@giselles-ai/agent 0.1.22 → 0.1.24

package/dist/chunk-TAQV6ZOB.js

@@ -0,0 +1,75 @@
+// src/hash.ts
+import { createHash } from "crypto";
+function computeConfigHash(config) {
+  const payload = JSON.stringify({
+    agentType: config.agentType ?? "gemini",
+    agentMd: config.agentMd ?? null,
+    files: (config.files ?? []).map((f) => ({
+      path: f.path,
+      content: f.content
+    }))
+  });
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+
+// src/request-build.ts
+function trimTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function resolveFiles(agent) {
+  const files = [
+    ...agent.files ?? []
+  ];
+  if (agent.agentMd !== void 0) {
+    files.push(
+      {
+        path: "/home/vercel-sandbox/.codex/AGENTS.md",
+        content: agent.agentMd
+      },
+      {
+        path: "/home/vercel-sandbox/.gemini/GEMINI.md",
+        content: agent.agentMd
+      }
+    );
+  }
+  return files;
+}
+async function requestBuild(agent, options) {
+  const baseUrl = trimTrailingSlash(
+    options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api"
+  );
+  const apiUrl = `${baseUrl}/build`;
+  const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
+  if (!token) {
+    throw new Error(
+      "Missing API token. Set GISELLE_AGENT_API_KEY or pass options.token."
+    );
+  }
+  const configHash = computeConfigHash(agent);
+  const files = resolveFiles(agent);
+  const requestBody = {
+    config_hash: configHash,
+    agent_type: agent.agentType ?? "gemini",
+    files
+  };
+  const requestHeaders = {
+    "content-type": "application/json",
+    authorization: `Bearer ${token}`,
+    ...options?.headers
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: requestHeaders,
+    body: JSON.stringify(requestBody)
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`Build failed (${response.status}): ${body}`);
+  }
+  return await response.json();
+}
+
+export {
+  computeConfigHash,
+  requestBuild
+};

package/dist/index.d.ts

@@ -5,4 +5,18 @@ declare function defineAgent(config: AgentConfig): DefinedAgent;
 
 declare function computeConfigHash(config: AgentConfig): string;
 
-export { AgentConfig, DefinedAgent, computeConfigHash, defineAgent };
+type RequestBuildOptions = {
+    /** Base URL for the agent API. Default: process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api" */
+    baseUrl?: string;
+    /** Bearer token. Default: process.env.GISELLE_AGENT_API_KEY */
+    token?: string;
+    /** Additional headers to include in the build API request */
+    headers?: Record<string, string | undefined>;
+};
+type BuildResult = {
+    snapshot_id: string;
+    cached: boolean;
+};
+declare function requestBuild(agent: AgentConfig, options?: RequestBuildOptions): Promise<BuildResult>;
+
+export { AgentConfig, type BuildResult, DefinedAgent, type RequestBuildOptions, computeConfigHash, defineAgent, requestBuild };

package/dist/index.js

@@ -1,6 +1,7 @@
 import {
-  computeConfigHash
-} from "./chunk-K2DPJIHU.js";
+  computeConfigHash,
+  requestBuild
+} from "./chunk-TAQV6ZOB.js";
 
 // src/define-agent.ts
 function defineAgent(config) {
@@ -21,5 +22,6 @@ function defineAgent(config) {
 }
 export {
   computeConfigHash,
-  defineAgent
+  defineAgent,
+  requestBuild
 };

package/dist/next/index.d.ts

@@ -10,6 +10,6 @@ type GiselleAgentPluginOptions = {
     headers?: Record<string, string | undefined>;
 };
 
-declare function withGiselleAgent(nextConfig: NextConfig, agent: AgentConfig, options?: GiselleAgentPluginOptions): () => Promise<NextConfig>;
+declare function withGiselleAgent(nextConfig: NextConfig, agent: AgentConfig, options?: GiselleAgentPluginOptions): (phase: string) => Promise<NextConfig>;
 
 export { type GiselleAgentPluginOptions, withGiselleAgent };

package/dist/next/index.js

@@ -1,73 +1,112 @@
 import {
-  computeConfigHash
-} from "../chunk-K2DPJIHU.js";
+  requestBuild
+} from "../chunk-TAQV6ZOB.js";
 
 // src/next/with-giselle-agent.ts
-function trimTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
+import crypto from "crypto";
+import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+var { version: PKG_VERSION } = require2("../../package.json");
+var bold = (s) => `\x1B[1m${s}\x1B[22m`;
+var green = (s) => `\x1B[32m${s}\x1B[39m`;
+var red = (s) => `\x1B[31m${s}\x1B[39m`;
+var magenta = (s) => `\x1B[35m${s}\x1B[39m`;
+var dim = (s) => `\x1B[2m${s}\x1B[22m`;
+function resolveBaseUrl(options) {
+  return (options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api").replace(/\/+$/, "");
+}
+function getSnapshotFile(agent) {
+  const key = {
+    agentType: agent.agentType,
+    agentMd: agent.agentMd,
+    files: agent.files
+  };
+  const hash = crypto.createHash("sha256").update(JSON.stringify(key)).digest("hex").slice(0, 16);
+  return path.join(process.cwd(), ".next", "giselle", hash);
+}
+function hasRunRecently() {
+  const lockFile = path.join(process.cwd(), ".next", "giselle", ".lock");
+  try {
+    const ts = Number(fs.readFileSync(lockFile, "utf-8").trim());
+    if (Date.now() - ts < 2e3) {
+      return true;
+    }
+  } catch {
+  }
+  fs.mkdirSync(path.dirname(lockFile), { recursive: true });
+  fs.writeFileSync(lockFile, String(Date.now()));
+  return false;
 }
 function withGiselleAgent(nextConfig, agent, options) {
   return async () => {
-    const baseUrl = trimTrailingSlash(
-      options?.baseUrl ?? process.env.GISELLE_AGENT_BASE_URL ?? "https://studio.giselles.ai/agent-api"
-    );
-    const apiUrl = `${baseUrl}/build`;
-    const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
-    if (!token) {
-      console.warn("[withGiselleAgent] Skipped snapshot build: missing token.");
+    if (hasRunRecently()) {
       return nextConfig;
     }
-    const configHash = computeConfigHash(agent);
-    const files = [
-      ...agent.files ?? []
-    ];
-    if (agent.agentMd !== void 0) {
-      files.push(
-        {
-          path: "/home/vercel-sandbox/.codex/AGENTS.md",
-          content: agent.agentMd
-        },
-        {
-          path: "/home/vercel-sandbox/.gemini/GEMINI.md",
-          content: agent.agentMd
+    const baseUrl = resolveBaseUrl(options);
+    const snapshotFile = getSnapshotFile(agent);
+    const cached = fs.existsSync(snapshotFile) ? fs.readFileSync(snapshotFile, "utf-8").trim() : void 0;
+    if (cached) {
+      return {
+        ...nextConfig,
+        env: {
+          ...nextConfig.env,
+          GISELLE_AGENT_SNAPSHOT_ID: cached
         }
+      };
+    }
+    console.log("");
+    console.log(`${magenta(bold(`\u2726 Giselle Agent ${PKG_VERSION}`))}`);
+    console.log(`${dim("- Base URL:")} ${baseUrl}`);
+    console.log("");
+    const token = options?.token ?? process.env.GISELLE_AGENT_API_KEY;
+    if (!token) {
+      console.log(`${red("\u2717")} Missing API key`);
+      console.log("");
+      console.log(
+        "  Create an account at https://studio.giselles.ai and generate"
+      );
+      console.log(
+        "  an API key, then set it as GISELLE_AGENT_API_KEY in your environment."
       );
+      console.log("");
+      throw new Error("Missing GISELLE_AGENT_API_KEY");
     }
-    const requestBody = {
-      config_hash: configHash,
-      agent_type: agent.agentType ?? "gemini",
-      files
-    };
-    const requestHeaders = {
-      "content-type": "application/json",
-      authorization: `Bearer ${token}`,
-      ...options?.headers
-    };
-    console.debug("[withGiselleAgent] POST %s", apiUrl);
-    console.debug(
-      "[withGiselleAgent] headers:",
-      JSON.stringify(requestHeaders, null, 2)
-    );
-    console.debug(
-      "[withGiselleAgent] body:",
-      JSON.stringify(requestBody, null, 2)
-    );
-    const response = await fetch(apiUrl, {
+    const authResponse = await fetch(`${baseUrl}/auth`, {
       method: "POST",
-      headers: requestHeaders,
-      body: JSON.stringify(requestBody)
+      headers: {
+        authorization: `Bearer ${token}`,
+        ...options?.headers
+      }
     });
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(
-        `[withGiselleAgent] Build failed (${response.status}): ${body}`
+    if (!authResponse.ok) {
+      console.log(`${red("\u2717")} Authentication failed`);
+      console.log("");
+      console.log(
+        "  Create an account at https://studio.giselles.ai and generate"
+      );
+      console.log(
+        "  an API key, then set it as GISELLE_AGENT_API_KEY in your environment."
       );
+      console.log("");
+      throw new Error("Authentication failed");
     }
-    const result = await response.json();
-    console.debug(
-      "[withGiselleAgent] result:",
-      JSON.stringify(result, null, 2)
-    );
+    console.log(`${green("\u2713")} Authenticated`);
+    const start = performance.now();
+    const result = await requestBuild(agent, {
+      baseUrl: options?.baseUrl,
+      token,
+      headers: options?.headers
+    });
+    fs.mkdirSync(path.dirname(snapshotFile), { recursive: true });
+    fs.writeFileSync(snapshotFile, result.snapshot_id);
+    const elapsed = Math.round(performance.now() - start);
+    const elapsedStr = elapsed < 1e3 ? `${elapsed}ms` : `${(elapsed / 1e3).toFixed(1)}s`;
+    console.log(`${green("\u2713")} Building...`);
+    console.log(`${green("\u2713")} Ready in ${elapsedStr}`);
+    console.log("");
+    console.log("");
     return {
       ...nextConfig,
       env: {

package/dist/server/index.d.ts

@@ -3,30 +3,6 @@ import { z } from 'zod';
 import { RelayRequest, RelayResponse } from '@giselles-ai/browser-tool';
 import { RelayRequestSubscription } from '@giselles-ai/browser-tool/relay';
 
-type AgentType$1 = "codex" | "gemini";
-declare class Agent {
-    private _type;
-    private _snapshotId;
-    private _pendingOps;
-    private constructor();
-    static create(type: AgentType$1, options: {
-        snapshotId: string;
-    }): Agent;
-    get type(): AgentType$1;
-    get snapshotId(): string;
-    get dirty(): boolean;
-    addFiles(files: Array<{
-        path: string;
-        content: Buffer;
-    }>): this;
-    setAgentMd(content: string | Buffer): this;
-    runCommands(commands: Array<{
-        cmd: string;
-        args?: string[];
-    }>): this;
-    prepare(): Promise<void>;
-}
-
 type BaseChatRequest = {
     message: string;
     session_id?: string;
@@ -143,6 +119,7 @@ type CloudChatSessionState = {
     chatId: string;
     agentSessionId?: string;
     sandboxId?: string;
+    snapshotId?: string;
     relay?: CloudRelaySession;
     pendingTool?: PendingToolState | null;
     updatedAt: number;
@@ -150,6 +127,7 @@ type CloudChatSessionState = {
 type CloudChatSessionPatch = {
     agentSessionId?: string;
     sandboxId?: string;
+    snapshotId?: string;
     relay?: CloudRelaySession;
     pendingTool?: PendingToolState | null;
 };
@@ -251,4 +229,4 @@ declare function runCloudChat<TRequest extends CloudChatRequest & {
     }) => Promise<void>;
 }): Promise<Response>;
 
-export { Agent, type AgentApiOptions, type AgentApiStoreConfig, type AgentParam, type AgentRequest, type AgentType, type BaseChatRequest, type ChatAgent, type ChatCommand, type CloudChatRequest, type CloudChatRunRequest, type CloudChatSessionPatch, type CloudChatSessionState, type CloudChatStateStore, type CloudRelaySession, type CloudToolName, type CloudToolResult, type CreateAgentOptions, type PendingToolState, type RelaySessionFactoryResult, type RunChatImpl, type RunChatInput, type StdoutMapper, applyCloudChatPatch, cloudChatRunRequestSchema, createAgent, createAgentApi, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, reduceCloudChatEvent, runChat, runCloudChat, toolNameFromRelayRequest };
+export { type AgentApiOptions, type AgentApiStoreConfig, type AgentParam, type AgentRequest, type AgentType, type BaseChatRequest, type ChatAgent, type ChatCommand, type CloudChatRequest, type CloudChatRunRequest, type CloudChatSessionPatch, type CloudChatSessionState, type CloudChatStateStore, type CloudRelaySession, type CloudToolName, type CloudToolResult, type CreateAgentOptions, type PendingToolState, type RelaySessionFactoryResult, type RunChatImpl, type RunChatInput, type StdoutMapper, applyCloudChatPatch, cloudChatRunRequestSchema, createAgent, createAgentApi, createCodexAgent, createCodexStdoutMapper, createGeminiAgent, reduceCloudChatEvent, runChat, runCloudChat, toolNameFromRelayRequest };

package/dist/server/index.js

@@ -1,96 +1,41 @@
-// src/agent.ts
+// src/agent-api.ts
+import {
+  createRelayHandler,
+  createRelaySession
+} from "@giselles-ai/browser-tool/relay";
+
+// src/build.ts
 import { Sandbox } from "@vercel/sandbox";
-var Agent = class _Agent {
-  _type;
-  _snapshotId;
-  _pendingOps = [];
-  constructor(type, snapshotId) {
-    this._type = type;
-    this._snapshotId = snapshotId;
-  }
-  static create(type, options) {
-    const trimmed = options.snapshotId.trim();
-    if (!trimmed) {
-      throw new Error("snapshotId is required.");
-    }
-    return new _Agent(type, trimmed);
+var CACHE_KEY_PREFIX = "agent-build:snapshot:";
+var CACHE_TTL_SEC = 60 * 60 * 24;
+var memoryCache = /* @__PURE__ */ new Map();
+var MemorySnapshotCache = class {
+  async get(key2) {
+    return memoryCache.get(key2) ?? null;
   }
-  get type() {
-    return this._type;
+  async set(key2, value) {
+    memoryCache.set(key2, value);
   }
-  get snapshotId() {
-    return this._snapshotId;
+};
+var RedisSnapshotCache = class {
+  constructor(redis) {
+    this.redis = redis;
   }
-  get dirty() {
-    return this._pendingOps.length > 0;
+  async get(key2) {
+    return this.redis.get(`${CACHE_KEY_PREFIX}${key2}`);
   }
-  addFiles(files) {
-    if (files.length === 0) {
-      return this;
-    }
-    this._pendingOps.push({
-      kind: "writeFiles",
-      files
-    });
-    return this;
-  }
-  setAgentMd(content) {
-    const buffer = typeof content === "string" ? Buffer.from(content) : content;
-    console.log(`[agent] setAgentMd called, content length=${buffer.length}`);
-    return this.addFiles([
-      { path: "/home/vercel-sandbox/.codex/AGENTS.md", content: buffer }
-    ]);
-  }
-  runCommands(commands) {
-    for (const command of commands) {
-      this._pendingOps.push({
-        kind: "runCommand",
-        cmd: command.cmd,
-        args: command.args ?? []
-      });
-    }
-    return this;
-  }
-  async prepare() {
-    console.log(
-      `[agent] prepare called, dirty=${this.dirty}, pendingOps=${this._pendingOps.length}`
-    );
-    if (!this.dirty) {
-      return;
-    }
-    const ops = this._pendingOps;
-    const sandbox = await Sandbox.create({
-      source: { type: "snapshot", snapshotId: this._snapshotId }
-    });
-    console.log(
-      `[sandbox] created sandbox=${sandbox.sandboxId} from snapshot=${this._snapshotId}`
+  async set(key2, value) {
+    await this.redis.set(
+      `${CACHE_KEY_PREFIX}${key2}`,
+      value,
+      "EX",
+      CACHE_TTL_SEC
     );
-    for (const op of ops) {
-      switch (op.kind) {
-        case "writeFiles":
-          await sandbox.writeFiles(op.files);
-          break;
-        case "runCommand":
-          await sandbox.runCommand(op.cmd, op.args);
-          break;
-      }
-    }
-    const snapshot = await sandbox.snapshot();
-    console.log(`[agent] prepare done, new snapshotId=${snapshot.snapshotId}`);
-    this._snapshotId = snapshot.snapshotId;
-    this._pendingOps = [];
   }
 };
-
-// src/agent-api.ts
-import {
-  createRelayHandler,
-  createRelaySession
-} from "@giselles-ai/browser-tool/relay";
-
-// src/build.ts
-import { Sandbox as Sandbox2 } from "@vercel/sandbox";
-var snapshotCache = /* @__PURE__ */ new Map();
+function createSnapshotCache(redis) {
+  return redis ? new RedisSnapshotCache(redis) : new MemorySnapshotCache();
+}
 function resolveBaseSnapshotId(configured) {
   const envValue = process.env.GISELLE_AGENT_SANDBOX_BASE_SNAPSHOT_ID?.trim();
   if (envValue) {
@@ -136,6 +81,7 @@ function parseBuildRequest(body) {
   };
 }
 async function buildAgent(input) {
+  const cache = input.cache ?? new MemorySnapshotCache();
   const body = await input.request.json().catch(() => null);
   const parsed = parseBuildRequest(body);
   if (!parsed) {
@@ -155,7 +101,7 @@ async function buildAgent(input) {
     );
   }
   const cacheKey = `${baseSnapshotId}:${parsed.config_hash}`;
-  const cached = snapshotCache.get(cacheKey);
+  const cached = await cache.get(cacheKey);
   if (cached) {
     console.log(
       `[agent-build] cache hit: hash=${cacheKey} -> snapshot=${cached}`
@@ -163,7 +109,7 @@ async function buildAgent(input) {
     const response2 = { snapshot_id: cached, cached: true };
     return Response.json(response2);
   }
-  const sandbox = await Sandbox2.create({
+  const sandbox = await Sandbox.create({
     source: { type: "snapshot", snapshotId: baseSnapshotId }
   });
   console.log(
@@ -179,7 +125,7 @@ async function buildAgent(input) {
   }
   const snapshot = await sandbox.snapshot();
   console.log(`[agent-build] snapshot created: ${snapshot.snapshotId}`);
-  snapshotCache.set(cacheKey, snapshot.snapshotId);
+  await cache.set(cacheKey, snapshot.snapshotId);
   const response = {
     snapshot_id: snapshot.snapshotId,
     cached: false
@@ -603,7 +549,7 @@ function createAgent(options) {
 
 // src/chat-run.ts
 import { Writable } from "stream";
-import { Sandbox as Sandbox3 } from "@vercel/sandbox";
+import { Sandbox as Sandbox2 } from "@vercel/sandbox";
 function emitText(controller, text, encoder) {
   if (text.length === 0) {
     return;
@@ -657,23 +603,39 @@ function runChat(input) {
       const mapper = input.agent.createStdoutMapper?.();
       void (async () => {
         try {
-          const sandbox = parsed.sandbox_id ? await Sandbox3.get({ sandboxId: parsed.sandbox_id }) : await (async () => {
-            const snapshotId = parsed.snapshot_id?.trim() || input.agent.snapshotId?.trim();
-            if (!snapshotId) {
-              throw new Error(
-                "Agent must provide snapshotId when sandbox_id is not provided."
-              );
-            }
-            const created = await Sandbox3.create({
+          const createFromSnapshot = async (snapshotId2) => {
+            const created = await Sandbox2.create({
               source: {
                 type: "snapshot",
-                snapshotId
+                snapshotId: snapshotId2
               }
             });
             console.log(
-              `[sandbox] created sandbox=${created.sandboxId} from snapshot=${snapshotId}`
+              `[sandbox] created sandbox=${created.sandboxId} from snapshot=${snapshotId2}`
             );
             return created;
+          };
+          const snapshotId = parsed.snapshot_id?.trim() || input.agent.snapshotId?.trim();
+          const sandbox = await (async () => {
+            if (parsed.sandbox_id) {
+              try {
+                return await Sandbox2.get({ sandboxId: parsed.sandbox_id });
+              } catch (error) {
+                if (!snapshotId) {
+                  throw error;
+                }
+                console.log(
+                  `[sandbox] sandbox=${parsed.sandbox_id} expired, recreating from snapshot=${snapshotId}`
+                );
+                return createFromSnapshot(snapshotId);
+              }
+            }
+            if (!snapshotId) {
+              throw new Error(
+                "Agent must provide snapshotId when sandbox_id is not provided."
+              );
+            }
+            return createFromSnapshot(snapshotId);
           })();
           enqueueEvent({ type: "sandbox", sandbox_id: sandbox.sandboxId });
           await input.agent.prepareSandbox({
@@ -710,6 +672,11 @@ function runChat(input) {
             }),
             signal: abortController.signal
           });
+          const snapshot = await sandbox.snapshot();
+          enqueueEvent({
+            type: "snapshot",
+            snapshot_id: snapshot.snapshotId
+          });
         } catch (error) {
           if (abortController.signal.aborted) {
             return;
@@ -825,6 +792,9 @@ function reduceCloudChatEvent(event) {
   if (event.type === "sandbox" && typeof event.sandbox_id === "string") {
     return { sandboxId: event.sandbox_id };
   }
+  if (event.type === "snapshot" && typeof event.snapshot_id === "string") {
+    return { snapshotId: event.snapshot_id };
+  }
   if (event.type === "relay.session" && typeof event.sessionId === "string" && typeof event.token === "string" && typeof event.relayUrl === "string" && typeof event.expiresAt === "number") {
     return {
       relay: {
@@ -865,6 +835,7 @@ function applyCloudChatPatch(input) {
     chatId: input.chatId,
     agentSessionId: input.patch?.agentSessionId ?? input.base?.agentSessionId,
     sandboxId: input.patch?.sandboxId ?? input.base?.sandboxId,
+    snapshotId: input.patch?.snapshotId ?? input.base?.snapshotId,
     relay: input.patch?.relay ?? input.base?.relay,
     pendingTool: input.patch?.pendingTool !== void 0 ? input.patch.pendingTool : input.base?.pendingTool,
     updatedAt: input.now
@@ -986,6 +957,7 @@ async function runCloudChat(input) {
     ...input.request,
     ...existing?.agentSessionId ? { session_id: existing.agentSessionId } : {},
     ...existing?.sandboxId ? { sandbox_id: existing.sandboxId } : {},
+    ...existing?.snapshotId ? { snapshot_id: existing.snapshotId } : {},
     relay_session_id: relaySession.sessionId,
     relay_token: relaySession.token
   };
@@ -1086,6 +1058,7 @@ async function resumeCloudChat(input) {
     ...input.request,
     ...input.existing.agentSessionId ? { session_id: input.existing.agentSessionId } : {},
     ...input.existing.sandboxId ? { sandbox_id: input.existing.sandboxId } : {},
+    ...input.existing.snapshotId ? { snapshot_id: input.existing.snapshotId } : {},
     relay_session_id: relaySession.sessionId,
     relay_token: relaySession.token
   };
@@ -1328,14 +1301,10 @@ function continueManagedCloudResponseFromLiveConnection(input) {
   return managed.response;
 }
 
-// src/cloud-chat-store.ts
-var CHAT_STATE_TTL_SEC = 60 * 60;
+// src/redis.ts
 var REDIS_URL_ENV_NAME = "REDIS_URL";
-function key(chatId) {
-  return `cloud-chat:${chatId}`;
-}
 function resolveRedisUrl(url) {
-  const resolved = url?.trim() || process.env.REDIS_URL?.trim();
+  const resolved = url?.trim() || process.env[REDIS_URL_ENV_NAME]?.trim();
   if (resolved) {
     return resolved;
   }
@@ -1343,6 +1312,26 @@ function resolveRedisUrl(url) {
     `Missing Redis URL. Set ${REDIS_URL_ENV_NAME} or pass store.url.`
   );
 }
+async function createRedisClient(url) {
+  let RedisCtor;
+  try {
+    const module = await import("ioredis");
+    RedisCtor = module.default;
+  } catch {
+    throw new Error(
+      "Redis store adapter requires `ioredis` to be installed as a peer dependency."
+    );
+  }
+  return new RedisCtor(resolveRedisUrl(url), {
+    maxRetriesPerRequest: 2
+  });
+}
+
+// src/cloud-chat-store.ts
+var CHAT_STATE_TTL_SEC = 60 * 60;
+function key(chatId) {
+  return `cloud-chat:${chatId}`;
+}
 var RedisCloudChatStateStore = class {
   constructor(redis) {
     this.redis = redis;
@@ -1363,25 +1352,12 @@ var RedisCloudChatStateStore = class {
     await this.redis.del(key(chatId));
   }
 };
-async function createRedisStore(url) {
-  let RedisCtor;
-  try {
-    const module = await import("ioredis");
-    RedisCtor = module.default;
-  } catch {
-    throw new Error(
-      "Redis store adapter requires `ioredis` to be installed as a peer dependency."
-    );
-  }
-  const redis = new RedisCtor(resolveRedisUrl(url), {
-    maxRetriesPerRequest: 2
-  });
-  return new RedisCloudChatStateStore(redis);
-}
 async function resolveCloudChatStateStore(store) {
   switch (store.adapter) {
-    case "redis":
-      return createRedisStore(store.url);
+    case "redis": {
+      const redis = await createRedisClient(store.url);
+      return new RedisCloudChatStateStore(redis);
+    }
   }
 }
 
@@ -1413,6 +1389,8 @@ function createAgentApi(options) {
   const relay = createRelayHandler();
   const { basePath, agent: agentOptions } = options;
   let storePromise = null;
+  let snapshotCachePromise = null;
+  const authPath = `${basePath}/auth`;
   const runPath = `${basePath}/run`;
   const buildPath = `${basePath}/build`;
   const relayPrefix = `${basePath}/relay`;
@@ -1420,6 +1398,13 @@ function createAgentApi(options) {
     storePromise ??= resolveCloudChatStateStore(options.store);
     return storePromise;
   }
+  function getSnapshotCache() {
+    snapshotCachePromise ??= (async () => {
+      const redis = await createRedisClient(options.store.url);
+      return createSnapshotCache(redis);
+    })();
+    return snapshotCachePromise;
+  }
   async function handleBuild(request) {
     const baseSnapshotId = process.env.GISELLE_AGENT_SANDBOX_BASE_SNAPSHOT_ID?.trim() || options.build?.baseSnapshotId;
     if (!options.build && !baseSnapshotId) {
@@ -1432,7 +1417,8 @@ function createAgentApi(options) {
       }
       return await buildAgent({
         request,
-        baseSnapshotId
+        baseSnapshotId,
+        cache: await getSnapshotCache()
       });
     } catch (error) {
       const message = error instanceof Error ? error.message : "Failed to process build request.";
@@ -1478,9 +1464,24 @@ function createAgentApi(options) {
       return errorResponse(500, "INTERNAL_ERROR", message);
     }
   }
+  async function handleAuth(request) {
+    try {
+      const hookResult = await options.hooks?.build?.before?.(request);
+      if (hookResult instanceof Response) {
+        return hookResult;
+      }
+      return Response.json({ ok: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Authentication failed.";
+      return errorResponse(401, "UNAUTHORIZED", message);
+    }
+  }
   function matchSubPath(request) {
     const url = new URL(request.url);
     const pathname = url.pathname;
+    if (pathname === authPath || pathname === `${authPath}/`) {
+      return "auth";
+    }
     if (pathname === runPath || pathname === `${runPath}/`) {
       return "run";
     }
@@ -1502,6 +1503,9 @@ function createAgentApi(options) {
     },
     POST: async (request) => {
       const sub = matchSubPath(request);
+      if (sub === "auth") {
+        return handleAuth(request);
+      }
       if (sub === "run") {
         return handleRun(request);
       }
@@ -1523,7 +1527,6 @@ function createAgentApi(options) {
   };
 }
 export {
-  Agent,
   applyCloudChatPatch,
   cloudChatRunRequestSchema,
   createAgent,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/agent",
-	"version": "0.1.22",
+	"version": "0.1.24",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",
@@ -37,7 +37,7 @@
 		"format": "pnpm exec biome check --write ."
 	},
 	"dependencies": {
-		"@giselles-ai/browser-tool": "0.1.22",
+		"@giselles-ai/browser-tool": "0.1.24",
 		"@vercel/sandbox": "1.6.0",
 		"@iarna/toml": "3.0.0",
 		"zod": "4.3.6"

package/dist/chunk-K2DPJIHU.js

@@ -1,17 +0,0 @@
-// src/hash.ts
-import { createHash } from "crypto";
-function computeConfigHash(config) {
-  const payload = JSON.stringify({
-    agentType: config.agentType ?? "gemini",
-    agentMd: config.agentMd ?? null,
-    files: (config.files ?? []).map((f) => ({
-      path: f.path,
-      content: f.content
-    }))
-  });
-  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-
-export {
-  computeConfigHash
-};