experimental-agent 0.0.2 → 0.0.4

package/dist/agent-workflow.js

@@ -33,13 +33,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/sandbox/process-manager.ts
 var process_manager_exports = {};
 __export(process_manager_exports, {
+  DEFAULT_WAIT_UNTIL: () => DEFAULT_WAIT_UNTIL,
   createProcessManager: () => createProcessManager
 });
 var DEFAULT_WAIT_UNTIL, RUN_SCRIPT, createProcessManager;
 var init_process_manager = __esm({
   "src/sandbox/process-manager.ts"() {
     "use strict";
-    DEFAULT_WAIT_UNTIL = 3e4;
+    DEFAULT_WAIT_UNTIL = 2e3;
     RUN_SCRIPT = `#!/bin/sh
 # Process runner for Agent SDK
 # All parameters passed via environment variables to avoid escaping issues
@@ -229,348 +230,21 @@ var init_errors = __esm({
   }
 });
 
-// src/utils/paginate.ts
-function paginate(opts) {
-  const { items, cursor, limit = 50 } = opts;
-  const startIndex = cursor ? items.findIndex((m) => m.id === cursor) + 1 : 0;
-  const sliced = items.slice(startIndex, startIndex + limit);
-  const nextCursor = startIndex + limit < items.length ? sliced.at(-1)?.id ?? null : null;
-  return { items: sliced, nextCursor };
-}
-var init_paginate = __esm({
-  "src/utils/paginate.ts"() {
-    "use strict";
-  }
-});
-
-// src/storage/bindings/local-fs-handlers.ts
-function createFilesystemHandlers(basePath) {
-  const sessionDir = (0, import_node_path.join)(basePath, "session");
-  const messageDir = (0, import_node_path.join)(basePath, "message");
-  const partDir = (0, import_node_path.join)(basePath, "part");
-  const sandboxDir = (0, import_node_path.join)(basePath, "sandbox");
-  const commandDir = (0, import_node_path.join)(basePath, "command");
-  async function ensureDir(dir) {
-    await (0, import_promises.mkdir)(dir, { recursive: true });
-  }
-  async function readJson(filePath) {
-    try {
-      const content = await (0, import_promises.readFile)(filePath, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  async function writeJsonFile(filePath, data) {
-    await ensureDir((0, import_node_path.dirname)(filePath));
-    await (0, import_promises.writeFile)(filePath, JSON.stringify(data, null, 2));
-  }
-  async function readAllFromDir(dir) {
-    try {
-      const files = await (0, import_promises.readdir)(dir);
-      const results = await Promise.all(
-        files.filter((f) => f.endsWith(".json")).map((f) => readJson((0, import_node_path.join)(dir, f)))
-      );
-      return results.filter((r) => r !== null);
-    } catch {
-      return [];
-    }
-  }
-  return {
-    "session.get": async ({ id }) => {
-      const session = await readJson((0, import_node_path.join)(sessionDir, `${id}.json`));
-      return session ?? null;
-    },
-    "session.set": async (session) => {
-      const now = Date.now();
-      const sessionPath = (0, import_node_path.join)(sessionDir, `${session.id}.json`);
-      const existing = await readJson(sessionPath);
-      const newSession = {
-        ...session,
-        tags: session.tags ?? existing?.tags ?? {},
-        createdAt: existing?.createdAt ?? session.createdAt ?? now,
-        updatedAt: now
-      };
-      await writeJsonFile(sessionPath, newSession);
-      return newSession;
-    },
-    "session.list": async ({ tags, cursor, limit }) => {
-      const allSessions = await readAllFromDir(sessionDir);
-      let filtered = allSessions;
-      if (tags && Object.keys(tags).length > 0) {
-        filtered = filtered.filter((s) => {
-          const sessionTags = s.tags ?? {};
-          return Object.entries(tags).every(
-            ([key, value]) => sessionTags[key] === value
-          );
-        });
-      }
-      filtered.sort((a, b) => a.createdAt - b.createdAt);
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "session.listBySandbox": async ({ sandboxId, tags, cursor, limit }) => {
-      const allSessions = await readAllFromDir(sessionDir);
-      let filtered = allSessions.filter((s) => s.sandboxId === sandboxId);
-      if (tags && Object.keys(tags).length > 0) {
-        filtered = filtered.filter((s) => {
-          const sessionTags = s.tags ?? {};
-          return Object.entries(tags).every(
-            ([key, value]) => sessionTags[key] === value
-          );
-        });
-      }
-      filtered.sort((a, b) => a.createdAt - b.createdAt);
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "session.tag.set": async ({ sessionId, tags }) => {
-      const sessionPath = (0, import_node_path.join)(sessionDir, `${sessionId}.json`);
-      const existing = await readJson(sessionPath);
-      if (!existing) {
-        throw new Error(`Session ${sessionId} not found`);
-      }
-      const mergedTags = { ...existing.tags, ...tags };
-      const now = Date.now();
-      const updatedSession = {
-        ...existing,
-        tags: mergedTags,
-        updatedAt: now
-      };
-      await writeJsonFile(sessionPath, updatedSession);
-      return updatedSession;
-    },
-    "message.get": async ({ id }) => {
-      return await readJson((0, import_node_path.join)(messageDir, `${id}.json`));
-    },
-    "message.set": async (message) => {
-      await writeJsonFile((0, import_node_path.join)(messageDir, `${message.id}.json`), message);
-      return message;
-    },
-    "message.list": async ({ sessionId, cursor, limit }) => {
-      const allMessages = await readAllFromDir(messageDir);
-      const filtered = allMessages.filter((m) => m.sessionId === sessionId).sort((a, b) => a.createdAt - b.createdAt);
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "part.listByMessage": async ({ messageId, cursor, limit }) => {
-      const allParts = await readAllFromDir(partDir);
-      const filtered = allParts.filter((p) => p.messageId === messageId).sort((a, b) => a.index - b.index);
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "part.listBySession": async ({ sessionId, cursor, limit }) => {
-      const allParts = await readAllFromDir(partDir);
-      const filtered = allParts.filter((p) => p.sessionId === sessionId).sort((a, b) => {
-        if (a.messageId !== b.messageId) {
-          return a.messageId.localeCompare(b.messageId);
-        }
-        return a.index - b.index;
-      });
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "part.set": async (part) => {
-      await writeJsonFile((0, import_node_path.join)(partDir, `${part.id}.json`), part);
-      return part;
-    },
-    "sandbox.get": async ({ key }) => {
-      const safeName = Buffer.from(key).toString("base64url");
-      const sandboxPath = (0, import_node_path.join)(sandboxDir, `${safeName}.json`);
-      const data = await readJson(sandboxPath);
-      if (!data) {
-        return null;
-      }
-      return data;
-    },
-    "sandbox.set": async (record) => {
-      const safeName = Buffer.from(record.id).toString("base64url");
-      const sandboxPath = (0, import_node_path.join)(sandboxDir, `${safeName}.json`);
-      const existing = await readJson(sandboxPath);
-      const newRecord = {
-        ...record,
-        tags: record.tags ?? existing?.tags ?? null
-      };
-      await writeJsonFile(sandboxPath, newRecord);
-    },
-    "sandbox.list": async ({ tags, order, cursor, limit }) => {
-      const allSandboxes = await readAllFromDir(sandboxDir);
-      let filtered = allSandboxes;
-      if (tags && Object.keys(tags).length > 0) {
-        filtered = filtered.filter((s) => {
-          const sandboxTags = s.tags ?? {};
-          return Object.entries(tags).every(
-            ([key, value]) => sandboxTags[key] === value
-          );
-        });
-      }
-      const sortField = order?.startsWith("lastActivityAt") ? "lastActivityAt" : "createdAt";
-      const sortDir = order?.endsWith("_desc") ? -1 : 1;
-      filtered.sort(
-        (a, b) => sortDir * ((a[sortField] ?? 0) - (b[sortField] ?? 0))
-      );
-      return paginate({ items: filtered, cursor, limit });
-    },
-    "sandbox.tag.set": async ({ sandboxId, tags }) => {
-      const safeName = Buffer.from(sandboxId).toString("base64url");
-      const sandboxPath = (0, import_node_path.join)(sandboxDir, `${safeName}.json`);
-      const existing = await readJson(sandboxPath);
-      if (!existing) {
-        throw new Error(`Sandbox ${sandboxId} not found`);
-      }
-      const mergedTags = { ...existing.tags, ...tags };
-      const updatedSandbox = {
-        ...existing,
-        tags: mergedTags
-      };
-      await writeJsonFile(sandboxPath, updatedSandbox);
-      return updatedSandbox;
-    },
-    "sandbox.getBySession": async ({ sessionId }) => {
-      const allSandboxes = await readAllFromDir(sandboxDir);
-      const matching = allSandboxes.filter(
-        (s) => s.id.startsWith(`${sessionId}-`)
-      );
-      if (matching.length === 0) {
-        return null;
-      }
-      matching.sort(
-        (a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0)
-      );
-      return matching[0];
-    },
-    "command.get": async ({ id }) => {
-      return await readJson((0, import_node_path.join)(commandDir, `${id}.json`));
-    },
-    "command.set": async (command) => {
-      await writeJsonFile((0, import_node_path.join)(commandDir, `${command.id}.json`), command);
-      return command;
-    },
-    "command.list": async ({ sessionId, includeFinished, cursor, limit }) => {
-      const allCommands = await readAllFromDir(commandDir);
-      let filtered = allCommands.filter((c) => c.sessionId === sessionId);
-      if (!includeFinished) {
-        filtered = filtered.filter((c) => c.status === "running");
-      }
-      filtered.sort((a, b) => a.startedAt - b.startedAt);
-      return paginate({ items: filtered, cursor, limit });
-    }
-  };
-}
-var import_promises, import_node_path;
-var init_local_fs_handlers = __esm({
-  "src/storage/bindings/local-fs-handlers.ts"() {
-    "use strict";
-    import_promises = require("fs/promises");
-    import_node_path = require("path");
-    init_paginate();
-  }
-});
-
-// src/storage/bindings/local.ts
-var local_exports = {};
-__export(local_exports, {
-  startLocalStorage: () => startLocalStorage,
-  stopLocalStorage: () => stopLocalStorage
-});
-function startLocalStorage(opts) {
-  if (startPromise) {
-    return startPromise;
-  }
-  startPromise = new Promise((resolve) => {
-    const handlers = createFilesystemHandlers(
-      opts?.path ?? DEFAULT_STORAGE_DIR
-    );
-    const app = new import_hono.Hono();
-    app.post("/", async (c) => {
-      const body = await c.req.json();
-      const response = await handleStorageRpc(body, handlers);
-      return c.json(response);
-    });
-    const port = opts?.port ?? 0;
-    const server = (0, import_node_server.serve)({
-      fetch: app.fetch,
-      port
-    });
-    server.on("listening", () => {
-      const address = server.address();
-      const actualPort = typeof address === "object" ? address?.port : port;
-      const url = `http://localhost:${actualPort}`;
-      serverInstance = { url, server };
-      console.log(`[agent] Local storage server started at ${url}`);
-      resolve(url);
-    });
-  });
-  return startPromise;
-}
-function stopLocalStorage() {
-  if (serverInstance) {
-    serverInstance.server.close();
-    serverInstance = null;
-    startPromise = null;
-  }
-}
-var import_node_server, import_hono, DEFAULT_STORAGE_DIR, startPromise, serverInstance;
-var init_local = __esm({
-  "src/storage/bindings/local.ts"() {
-    "use strict";
-    import_node_server = require("@hono/node-server");
-    import_hono = require("hono");
-    init_storage();
-    init_local_fs_handlers();
-    DEFAULT_STORAGE_DIR = ".agent-storage";
-    startPromise = null;
-    serverInstance = null;
-    if (typeof process !== "undefined") {
-      process.on("SIGTERM", stopLocalStorage);
-      process.on("SIGINT", stopLocalStorage);
-    }
-  }
-});
-
-// src/storage/bindings/vercel.ts
-var vercel_exports = {};
-__export(vercel_exports, {
-  getVercelStorageConfig: () => getVercelStorageConfig
-});
-async function getVercelStorageConfig() {
-  let token = null;
-  try {
-    const { getVercelOidcToken } = await import("@vercel/oidc");
-    token = await getVercelOidcToken();
-  } catch {
-  }
-  return {
-    url: VERCEL_STORAGE_URL,
-    headers: token ? { Authorization: `Bearer ${token}` } : {}
-  };
-}
-var VERCEL_STORAGE_URL;
-var init_vercel = __esm({
-  "src/storage/bindings/vercel.ts"() {
-    "use strict";
-    VERCEL_STORAGE_URL = "https://agent-sdk-storage-nine.labs.vercel.dev/api/storage";
-  }
-});
-
 // src/storage/client.ts
 var client_exports = {};
 __export(client_exports, {
+  DEFAULT_NAMESPACE: () => DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION: () => LOCAL_STORAGE_VERSION,
   getStorage: () => getStorage,
   getStorageClient: () => getStorageClient
 });
-function getStorageClient({ url, headers }) {
+function getStorageClient(rpcFn, name) {
   async function rpc(method, params) {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...headers },
-      body: JSON.stringify({ method, params })
-    });
-    if (!res.ok) {
-      throw new StorageError({
-        reason: `HTTP ${res.status}: ${res.statusText}`
-      });
+    const result = await rpcFn({ name, method, params });
+    if ("error" in result) {
+      throw new StorageError({ reason: result.error.message });
     }
-    const json = await res.json();
-    if ("error" in json) {
-      throw new StorageError({ reason: json.error.message });
-    }
-    return json.result;
+    return result.result;
   }
   return {
     session: {
@@ -706,6 +380,16 @@ function getStorageClient({ url, headers }) {
           }
           return new StorageError({ reason: String(e), cause: e });
         }
+      },
+      delete: async (id) => {
+        try {
+          await rpc("part.delete", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
       }
     },
     sandbox: {
@@ -816,383 +500,17 @@ function getStorageClient({ url, headers }) {
     }
   };
 }
-async function resolveStorageUrl(config) {
-  switch (config.type) {
-    case "local": {
-      const { startLocalStorage: startLocalStorage2 } = await Promise.resolve().then(() => (init_local(), local_exports));
-      return { url: await startLocalStorage2({ path: config.path }) };
-    }
-    case "vercel": {
-      const { getVercelStorageConfig: getVercelStorageConfig2 } = await Promise.resolve().then(() => (init_vercel(), vercel_exports));
-      return getVercelStorageConfig2();
-    }
-    case "custom": {
-      return { url: config.url, headers: config.headers };
-    }
-    default: {
-      config;
-      throw new Error(
-        `Unknown storage type: ${config.type}`
-      );
-    }
-  }
-}
-function getStorage(storageConfig) {
-  let clientPromise = null;
-  const getClient = () => {
-    if (!clientPromise) {
-      clientPromise = resolveStorageUrl(storageConfig).then(
-        (resolved) => getStorageClient(resolved)
-      );
-    }
-    return clientPromise;
-  };
-  return {
-    session: {
-      get: async (id) => (await getClient()).session.get(id),
-      set: async (session) => (await getClient()).session.set(session),
-      list: async (opts) => (await getClient()).session.list(opts),
-      tag: {
-        set: async (opts) => (await getClient()).session.tag.set(opts)
-      }
-    },
-    message: {
-      list: async (sessionId, opts) => (await getClient()).message.list(sessionId, opts),
-      get: async (id) => (await getClient()).message.get(id),
-      set: async (message) => (await getClient()).message.set(message)
-    },
-    part: {
-      listByMessage: async (messageId, opts) => (await getClient()).part.listByMessage(messageId, opts),
-      listBySession: async (sessionId, opts) => (await getClient()).part.listBySession(sessionId, opts),
-      set: async (part) => (await getClient()).part.set(part)
-    },
-    sandbox: {
-      get: async (key) => (await getClient()).sandbox.get(key),
-      set: async (opts) => (await getClient()).sandbox.set(opts),
-      getBySession: async (sessionId) => (await getClient()).sandbox.getBySession(sessionId),
-      list: async (opts) => (await getClient()).sandbox.list(opts),
-      tag: {
-        set: async (opts) => (await getClient()).sandbox.tag.set(opts)
-      }
-    },
-    command: {
-      get: async (id) => (await getClient()).command.get(id),
-      set: async (command) => (await getClient()).command.set(command),
-      list: async (sessionId, opts) => (await getClient()).command.list(sessionId, opts)
-    }
-  };
+function getStorage(opts) {
+  const name = opts.config.name ?? DEFAULT_NAMESPACE;
+  return getStorageClient(opts.rpc, name);
 }
+var DEFAULT_NAMESPACE, LOCAL_STORAGE_VERSION;
 var init_client = __esm({
   "src/storage/client.ts"() {
     "use strict";
     init_errors();
-  }
-});
-
-// src/storage/rpc.ts
-function ListResultSchema(itemSchema) {
-  return import_zod2.z.object({
-    items: import_zod2.z.array(itemSchema),
-    nextCursor: import_zod2.z.string().nullable()
-  });
-}
-var import_zod2, VercelLifecycleConfigSchema, SandboxConfigSchema, SessionSchema, MessageSchema, PartSchema, CommandResultSchema, SandboxRecordSchema, CommandBaseSchema, CommandSchema, methods;
-var init_rpc = __esm({
-  "src/storage/rpc.ts"() {
-    "use strict";
-    import_zod2 = require("zod");
-    VercelLifecycleConfigSchema = import_zod2.z.object({
-      stopAfterInactiveMs: import_zod2.z.number().optional(),
-      snapshotBeforeTimeoutMs: import_zod2.z.number().optional(),
-      snapshotId: import_zod2.z.string().optional(),
-      autoStart: import_zod2.z.boolean().optional()
-    });
-    SandboxConfigSchema = import_zod2.z.discriminatedUnion("type", [
-      import_zod2.z.object({
-        type: import_zod2.z.literal("vercel"),
-        resources: import_zod2.z.object({ vcpus: import_zod2.z.number() }).optional(),
-        ports: import_zod2.z.array(import_zod2.z.number()).optional(),
-        lifecycle: VercelLifecycleConfigSchema.optional()
-      }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("local"),
-        path: import_zod2.z.string().optional()
-      }),
-      import_zod2.z.object({
-        type: import_zod2.z.literal("custom"),
-        url: import_zod2.z.string(),
-        headers: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
-      })
-    ]);
-    SessionSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      createdAt: import_zod2.z.number(),
-      updatedAt: import_zod2.z.number(),
-      runId: import_zod2.z.string().nullable(),
-      lastMessageId: import_zod2.z.string().nullable(),
-      tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).nullable(),
-      instructions: import_zod2.z.string().nullable(),
-      model: import_zod2.z.string().nullable(),
-      mcp: import_zod2.z.unknown().nullable(),
-      // TODO
-      sandboxId: import_zod2.z.string().nullable(),
-      skillsDir: import_zod2.z.array(import_zod2.z.string()).nullable(),
-      hookToken: import_zod2.z.string().nullable()
-    });
-    MessageSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      sessionId: import_zod2.z.string(),
-      role: import_zod2.z.enum(["user", "assistant", "system"]),
-      createdAt: import_zod2.z.number(),
-      completedAt: import_zod2.z.number().nullable(),
-      interruptedAt: import_zod2.z.number().nullable(),
-      mcpContext: import_zod2.z.unknown().nullable()
-    });
-    PartSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      messageId: import_zod2.z.string(),
-      sessionId: import_zod2.z.string(),
-      index: import_zod2.z.number(),
-      part: import_zod2.z.unknown()
-    });
-    CommandResultSchema = import_zod2.z.object({
-      stdout: import_zod2.z.string(),
-      stderr: import_zod2.z.string(),
-      exitCode: import_zod2.z.number(),
-      completedAt: import_zod2.z.number()
-    });
-    SandboxRecordSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      config: SandboxConfigSchema,
-      tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).nullable(),
-      createdAt: import_zod2.z.number().nullable(),
-      lastActivityAt: import_zod2.z.number().nullable(),
-      acquiringLockId: import_zod2.z.string().nullable(),
-      acquiringLockAt: import_zod2.z.number().nullable(),
-      providerMetadata: import_zod2.z.discriminatedUnion("provider", [
-        import_zod2.z.object({
-          provider: import_zod2.z.literal("vercel"),
-          sandboxId: import_zod2.z.string().nullable(),
-          snapshotId: import_zod2.z.string().nullable()
-        })
-      ]).optional()
-    });
-    CommandBaseSchema = import_zod2.z.object({
-      id: import_zod2.z.string(),
-      sessionId: import_zod2.z.string(),
-      command: import_zod2.z.string(),
-      args: import_zod2.z.array(import_zod2.z.string()).optional(),
-      startedAt: import_zod2.z.number()
-    });
-    CommandSchema = import_zod2.z.discriminatedUnion("status", [
-      CommandBaseSchema.extend({ status: import_zod2.z.literal("running") }),
-      CommandBaseSchema.extend({
-        status: import_zod2.z.literal("completed"),
-        result: CommandResultSchema
-      }),
-      CommandBaseSchema.extend({
-        status: import_zod2.z.literal("killed"),
-        result: CommandResultSchema.optional()
-      }),
-      CommandBaseSchema.extend({
-        status: import_zod2.z.literal("failed"),
-        result: CommandResultSchema
-      })
-    ]);
-    methods = {
-      "session.get": {
-        params: import_zod2.z.object({ id: import_zod2.z.string() }),
-        result: SessionSchema.nullable()
-      },
-      "session.set": {
-        params: SessionSchema,
-        result: SessionSchema
-      },
-      "session.list": {
-        params: import_zod2.z.object({
-          tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
-          order: import_zod2.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "updatedAt_asc",
-            "updatedAt_desc"
-          ]).optional(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(SessionSchema)
-      },
-      "session.listBySandbox": {
-        params: import_zod2.z.object({
-          sandboxId: import_zod2.z.string(),
-          tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
-          order: import_zod2.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "updatedAt_asc",
-            "updatedAt_desc"
-          ]).optional(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(SessionSchema)
-      },
-      "session.tag.set": {
-        params: import_zod2.z.object({
-          sessionId: import_zod2.z.string(),
-          tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
-        }),
-        result: SessionSchema
-      },
-      "message.get": {
-        params: import_zod2.z.object({ id: import_zod2.z.string() }),
-        result: MessageSchema.nullable()
-      },
-      "message.set": {
-        params: MessageSchema,
-        result: MessageSchema
-      },
-      "message.list": {
-        params: import_zod2.z.object({
-          sessionId: import_zod2.z.string(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(MessageSchema)
-      },
-      "part.listByMessage": {
-        params: import_zod2.z.object({
-          messageId: import_zod2.z.string(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(PartSchema)
-      },
-      "part.listBySession": {
-        params: import_zod2.z.object({
-          sessionId: import_zod2.z.string(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(PartSchema)
-      },
-      "part.set": {
-        params: PartSchema,
-        result: PartSchema
-      },
-      "sandbox.get": {
-        params: import_zod2.z.object({ key: import_zod2.z.string() }),
-        result: SandboxRecordSchema.nullable()
-      },
-      "sandbox.getBySession": {
-        params: import_zod2.z.object({ sessionId: import_zod2.z.string() }),
-        result: SandboxRecordSchema.nullable()
-      },
-      "sandbox.set": {
-        params: SandboxRecordSchema,
-        result: import_zod2.z.void()
-      },
-      "sandbox.list": {
-        params: import_zod2.z.object({
-          tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
-          order: import_zod2.z.enum([
-            "createdAt_asc",
-            "createdAt_desc",
-            "lastActivityAt_asc",
-            "lastActivityAt_desc"
-          ]).optional(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(SandboxRecordSchema)
-      },
-      "sandbox.tag.set": {
-        params: import_zod2.z.object({
-          sandboxId: import_zod2.z.string(),
-          tags: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown())
-        }),
-        result: SandboxRecordSchema
-      },
-      "command.get": {
-        params: import_zod2.z.object({ id: import_zod2.z.string() }),
-        result: CommandSchema.nullable()
-      },
-      "command.set": {
-        params: CommandSchema,
-        result: CommandSchema
-      },
-      "command.list": {
-        params: import_zod2.z.object({
-          sessionId: import_zod2.z.string(),
-          includeFinished: import_zod2.z.boolean().optional(),
-          cursor: import_zod2.z.string().optional(),
-          limit: import_zod2.z.number().optional()
-        }),
-        result: ListResultSchema(CommandSchema)
-      }
-    };
-  }
-});
-
-// src/storage/handler.ts
-async function handleStorageRpc(body, handlers) {
-  const { method, params } = body;
-  if (!(method in methods)) {
-    return {
-      error: { code: "METHOD_NOT_FOUND", message: `Unknown method: ${method}` }
-    };
-  }
-  const methodName = method;
-  const schema = methods[methodName].params;
-  const parsed = schema.safeParse(params);
-  if (!parsed.success) {
-    return {
-      error: {
-        code: "INVALID_PARAMS",
-        message: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")
-      }
-    };
-  }
-  try {
-    const handler = handlers[methodName];
-    const result = await handler(parsed.data);
-    return { result };
-  } catch (e) {
-    return {
-      error: {
-        code: "INTERNAL_ERROR",
-        message: e instanceof Error ? e.message : String(e)
-      }
-    };
-  }
-}
-var init_handler = __esm({
-  "src/storage/handler.ts"() {
-    "use strict";
-    init_rpc();
-  }
-});
-
-// src/storage/index.ts
-var storage_exports = {};
-__export(storage_exports, {
-  CommandResultSchema: () => CommandResultSchema,
-  CommandSchema: () => CommandSchema,
-  MessageSchema: () => MessageSchema,
-  PartSchema: () => PartSchema,
-  SandboxConfigSchema: () => SandboxConfigSchema,
-  SandboxRecordSchema: () => SandboxRecordSchema,
-  SessionSchema: () => SessionSchema,
-  getStorage: () => getStorage,
-  handleStorageRpc: () => handleStorageRpc,
-  methods: () => methods
-});
-var init_storage = __esm({
-  "src/storage/index.ts"() {
-    "use strict";
-    init_client();
-    init_handler();
-    init_rpc();
+    DEFAULT_NAMESPACE = "default";
+    LOCAL_STORAGE_VERSION = "v1";
   }
 });
 
@@ -1202,9 +520,7 @@ async function writeFiles(opts) {
   if (files.length === 0) {
     return;
   }
-  const filePaths = files.map(
-    (file) => path.posix.join(destPath, file.path)
-  );
+  const filePaths = files.map((file) => path.posix.join(destPath, file.path));
   const parentDirs = Array.from(
     new Set(filePaths.map((p) => path.posix.dirname(p)))
   );
@@ -1322,23 +638,21 @@ var init_write_files = __esm({
 
 // src/sandbox/bindings/local.ts
 var import_node_child_process, errore2, import_ulid, localSandbox;
-var init_local2 = __esm({
+var init_local = __esm({
   "src/sandbox/bindings/local.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     errore2 = __toESM(require("errore"));
     import_ulid = require("ulid");
     init_errors();
-    init_storage();
     init_write_files();
     localSandbox = ({
       sandboxRecord,
-      storageConfig
+      storage
     }) => {
       const config = sandboxRecord.config;
       const basePath = config.path ?? process.cwd();
       const processes = /* @__PURE__ */ new Map();
-      const storage = getStorage(storageConfig);
       const sandbox = {
         id: sandboxRecord.id,
         config: sandboxRecord.config,
@@ -1462,26 +776,509 @@ var init_local2 = __esm({
             return void 0;
           }
         }
-      };
-      return sandbox;
+      };
+      return sandbox;
+    };
+  }
+});
+
+// src/sandbox/bindings/vercel-sdk.ts
+var vercel_sdk_exports = {};
+__export(vercel_sdk_exports, {
+  Sandbox: () => import_sandbox.Sandbox
+});
+var import_sandbox;
+var init_vercel_sdk = __esm({
+  "src/sandbox/bindings/vercel-sdk.ts"() {
+    "use strict";
+    import_sandbox = require("sandbox");
+  }
+});
+
+// src/storage/rpc.ts
+function ListResultSchema(itemSchema) {
+  return import_zod3.z.object({
+    items: import_zod3.z.array(itemSchema),
+    nextCursor: import_zod3.z.string().nullable()
+  });
+}
+var import_zod3, VercelLifecycleConfigSchema, SandboxConfigSchema, GenerationSchema, SessionSchema, StepUsageSchema, UsageSummarySchema, MessageUsageSchema, MessageSchema, PartSchema, CommandResultSchema, SandboxRecordSchema, CommandBaseSchema, CommandSchema, methods, STORAGE_RPC_METHODS;
+var init_rpc = __esm({
+  "src/storage/rpc.ts"() {
+    "use strict";
+    import_zod3 = require("zod");
+    VercelLifecycleConfigSchema = import_zod3.z.object({
+      pollIntervalMs: import_zod3.z.number().optional(),
+      stopAfterInactiveMs: import_zod3.z.number().optional(),
+      snapshotBeforeTimeoutMs: import_zod3.z.number().optional(),
+      snapshotId: import_zod3.z.string().optional(),
+      autoStart: import_zod3.z.boolean().optional()
+    });
+    SandboxConfigSchema = import_zod3.z.discriminatedUnion("type", [
+      import_zod3.z.object({
+        type: import_zod3.z.literal("vercel"),
+        resources: import_zod3.z.object({ vcpus: import_zod3.z.number() }).optional(),
+        ports: import_zod3.z.array(import_zod3.z.number()).optional(),
+        lifecycle: VercelLifecycleConfigSchema.optional()
+      }),
+      import_zod3.z.object({
+        type: import_zod3.z.literal("local"),
+        path: import_zod3.z.string().optional()
+      }),
+      import_zod3.z.object({
+        type: import_zod3.z.literal("custom"),
+        url: import_zod3.z.string(),
+        headers: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+      })
+    ]);
+    GenerationSchema = import_zod3.z.object({
+      maxSteps: import_zod3.z.number().optional(),
+      temperature: import_zod3.z.number().optional(),
+      topK: import_zod3.z.number().optional(),
+      topP: import_zod3.z.number().optional(),
+      frequencyPenalty: import_zod3.z.number().optional(),
+      presencePenalty: import_zod3.z.number().optional(),
+      maxOutputTokens: import_zod3.z.number().optional(),
+      headers: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+    });
+    SessionSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      createdAt: import_zod3.z.number(),
+      updatedAt: import_zod3.z.number(),
+      runId: import_zod3.z.string().nullable(),
+      lastMessageId: import_zod3.z.string().nullable(),
+      tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).nullable(),
+      system: import_zod3.z.string().nullable(),
+      model: import_zod3.z.string().nullable(),
+      sandboxId: import_zod3.z.string().nullable(),
+      skillsDir: import_zod3.z.array(import_zod3.z.string()).nullable(),
+      hookToken: import_zod3.z.string().nullable(),
+      activeTools: import_zod3.z.array(import_zod3.z.string()).nullable(),
+      generation: GenerationSchema.nullable().default(null)
+    });
+    StepUsageSchema = import_zod3.z.object({
+      stepIndex: import_zod3.z.number(),
+      model: import_zod3.z.string(),
+      inputTokens: import_zod3.z.number(),
+      outputTokens: import_zod3.z.number(),
+      totalTokens: import_zod3.z.number(),
+      cacheReadTokens: import_zod3.z.number(),
+      cacheWriteTokens: import_zod3.z.number(),
+      reasoningTokens: import_zod3.z.number()
+    });
+    UsageSummarySchema = import_zod3.z.object({
+      model: import_zod3.z.string(),
+      inputTokens: import_zod3.z.number(),
+      outputTokens: import_zod3.z.number(),
+      totalTokens: import_zod3.z.number(),
+      cacheReadTokens: import_zod3.z.number(),
+      cacheWriteTokens: import_zod3.z.number(),
+      reasoningTokens: import_zod3.z.number(),
+      stepCount: import_zod3.z.number()
+    });
+    MessageUsageSchema = import_zod3.z.object({
+      steps: import_zod3.z.array(StepUsageSchema),
+      summary: UsageSummarySchema
+    });
+    MessageSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      sessionId: import_zod3.z.string(),
+      role: import_zod3.z.enum(["user", "assistant", "system"]),
+      createdAt: import_zod3.z.number(),
+      startedAt: import_zod3.z.number().nullable(),
+      completedAt: import_zod3.z.number().nullable(),
+      interruptedAt: import_zod3.z.number().nullable(),
+      usage: MessageUsageSchema.nullable()
+    });
+    PartSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      messageId: import_zod3.z.string(),
+      sessionId: import_zod3.z.string(),
+      index: import_zod3.z.number(),
+      part: import_zod3.z.unknown()
+    });
+    CommandResultSchema = import_zod3.z.object({
+      stdout: import_zod3.z.string(),
+      stderr: import_zod3.z.string(),
+      exitCode: import_zod3.z.number(),
+      completedAt: import_zod3.z.number()
+    });
+    SandboxRecordSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      config: SandboxConfigSchema,
+      tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).nullable(),
+      createdAt: import_zod3.z.number().nullable(),
+      lastActivityAt: import_zod3.z.number().nullable(),
+      acquiringLockId: import_zod3.z.string().nullable(),
+      acquiringLockAt: import_zod3.z.number().nullable(),
+      providerMetadata: import_zod3.z.discriminatedUnion("provider", [
+        import_zod3.z.object({
+          provider: import_zod3.z.literal("vercel"),
+          sandboxId: import_zod3.z.string().nullable(),
+          snapshotId: import_zod3.z.string().nullable()
+        })
+      ]).optional()
+    });
+    CommandBaseSchema = import_zod3.z.object({
+      id: import_zod3.z.string(),
+      sessionId: import_zod3.z.string(),
+      command: import_zod3.z.string(),
+      args: import_zod3.z.array(import_zod3.z.string()).optional(),
+      startedAt: import_zod3.z.number()
+    });
+    CommandSchema = import_zod3.z.discriminatedUnion("status", [
+      CommandBaseSchema.extend({ status: import_zod3.z.literal("running") }),
+      CommandBaseSchema.extend({
+        status: import_zod3.z.literal("completed"),
+        result: CommandResultSchema
+      }),
+      CommandBaseSchema.extend({
+        status: import_zod3.z.literal("killed"),
+        result: CommandResultSchema.optional()
+      }),
+      CommandBaseSchema.extend({
+        status: import_zod3.z.literal("failed"),
+        result: CommandResultSchema
+      })
+    ]);
+    methods = {
+      "session.get": {
+        params: import_zod3.z.object({ id: import_zod3.z.string() }),
+        result: SessionSchema.nullable()
+      },
+      "session.set": {
+        params: SessionSchema,
+        result: SessionSchema
+      },
+      "session.list": {
+        params: import_zod3.z.object({
+          tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
+          order: import_zod3.z.enum([
+            "createdAt_asc",
+            "createdAt_desc",
+            "updatedAt_asc",
+            "updatedAt_desc"
+          ]).optional(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(SessionSchema)
+      },
+      "session.listBySandbox": {
+        params: import_zod3.z.object({
+          sandboxId: import_zod3.z.string(),
+          tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
+          order: import_zod3.z.enum([
+            "createdAt_asc",
+            "createdAt_desc",
+            "updatedAt_asc",
+            "updatedAt_desc"
+          ]).optional(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(SessionSchema)
+      },
+      "session.tag.set": {
+        params: import_zod3.z.object({
+          sessionId: import_zod3.z.string(),
+          tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())
+        }),
+        result: SessionSchema
+      },
+      "message.get": {
+        params: import_zod3.z.object({ id: import_zod3.z.string() }),
+        result: MessageSchema.nullable()
+      },
+      "message.set": {
+        params: MessageSchema,
+        result: MessageSchema
+      },
+      "message.list": {
+        params: import_zod3.z.object({
+          sessionId: import_zod3.z.string(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(MessageSchema)
+      },
+      "part.listByMessage": {
+        params: import_zod3.z.object({
+          messageId: import_zod3.z.string(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(PartSchema)
+      },
+      "part.listBySession": {
+        params: import_zod3.z.object({
+          sessionId: import_zod3.z.string(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(PartSchema)
+      },
+      "part.set": {
+        params: PartSchema,
+        result: PartSchema
+      },
+      "part.delete": {
+        params: import_zod3.z.object({ id: import_zod3.z.string() }),
+        result: import_zod3.z.void()
+      },
+      "sandbox.get": {
+        params: import_zod3.z.object({ key: import_zod3.z.string() }),
+        result: SandboxRecordSchema.nullable()
+      },
+      "sandbox.getBySession": {
+        params: import_zod3.z.object({ sessionId: import_zod3.z.string() }),
+        result: SandboxRecordSchema.nullable()
+      },
+      "sandbox.set": {
+        params: SandboxRecordSchema,
+        result: import_zod3.z.void()
+      },
+      "sandbox.list": {
+        params: import_zod3.z.object({
+          tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional(),
+          order: import_zod3.z.enum([
+            "createdAt_asc",
+            "createdAt_desc",
+            "lastActivityAt_asc",
+            "lastActivityAt_desc"
+          ]).optional(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(SandboxRecordSchema)
+      },
+      "sandbox.tag.set": {
+        params: import_zod3.z.object({
+          sandboxId: import_zod3.z.string(),
+          tags: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())
+        }),
+        result: SandboxRecordSchema
+      },
+      "command.get": {
+        params: import_zod3.z.object({ id: import_zod3.z.string() }),
+        result: CommandSchema.nullable()
+      },
+      "command.set": {
+        params: CommandSchema,
+        result: CommandSchema
+      },
+      "command.list": {
+        params: import_zod3.z.object({
+          sessionId: import_zod3.z.string(),
+          includeFinished: import_zod3.z.boolean().optional(),
+          cursor: import_zod3.z.string().optional(),
+          limit: import_zod3.z.number().optional()
+        }),
+        result: ListResultSchema(CommandSchema)
+      }
+    };
+    STORAGE_RPC_METHODS = Object.keys(methods);
+  }
+});
+
+// src/storage/handler.ts
+async function handleStorageRpc(body, handlers) {
+  const { method, params } = body;
+  if (!(method in methods)) {
+    return {
+      error: { code: "METHOD_NOT_FOUND", message: `Unknown method: ${method}` }
+    };
+  }
+  const methodName = method;
+  const schema = methods[methodName].params;
+  const parsed = schema.safeParse(params);
+  if (!parsed.success) {
+    return {
+      error: {
+        code: "INVALID_PARAMS",
+        message: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")
+      }
+    };
+  }
+  try {
+    const handler = handlers[methodName];
+    const result = await handler(parsed.data);
+    return { result };
+  } catch (e) {
+    return {
+      error: {
+        code: "INTERNAL_ERROR",
+        message: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
+}
+var init_handler = __esm({
+  "src/storage/handler.ts"() {
+    "use strict";
+    init_rpc();
+  }
+});
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  DEFAULT_NAMESPACE: () => DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION: () => LOCAL_STORAGE_VERSION,
+  STORAGE_RPC_METHODS: () => STORAGE_RPC_METHODS,
+  getStorage: () => getStorage,
+  handleStorageRpc: () => handleStorageRpc
+});
+var init_storage = __esm({
+  "src/storage/index.ts"() {
+    "use strict";
+    init_client();
+    init_handler();
+    init_rpc();
+  }
+});
+
+// src/sandbox/bindings/lifecycle-workflow-steps.ts
+async function checkAndSnapshotStep(input) {
+  "use step";
+  const { Sandbox: VercelSandboxSDK2 } = await Promise.resolve().then(() => (init_vercel_sdk(), vercel_sdk_exports));
+  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+  const storage = getStorage2({
+    config: input.storageConfig,
+    rpc: input.rpc
+  });
+  const record = await storage.sandbox.get(input.id);
+  if (record instanceof Error) {
+    return { action: "exit", reason: "not_found" };
+  }
+  const currentSandboxId = record.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+  if (currentSandboxId !== input.vercelSandboxId) {
+    return { action: "exit", reason: "sandboxId_changed" };
+  }
+  if (!currentSandboxId) {
+    return { action: "exit", reason: "not_found" };
+  }
+  const config = record.config;
+  if (config.type !== "vercel") {
+    return { action: "exit", reason: "not_found" };
+  }
+  const pollIntervalMs = config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const idleTimeoutMs = config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const snapshotBeforeTimeoutMs = config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;
+  const now = Date.now();
+  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;
+  const idleDuration = now - lastActivity;
+  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
+  let shouldSnapshotDueToTimeout = false;
+  try {
+    const sandbox = await VercelSandboxSDK2.get({
+      sandboxId: currentSandboxId,
+      ...getTestCredentials()
+    });
+    if (sandbox.timeout < snapshotBeforeTimeoutMs) {
+      shouldSnapshotDueToTimeout = true;
+    }
+  } catch {
+    return { action: "exit", reason: "not_found" };
+  }
+  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {
+    try {
+      const sandbox = await VercelSandboxSDK2.get({
+        sandboxId: currentSandboxId,
+        ...getTestCredentials()
+      });
+      const snapshot = await sandbox.snapshot();
+      await storage.sandbox.set({
+        ...record,
+        acquiringLockId: null,
+        acquiringLockAt: null,
+        providerMetadata: {
+          provider: "vercel",
+          sandboxId: null,
+          snapshotId: snapshot.snapshotId
+        }
+      });
+    } catch (e) {
+      return e instanceof Error ? e : new Error(String(e));
+    }
+    return {
+      action: "exit",
+      reason: shouldSnapshotDueToIdle ? "idle" : "timeout"
     };
   }
+  return { action: "continue", nextPollMs: pollIntervalMs };
+}
+var DEFAULT_POLL_INTERVAL_MS, DEFAULT_IDLE_TIMEOUT_MS, SNAPSHOT_BEFORE_TIMEOUT_MS, getTestCredentials;
+var init_lifecycle_workflow_steps = __esm({
+  "src/sandbox/bindings/lifecycle-workflow-steps.ts"() {
+    "use strict";
+    DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1e3;
+    DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+    SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1e3;
+    getTestCredentials = () => process.env.NODE_ENV === "test" ? {
+      token: process.env.TEST_VERCEL_TOKEN,
+      teamId: process.env.TEST_VERCEL_TEAM_ID,
+      projectId: process.env.TEST_VERCEL_PROJECT_ID
+    } : {};
+  }
+});
+
+// src/sandbox/bindings/lifecycle-workflow.ts
+async function sandboxLifecycleWorkflow({
+  input
+}) {
+  "use workflow";
+  let nextPollMs = DEFAULT_POLL_MS;
+  while (true) {
+    await (0, import_workflow.sleep)(nextPollMs);
+    const result = await checkAndSnapshotStep(input);
+    if (result instanceof Error || result.action === "exit") {
+      break;
+    }
+    nextPollMs = result.nextPollMs;
+  }
+}
+var import_workflow, DEFAULT_POLL_MS;
+var init_lifecycle_workflow = __esm({
+  "src/sandbox/bindings/lifecycle-workflow.ts"() {
+    "use strict";
+    import_workflow = require("workflow");
+    init_lifecycle_workflow_steps();
+    DEFAULT_POLL_MS = 2 * 60 * 1e3;
+  }
 });
 
 // src/sandbox/bindings/vercel.ts
-var errore3, import_sandbox, VERCEL_MAX_TIMEOUT_MS, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, getTestCredentials, createPromises, ACTIVITY_THROTTLE_MS, lastActivitySent, DEFAULT_VCPUS, vercelSandbox;
-var init_vercel2 = __esm({
+function isSandboxGoneError(e) {
+  if (!(e instanceof Error)) {
+    return false;
+  }
+  const errorWithResponse = e;
+  const errorWithCause = e;
+  const status = errorWithResponse.response?.status ?? errorWithCause.cause?.response?.status;
+  if (status === 410 || status === 422) {
+    return true;
+  }
+  const message = e.message || String(e);
+  if (message.includes("Expected a stream of command data") || message.includes("Expected a stream of logs")) {
+    return true;
+  }
+  return false;
+}
+var errore3, import_sandbox2, import_api, VERCEL_MAX_TIMEOUT_MS, LOCK_TIMEOUT_MS, LOCK_POLL_INTERVAL_MS, getTestCredentials2, createPromises, ACTIVITY_THROTTLE_MS, lastActivitySent, DEFAULT_VCPUS, vercelSandbox;
+var init_vercel = __esm({
   "src/sandbox/bindings/vercel.ts"() {
     "use strict";
     errore3 = __toESM(require("errore"));
-    import_sandbox = require("sandbox");
+    import_sandbox2 = require("sandbox");
+    import_api = require("workflow/api");
     init_errors();
-    init_storage();
     init_write_files();
+    init_lifecycle_workflow();
     VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
     LOCK_TIMEOUT_MS = 2 * 60 * 1e3;
     LOCK_POLL_INTERVAL_MS = 200;
-    getTestCredentials = () => process.env.NODE_ENV === "test" ? {
+    getTestCredentials2 = () => process.env.NODE_ENV === "test" ? {
       token: process.env.TEST_VERCEL_TOKEN,
       teamId: process.env.TEST_VERCEL_TEAM_ID,
       projectId: process.env.TEST_VERCEL_PROJECT_ID
@@ -1493,15 +1290,16 @@ var init_vercel2 = __esm({
     vercelSandbox = ({
       sandboxRecord,
       storageConfig,
-      enableLifecycleWorkflow = true,
-      storage: storageOverride
+      enableLifecycleWorkflow,
+      storage,
+      rpc
     }) => {
       const { id, config } = sandboxRecord;
       const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;
       const ports = config.ports;
-      const storage = storageOverride ?? getStorage(storageConfig);
       const initialVercel = sandboxRecord.providerMetadata?.provider === "vercel" ? sandboxRecord.providerMetadata : null;
       let sandboxPromise = null;
+      let recoveredFromStale = false;
       const HOME_DIR = "/home/vercel-sandbox";
       async function pollForSandboxId() {
         const deadline = Date.now() + LOCK_TIMEOUT_MS;
@@ -1534,15 +1332,31 @@ var init_vercel2 = __esm({
           reason: "Timed out waiting for sandbox creation by another process"
         });
       }
+      async function startLifecycleWorkflow(vercelSandboxId) {
+        if (!enableLifecycleWorkflow) {
+          return;
+        }
+        const lifecycleInput = {
+          id,
+          vercelSandboxId,
+          storageConfig,
+          rpc
+        };
+        await (0, import_api.start)(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(
+          // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget
+          () => {
+          }
+        );
+      }
       async function createSandboxFromSnapshot(snapshotId) {
         return await errore3.tryAsync({
           try: async () => {
-            const sandbox2 = await import_sandbox.Sandbox.create({
+            const sandbox2 = await import_sandbox2.Sandbox.create({
               source: { type: "snapshot", snapshotId },
               resources: { vcpus },
               timeout: VERCEL_MAX_TIMEOUT_MS,
               ports,
-              ...getTestCredentials()
+              ...getTestCredentials2()
             });
             const now = Date.now();
             await storage.sandbox.set({
@@ -1559,6 +1373,7 @@ var init_vercel2 = __esm({
                 snapshotId
               }
             });
+            await startLifecycleWorkflow(sandbox2.sandboxId);
             return sandbox2.sandboxId;
           },
           catch: (e) => new SandboxError({ reason: String(e), cause: e })
@@ -1567,11 +1382,11 @@ var init_vercel2 = __esm({
       async function createFreshSandbox() {
         return await errore3.tryAsync({
           try: async () => {
-            const sandbox2 = await import_sandbox.Sandbox.create({
+            const sandbox2 = await import_sandbox2.Sandbox.create({
               resources: { vcpus },
               timeout: VERCEL_MAX_TIMEOUT_MS,
               ports,
-              ...getTestCredentials()
+              ...getTestCredentials2()
             });
             const now = Date.now();
             await storage.sandbox.set({
@@ -1588,13 +1403,14 @@ var init_vercel2 = __esm({
                 snapshotId: null
               }
             });
+            await startLifecycleWorkflow(sandbox2.sandboxId);
             return sandbox2.sandboxId;
           },
           catch: (e) => new SandboxError({ reason: String(e), cause: e })
         });
       }
       async function doGetOrCreateSandboxId() {
-        if (initialVercel?.sandboxId) {
+        if (initialVercel?.sandboxId && !recoveredFromStale) {
           return initialVercel.sandboxId;
         }
         const existing = await storage.sandbox.get(id);
@@ -1662,9 +1478,9 @@ var init_vercel2 = __esm({
           return vercelSandboxId;
         }
         return errore3.tryAsync({
-          try: () => import_sandbox.Sandbox.get({
+          try: () => import_sandbox2.Sandbox.get({
             sandboxId: vercelSandboxId,
-            ...getTestCredentials()
+            ...getTestCredentials2()
           }),
           catch: (e) => new SandboxError({ reason: String(e), cause: e })
         });
@@ -1675,6 +1491,31 @@ var init_vercel2 = __esm({
         }
         return sandboxPromise;
       }
+      async function recoverFromStaleSandbox() {
+        sandboxPromise = null;
+        recoveredFromStale = true;
+        const existing = await storage.sandbox.get(id);
+        if (existing instanceof Error || !existing) {
+          return;
+        }
+        const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
+        if (existingVercel?.sandboxId) {
+          await storage.sandbox.set({
+            id: existing.id,
+            config: existing.config,
+            tags: existing.tags,
+            createdAt: existing.createdAt,
+            lastActivityAt: existing.lastActivityAt,
+            acquiringLockId: null,
+            acquiringLockAt: null,
+            providerMetadata: {
+              provider: "vercel",
+              sandboxId: null,
+              snapshotId: existingVercel.snapshotId
+            }
+          });
+        }
+      }
       async function updateLastActivity() {
         const now = Date.now();
         const lastSent = lastActivitySent.get(id);
@@ -1701,8 +1542,6 @@ var init_vercel2 = __esm({
             snapshotId: null
           }
         });
-        if (enableLifecycleWorkflow) {
-        }
       }
       const lifecycle = {
         start: async () => {
@@ -1794,31 +1633,34 @@ var init_vercel2 = __esm({
           return sandbox2.timeout;
         }
       };
-      const sandbox = {
-        id,
-        config,
-        exec: async ({ command, args, signal }) => {
-          const instance = await getSandbox2();
-          if (instance instanceof Error) {
-            return instance;
-          }
-          const updatePromise = updateLastActivity();
-          const execResult = await errore3.tryAsync({
-            try: async () => {
-              const output = await instance.runCommand({
-                cwd: HOME_DIR,
-                args,
-                cmd: command,
-                signal
-              });
-              let stdout = "";
-              let stderr = "";
-              const logBuffer = [];
-              const state = {
-                resolve: null,
-                consumed: false
-              };
-              const consumeLogs = (async () => {
+      async function doExec({
+        command,
+        args,
+        signal
+      }) {
+        const instance = await getSandbox2();
+        if (instance instanceof Error) {
+          return instance;
+        }
+        const updatePromise = updateLastActivity();
+        const execResult = await errore3.tryAsync({
+          try: async () => {
+            const output = await instance.runCommand({
+              cwd: HOME_DIR,
+              args,
+              cmd: command,
+              signal,
+              detached: true
+            });
+            let stdout = "";
+            let stderr = "";
+            const logBuffer = [];
+            const state = {
+              resolve: null,
+              consumed: false
+            };
+            const consumeLogs = (async () => {
+              try {
                 for await (const log of output.logs()) {
                   const entry = log.stream === "stdout" ? { stream: "stdout", data: log.data } : { stream: "stderr", data: log.data };
                   if (log.stream === "stdout") {
@@ -1829,33 +1671,56 @@ var init_vercel2 = __esm({
                   logBuffer.push(entry);
                   state.resolve?.();
                 }
-                state.consumed = true;
-                state.resolve?.();
-              })();
-              async function* logs() {
-                let index = 0;
-                while (!state.consumed || index < logBuffer.length) {
-                  if (index < logBuffer.length) {
-                    yield logBuffer[index++];
-                  } else {
-                    await new Promise((resolve) => {
-                      state.resolve = resolve;
-                    });
-                    state.resolve = null;
-                  }
+              } catch {
+              }
+              state.consumed = true;
+              state.resolve?.();
+            })();
+            async function* logs() {
+              let index = 0;
+              while (!state.consumed || index < logBuffer.length) {
+                if (index < logBuffer.length) {
+                  yield logBuffer[index++];
+                } else {
+                  await new Promise((resolve) => {
+                    state.resolve = resolve;
+                  });
+                  state.resolve = null;
                 }
               }
-              const result = consumeLogs.then(() => ({
-                stdout,
-                stderr,
-                exitCode: output.exitCode
-              }));
-              return { commandId: output.cmdId, logs, result };
-            },
-            catch: (e) => new SandboxError({ reason: String(e), cause: e })
-          });
-          await updatePromise;
-          return execResult;
+            }
+            const result = consumeLogs.then(async () => {
+              try {
+                const finished = await output.wait();
+                return {
+                  stdout,
+                  stderr,
+                  exitCode: finished.exitCode
+                };
+              } catch (e) {
+                if (isSandboxGoneError(e)) {
+                  return { stdout, stderr, exitCode: 1 };
+                }
+                throw e;
+              }
+            });
+            return { commandId: output.cmdId, logs, result };
+          },
+          catch: (e) => new SandboxError({ reason: String(e), cause: e })
+        });
+        await updatePromise;
+        return execResult;
+      }
+      const sandbox = {
+        id,
+        config,
+        exec: async (opts) => {
+          const result = await doExec(opts);
+          if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {
+            await recoverFromStaleSandbox();
+            return await doExec(opts);
+          }
+          return result;
         },
         getDomain: async (port) => {
           const sandbox2 = await getSandbox2();
@@ -1938,35 +1803,40 @@ var init_vercel2 = __esm({
 // src/sandbox/client.ts
 function getSandbox({
   sandboxRecord,
-  storageConfig
+  storageConfig,
+  storage,
+  rpc,
+  enableLifecycleWorkflow = true
 }) {
-  const { config } = sandboxRecord;
-  switch (config.type) {
+  switch (sandboxRecord.config.type) {
     case "local":
       return localSandbox({
         sandboxRecord,
-        storageConfig
+        storage
       });
     case "vercel":
       return vercelSandbox({
         sandboxRecord,
-        storageConfig
+        storageConfig,
+        storage,
+        rpc,
+        enableLifecycleWorkflow
       });
     case "custom":
       throw new Error("Custom sandboxes are not supported");
     default:
-      config;
+      sandboxRecord.config;
       throw new Error(
         `Unknown sandbox type: ${// biome-ignore lint/suspicious/noExplicitAny: .
-        config.type}`
+        sandboxRecord.config.type}`
       );
   }
 }
 var init_client2 = __esm({
   "src/sandbox/client.ts"() {
     "use strict";
-    init_local2();
-    init_vercel2();
+    init_local();
+    init_vercel();
   }
 });
 
@@ -1986,15 +1856,16 @@ var init_sandbox = __esm({
 var agent_workflow_exports = {};
 __export(agent_workflow_exports, {
   agentMessageHook: () => agentMessageHook,
-  agentWorkflow: () => agentWorkflow
+  agentWorkflow: () => agentWorkflow,
+  approvalHook: () => approvalHook
 });
 module.exports = __toCommonJS(agent_workflow_exports);
-var import_workflow2 = require("workflow");
+var import_workflow3 = require("workflow");
 
 // src/agent-workflow-steps.ts
-var import_ai2 = require("ai");
+var import_ai3 = require("ai");
 var import_ulid2 = require("ulid");
-var import_workflow = require("workflow");
+var import_workflow2 = require("workflow");
 
 // src/skills/parser.ts
 function parseSkillFrontmatter(content) {
@@ -2042,11 +1913,6 @@ function parseSimpleYaml(yaml) {
 // src/skills/discover.ts
 async function discoverSkillsInSandbox(opts) {
   const { sandbox, skillsDirs, debug } = opts;
-  console.log("[discover] discoverSkillsInSandbox called:", {
-    skillsDirs,
-    skillsDirsLength: skillsDirs?.length,
-    debug
-  });
   const summaries = [];
   const seenNames = /* @__PURE__ */ new Set();
   for (const skillsDir of skillsDirs) {
@@ -2081,14 +1947,6 @@ async function discoverSkillsInDirectory(opts) {
 }
 async function findSkillFiles(opts) {
   const { sandbox, skillsDir, debug } = opts;
-  console.log("[discover] findSkillFiles called:", {
-    skillsDir,
-    debug
-  });
-  console.log("[discover] Executing find command:", {
-    command: "find",
-    args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
-  });
   const execResult = await sandbox.exec({
     command: "find",
     args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
@@ -2135,57 +1993,553 @@ async function parseSkillFile(opts) {
     }
     return null;
   }
-  const { stdout, exitCode } = await execResult.result;
-  if (exitCode !== 0) {
-    if (debug) {
-      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);
-    }
-    return null;
+  const { stdout, exitCode } = await execResult.result;
+  if (exitCode !== 0) {
+    if (debug) {
+      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);
+    }
+    return null;
+  }
+  const parsed = parseSkillFrontmatter(stdout);
+  if (!parsed) {
+    if (debug) {
+      console.warn(
+        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`
+      );
+    }
+    return null;
+  }
+  return {
+    name: parsed.name,
+    description: parsed.description,
+    skillMdPath
+  };
+}
+
+// src/tools/index.ts
+var import_ai2 = require("ai");
+var import_zod2 = require("zod");
+init_process_manager();
+
+// src/tools/javascript.ts
+var import_ai = require("ai");
+var import_zod = require("zod");
+var REQUEST_MARKER_START = "__TOOL_REQUEST__";
+var REQUEST_MARKER_END = "__TOOL_REQUEST_END__";
+var EXECUTION_TIMEOUT_MS = 5 * 60 * 1e3;
+var RUNNER_SCRIPT = `
+import { readFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const TOOL_CALL_TIMEOUT_MS = 300_000;
+
+let reqCounter = 0;
+
+async function callTool(name, input) {
+  const id = 'req_' + (++reqCounter) + '_' + Date.now();
+  const responseFile = join(SCRIPT_DIR, id + '.response.json');
+
+  const request = JSON.stringify({ id, tool: name, input });
+  process.stderr.write('${REQUEST_MARKER_START}' + request + '${REQUEST_MARKER_END}' + '\\n');
+
+  const start = Date.now();
+  while (!existsSync(responseFile)) {
+    if (Date.now() - start > TOOL_CALL_TIMEOUT_MS) {
+      throw new Error('Tool call ' + name + ' timed out waiting for response');
+    }
+    await new Promise(r => setTimeout(r, 30));
+  }
+
+  let raw;
+  try {
+    raw = readFileSync(responseFile, 'utf8');
+  } catch {
+    await new Promise(r => setTimeout(r, 50));
+    raw = readFileSync(responseFile, 'utf8');
+  }
+
+  const response = JSON.parse(raw);
+  try { unlinkSync(responseFile); } catch {}
+
+  if (response.error) {
+    throw new Error(response.error);
+  }
+  return response.result;
+}
+
+const code = readFileSync(join(SCRIPT_DIR, 'code.js'), 'utf8');
+const toolNames = JSON.parse(readFileSync(join(SCRIPT_DIR, 'tools.json'), 'utf8'));
+
+const ctx = { tools: {} };
+for (const name of toolNames) {
+  ctx.tools[name] = (input) => callTool(name, input);
+}
+
+const logs = [];
+const customConsole = {
+  log: (...args) => logs.push(args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+  error: (...args) => logs.push('[error] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+  warn: (...args) => logs.push('[warn] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),
+};
+
+try {
+  const AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+  const fn = new AsyncFunction('ctx', 'console', code);
+  const result = await fn(ctx, customConsole);
+
+  const output = { success: true, result: result !== undefined ? result : null };
+  if (logs.length > 0) output.logs = logs;
+  process.stdout.write(JSON.stringify(output));
+} catch (err) {
+  const output = {
+    success: false,
+    error: err instanceof Error ? err.message + '\\n' + err.stack : String(err),
+  };
+  if (logs.length > 0) output.logs = logs;
+  process.stdout.write(JSON.stringify(output));
+}
+`;
+function extractJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") {
+    return null;
+  }
+  if ("_def" in schema && typeof schema._def === "object") {
+    try {
+      return import_zod.z.toJSONSchema(schema);
+    } catch {
+      return null;
+    }
+  }
+  const s = schema;
+  if (Symbol.for("vercel.ai.schema") in s && "jsonSchema" in s) {
+    return s.jsonSchema;
+  }
+  if ("type" in s || "properties" in s) {
+    return s;
+  }
+  return null;
+}
+function jsonSchemaToTs(schema, indent = 0) {
+  if (!schema) {
+    return "unknown";
+  }
+  if (schema.enum && Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map((s) => jsonSchemaToTs(s, indent)).join(" | ");
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map((s) => jsonSchemaToTs(s, indent)).join(" | ");
+  }
+  const type = schema.type;
+  switch (type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array": {
+      const items = schema.items ? jsonSchemaToTs(schema.items, indent) : "unknown";
+      return `Array<${items}>`;
+    }
+    case "object": {
+      const properties = schema.properties;
+      if (!properties) {
+        return "Record<string, unknown>";
+      }
+      const required = new Set(schema.required || []);
+      const pad = "  ".repeat(indent + 1);
+      const closePad = "  ".repeat(indent);
+      const props = Object.entries(properties).map(([key, value]) => {
+        const opt = required.has(key) ? "" : "?";
+        return `${pad}${key}${opt}: ${jsonSchemaToTs(value, indent + 1)}`;
+      });
+      return `{
+${props.join(";\n")};
+${closePad}}`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function generateContextTypeString(tools) {
+  const sigs = [];
+  for (const [name, t] of Object.entries(tools)) {
+    const raw = t;
+    const inputSchema = extractJsonSchema(raw.inputSchema ?? raw.parameters);
+    const outputSchema = extractJsonSchema(raw.outputSchema);
+    const inputType = inputSchema ? jsonSchemaToTs(inputSchema, 2) : "{}";
+    const outputType = outputSchema ? jsonSchemaToTs(outputSchema, 2) : "unknown";
+    sigs.push(`    ${name}(input: ${inputType}): Promise<${outputType}>`);
+  }
+  return `type Context = {
+  tools: {
+${sigs.join(";\n")};
+  }
+}`;
+}
+async function executeInSandbox({
+  code,
+  rpcDir,
+  abortController,
+  sandbox,
+  availableTools,
+  onSubToolCall
+}) {
+  const mkdirResult = await sandbox.exec({
+    command: "mkdir",
+    args: ["-p", rpcDir]
+  });
+  if (mkdirResult instanceof Error) {
+    return { success: false, error: mkdirResult.message };
+  }
+  await mkdirResult.result;
+  await sandbox.writeFiles({
+    files: [
+      { path: "runner.mjs", content: RUNNER_SCRIPT },
+      { path: "code.js", content: code },
+      {
+        path: "tools.json",
+        content: JSON.stringify(Object.keys(availableTools))
+      }
+    ],
+    destPath: rpcDir
+  });
+  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
+  const permissionFlag = nodeMajor >= 22 ? "--permission" : "--experimental-permission";
+  const execResult = await sandbox.exec({
+    command: "node",
+    args: [
+      permissionFlag,
+      `--allow-fs-read=${rpcDir}`,
+      `--allow-fs-write=${rpcDir}`,
+      `${rpcDir}/runner.mjs`
+    ],
+    signal: abortController.signal
+  });
+  if (execResult instanceof Error) {
+    return { success: false, error: execResult.message };
+  }
+  const fatal = { error: null };
+  const abort = (error) => {
+    if (!fatal.error) {
+      fatal.error = error;
+      abortController.abort();
+    }
+  };
+  const handleToolRequest = async (requestJson) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(requestJson);
+    } catch {
+      return;
+    }
+    const { id, tool: toolName, input } = parsed;
+    let response;
+    try {
+      const t = availableTools[toolName];
+      if (!t?.execute) {
+        throw new Error(
+          `Tool ${toolName} not found or has no execute function`
+        );
+      }
+      const exec = t.execute.bind(t);
+      if (onSubToolCall) {
+        response = await onSubToolCall(
+          toolName,
+          input,
+          () => exec(input, {
+            toolCallId: `js_${toolName}_${Date.now()}`,
+            messages: []
+          })
+        );
+      } else {
+        const result = await exec(input, {
+          toolCallId: `js_${toolName}_${Date.now()}`,
+          messages: []
+        });
+        response = { result };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      response = { error: msg };
+    }
+    try {
+      await sandbox.writeFiles({
+        files: [
+          {
+            path: `${id}.response.json`,
+            content: JSON.stringify(response)
+          }
+        ],
+        destPath: rpcDir
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      abort(new Error(`Failed to write RPC response for ${toolName}: ${msg}`));
+    }
+  };
+  const toolCallPromises = [];
+  let stderrBuffer = "";
+  let nonMarkerStderr = "";
+  const timeout = setTimeout(() => {
+    abort(
+      new Error(
+        `JavaScript execution timed out after ${EXECUTION_TIMEOUT_MS / 1e3}s`
+      )
+    );
+  }, EXECUTION_TIMEOUT_MS);
+  try {
+    for await (const entry of execResult.logs()) {
+      if (fatal.error) {
+        break;
+      }
+      if (entry.stream === "stderr") {
+        stderrBuffer += entry.data;
+        while (true) {
+          const startIdx = stderrBuffer.indexOf(REQUEST_MARKER_START);
+          if (startIdx === -1) {
+            break;
+          }
+          const beforeMarker = stderrBuffer.slice(0, startIdx);
+          if (beforeMarker.trim()) {
+            nonMarkerStderr += beforeMarker;
+          }
+          const contentStart = startIdx + REQUEST_MARKER_START.length;
+          const endIdx = stderrBuffer.indexOf(REQUEST_MARKER_END, contentStart);
+          if (endIdx === -1) {
+            break;
+          }
+          const requestJson = stderrBuffer.slice(contentStart, endIdx);
+          stderrBuffer = stderrBuffer.slice(endIdx + REQUEST_MARKER_END.length);
+          toolCallPromises.push(handleToolRequest(requestJson));
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (stderrBuffer.trim()) {
+    nonMarkerStderr += stderrBuffer;
+  }
+  await Promise.allSettled(toolCallPromises);
+  if (fatal.error) {
+    execResult.result.catch(() => void 0);
+    return {
+      success: false,
+      error: fatal.error.message,
+      ...nonMarkerStderr ? { stderr: nonMarkerStderr.slice(0, 2e3) } : {}
+    };
+  }
+  const { stdout, stderr, exitCode } = await execResult.result;
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return {
+      success: false,
+      error: `Runner failed (exit ${exitCode}).`,
+      stderr: (nonMarkerStderr + stderr).slice(0, 2e3),
+      stdout: stdout.slice(0, 1e3)
+    };
   }
-  const parsed = parseSkillFrontmatter(stdout);
-  if (!parsed) {
-    if (debug) {
-      console.warn(
-        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`
-      );
+}
+function createJavaScriptTool(opts) {
+  const { session, sandbox, onSubToolCall } = opts;
+  const activeSet = session.activeTools ? new Set(session.activeTools) : null;
+  const availableTools = {};
+  for (const [name, t] of Object.entries(opts.tools)) {
+    if (!activeSet || activeSet.has(name)) {
+      availableTools[name] = t;
     }
-    return null;
   }
-  return {
-    name: parsed.name,
-    description: parsed.description,
-    skillMdPath
-  };
+  const contextType = generateContextTypeString(availableTools);
+  return (0, import_ai.tool)({
+    ...builtInTools.JavaScript,
+    description: `Execute JavaScript to orchestrate multiple tool calls in a single step. Use this when you need to run several tools in sequence, transform intermediate results, or parallelize independent operations with Promise.all.
+
+The code runs as an async function body with \`ctx\` in scope:
+
+\`\`\`typescript
+${contextType}
+\`\`\`
+
+Examples:
+- Sequential: \`const file = await ctx.tools.Read({ path: "package.json" }); return JSON.parse(file.content);\`
+- Parallel: \`const [a, b] = await Promise.all([ctx.tools.Read({ path: "a.ts" }), ctx.tools.Read({ path: "b.ts" })]); return { a: a.content, b: b.content };\`
+- Transform: \`const grep = await ctx.tools.Grep({ pattern: "TODO" }); return grep.matches.split("\\n").length;\`
+
+Return a value to pass results back. Use console.log() for debug output.`,
+    execute: ({ code }) => {
+      const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const rpcDir = `.agent/js-rpc/${runId}`;
+      const abortController = new AbortController();
+      return executeInSandbox({
+        code,
+        rpcDir,
+        abortController,
+        sandbox,
+        availableTools,
+        onSubToolCall
+      });
+    }
+  });
 }
 
 // src/tools/index.ts
-var import_ai = require("ai");
-var import_zod = require("zod");
+var builtInTools = {
+  Read: (0, import_ai2.tool)({
+    description: "Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.",
+    inputSchema: import_zod2.z.object({
+      path: import_zod2.z.string().describe("Path to the file relative to workspace root"),
+      startLine: import_zod2.z.number().optional().describe(
+        "Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size."
+      ),
+      endLine: import_zod2.z.number().optional().describe(
+        "Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size."
+      )
+    }),
+    outputSchema: import_zod2.z.object({
+      content: import_zod2.z.string().describe("File content"),
+      metadata: import_zod2.z.object({
+        totalLines: import_zod2.z.number().describe("Total number of lines in the file"),
+        linesShown: import_zod2.z.number().describe("Number of lines included in this response"),
+        startLine: import_zod2.z.number().describe("First line number shown (1-indexed)"),
+        endLine: import_zod2.z.number().describe("Last line number shown (1-indexed)"),
+        isPaginated: import_zod2.z.boolean().describe("Whether this is a partial view of the file"),
+        fileSize: import_zod2.z.string().describe("Human-readable file size (e.g., '2.5K', '1.2M')"),
+        path: import_zod2.z.string().describe("Path to the file relative to workspace root")
+      })
+    })
+  }),
+  Grep: (0, import_ai2.tool)({
+    description: "Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.",
+    inputSchema: import_zod2.z.object({
+      pattern: import_zod2.z.string().describe("Regex pattern to search for (ripgrep syntax)"),
+      path: import_zod2.z.string().optional().describe(
+        "Path to search in (defaults to workspace root). Can be a file or directory."
+      ),
+      fileType: import_zod2.z.string().optional().describe(
+        "File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters."
+      ),
+      glob: import_zod2.z.string().optional().describe(
+        "Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')"
+      ),
+      caseSensitive: import_zod2.z.boolean().optional().default(true).describe("Whether search is case-sensitive (default: true)"),
+      contextLines: import_zod2.z.number().optional().describe(
+        "Number of context lines to show before and after each match"
+      ),
+      maxCount: import_zod2.z.number().optional().describe(
+        "Maximum number of matches per file (useful for limiting output)"
+      ),
+      filesWithMatches: import_zod2.z.boolean().optional().default(false).describe(
+        "Only show file paths that contain matches, not the matching lines themselves"
+      )
+    }),
+    outputSchema: import_zod2.z.object({
+      matches: import_zod2.z.string().describe(
+        "Search results with file paths, line numbers, and matching content"
+      ),
+      summary: import_zod2.z.object({
+        matchCount: import_zod2.z.number().describe("Number of matches found"),
+        fileCount: import_zod2.z.number().describe("Number of files containing matches"),
+        searchPath: import_zod2.z.string().describe("Path that was searched"),
+        pattern: import_zod2.z.string().describe("Pattern that was searched for")
+      })
+    })
+  }),
+  List: (0, import_ai2.tool)({
+    description: "Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.",
+    inputSchema: import_zod2.z.object({
+      path: import_zod2.z.string().optional().describe("Path to list (defaults to workspace root)"),
+      depth: import_zod2.z.number().optional().describe(
+        "Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping"
+      ),
+      includeHidden: import_zod2.z.boolean().optional().default(false).describe(
+        "Include hidden files and directories (those starting with '.')"
+      ),
+      filesOnly: import_zod2.z.boolean().optional().default(false).describe("Only show files, not directories"),
+      pattern: import_zod2.z.string().optional().describe("Glob pattern to filter results (e.g., '*.ts', '*test*')")
+    }),
+    outputSchema: import_zod2.z.object({
+      listing: import_zod2.z.string().describe(
+        "Directory tree listing showing paths relative to search root"
+      ),
+      summary: import_zod2.z.object({
+        totalItems: import_zod2.z.number().describe("Total number of items found"),
+        totalFiles: import_zod2.z.number().describe("Total number of files found"),
+        totalDirs: import_zod2.z.number().describe("Total number of directories found"),
+        searchPath: import_zod2.z.string().describe("Path that was listed"),
+        depth: import_zod2.z.number().optional().describe("Maximum depth used (if specified)")
+      })
+    })
+  }),
+  Write: (0, import_ai2.tool)({
+    description: "Write content to a file. Creates parent directories automatically. Overwrites existing files.",
+    inputSchema: import_zod2.z.object({
+      path: import_zod2.z.string().describe("Path to the file relative to workspace root"),
+      content: import_zod2.z.string().describe("Content to write to the file")
+    }),
+    outputSchema: import_zod2.z.object({
+      success: import_zod2.z.boolean().describe("Whether the write succeeded"),
+      path: import_zod2.z.string().describe("Path to the written file"),
+      bytesWritten: import_zod2.z.number().describe("Number of bytes written"),
+      error: import_zod2.z.string().optional().describe("Error message if write failed")
+    })
+  }),
+  Edit: (0, import_ai2.tool)({
+    description: "Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.",
+    inputSchema: import_zod2.z.object({
+      path: import_zod2.z.string().describe("Path to the file relative to workspace root"),
+      old_string: import_zod2.z.string().describe("Exact string to find and replace (must be unique in file)"),
+      new_string: import_zod2.z.string().describe("String to replace old_string with")
+    }),
+    outputSchema: import_zod2.z.object({
+      success: import_zod2.z.boolean().describe("Whether the edit succeeded"),
+      path: import_zod2.z.string().describe("Path to the edited file"),
+      error: import_zod2.z.string().optional().describe("Error message if edit failed")
+    })
+  }),
+  Bash: (0, import_ai2.tool)({
+    description: "Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).",
+    inputSchema: import_zod2.z.object({
+      command: import_zod2.z.string().describe("The shell command to execute"),
+      waitUntil: import_zod2.z.number().optional().describe(
+        `Max ms to wait for completion (default: ${DEFAULT_WAIT_UNTIL}). Use 0 to run in background and return immediately.`
+      )
+    }),
+    outputSchema: import_zod2.z.object({
+      pid: import_zod2.z.number().describe(
+        "System PID (0 for foreground, >0 for background - use to kill)"
+      ),
+      output: import_zod2.z.string().describe("Command stdout+stderr combined (empty for background)"),
+      exitCode: import_zod2.z.number().describe("Exit code (-1 for background/running)"),
+      status: import_zod2.z.enum(["running", "completed", "failed"]).describe("Process status"),
+      cwd: import_zod2.z.string().describe("Current working directory after command"),
+      outputFile: import_zod2.z.string().describe("Path to output log (for background processes)")
+    })
+  }),
+  JavaScript: (0, import_ai2.tool)({
+    inputSchema: import_zod2.z.object({
+      code: import_zod2.z.string().describe(
+        "JavaScript async function body. `ctx` is in scope. Must use `return` to produce output."
+      )
+    })
+  })
+};
+var builtinToolNames = Object.fromEntries(
+  Object.entries(builtInTools).map(([name]) => [name, name])
+);
 function getTools(context) {
-  return {
-    Read: (0, import_ai.tool)({
-      description: "Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.",
-      inputSchema: import_zod.z.object({
-        path: import_zod.z.string().describe("Path to the file relative to workspace root"),
-        startLine: import_zod.z.number().optional().describe(
-          "Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size."
-        ),
-        endLine: import_zod.z.number().optional().describe(
-          "Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size."
-        )
-      }),
-      outputSchema: import_zod.z.object({
-        content: import_zod.z.string().describe("File content"),
-        metadata: import_zod.z.object({
-          totalLines: import_zod.z.number().describe("Total number of lines in the file"),
-          linesShown: import_zod.z.number().describe("Number of lines included in this response"),
-          startLine: import_zod.z.number().describe("First line number shown (1-indexed)"),
-          endLine: import_zod.z.number().describe("Last line number shown (1-indexed)"),
-          isPaginated: import_zod.z.boolean().describe("Whether this is a partial view of the file"),
-          fileSize: import_zod.z.string().describe("Human-readable file size (e.g., '2.5K', '1.2M')"),
-          path: import_zod.z.string().describe("Path to the file relative to workspace root")
-        })
-      }),
+  const tools = {
+    [builtinToolNames.Read]: (0, import_ai2.tool)({
+      ...builtInTools.Read,
       execute: async ({ path: path2, startLine, endLine }) => {
         const filePath = path2;
         const result = await context.sandbox.exec({
@@ -2317,41 +2671,8 @@ function getTools(context) {
         };
       }
     }),
-    Grep: (0, import_ai.tool)({
-      description: "Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.",
-      inputSchema: import_zod.z.object({
-        pattern: import_zod.z.string().describe("Regex pattern to search for (ripgrep syntax)"),
-        path: import_zod.z.string().optional().describe(
-          "Path to search in (defaults to workspace root). Can be a file or directory."
-        ),
-        fileType: import_zod.z.string().optional().describe(
-          "File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters."
-        ),
-        glob: import_zod.z.string().optional().describe(
-          "Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')"
-        ),
-        caseSensitive: import_zod.z.boolean().optional().default(true).describe("Whether search is case-sensitive (default: true)"),
-        contextLines: import_zod.z.number().optional().describe(
-          "Number of context lines to show before and after each match"
-        ),
-        maxCount: import_zod.z.number().optional().describe(
-          "Maximum number of matches per file (useful for limiting output)"
-        ),
-        filesWithMatches: import_zod.z.boolean().optional().default(false).describe(
-          "Only show file paths that contain matches, not the matching lines themselves"
-        )
-      }),
-      outputSchema: import_zod.z.object({
-        matches: import_zod.z.string().describe(
-          "Search results with file paths, line numbers, and matching content"
-        ),
-        summary: import_zod.z.object({
-          matchCount: import_zod.z.number().describe("Number of matches found"),
-          fileCount: import_zod.z.number().describe("Number of files containing matches"),
-          searchPath: import_zod.z.string().describe("Path that was searched"),
-          pattern: import_zod.z.string().describe("Pattern that was searched for")
-        })
-      }),
+    [builtinToolNames.Grep]: (0, import_ai2.tool)({
+      ...builtInTools.Grep,
       execute: async ({
         pattern,
         path: path2,
@@ -2418,31 +2739,8 @@ function getTools(context) {
         };
       }
     }),
-    List: (0, import_ai.tool)({
-      description: "Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.",
-      inputSchema: import_zod.z.object({
-        path: import_zod.z.string().optional().describe("Path to list (defaults to workspace root)"),
-        depth: import_zod.z.number().optional().describe(
-          "Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping"
-        ),
-        includeHidden: import_zod.z.boolean().optional().default(false).describe(
-          "Include hidden files and directories (those starting with '.')"
-        ),
-        filesOnly: import_zod.z.boolean().optional().default(false).describe("Only show files, not directories"),
-        pattern: import_zod.z.string().optional().describe("Glob pattern to filter results (e.g., '*.ts', '*test*')")
-      }),
-      outputSchema: import_zod.z.object({
-        listing: import_zod.z.string().describe(
-          "Directory tree listing showing paths relative to search root"
-        ),
-        summary: import_zod.z.object({
-          totalItems: import_zod.z.number().describe("Total number of items found"),
-          totalFiles: import_zod.z.number().describe("Total number of files found"),
-          totalDirs: import_zod.z.number().describe("Total number of directories found"),
-          searchPath: import_zod.z.string().describe("Path that was listed"),
-          depth: import_zod.z.number().optional().describe("Maximum depth used (if specified)")
-        })
-      }),
+    [builtinToolNames.List]: (0, import_ai2.tool)({
+      ...builtInTools.List,
       execute: async ({ path: path2, depth, includeHidden, filesOnly, pattern }) => {
         const searchPath = path2 ?? ".";
         const result = await context.sandbox.exec({
@@ -2514,18 +2812,8 @@ function getTools(context) {
         };
       }
     }),
-    Write: (0, import_ai.tool)({
-      description: "Write content to a file. Creates parent directories automatically. Overwrites existing files.",
-      inputSchema: import_zod.z.object({
-        path: import_zod.z.string().describe("Path to the file relative to workspace root"),
-        content: import_zod.z.string().describe("Content to write to the file")
-      }),
-      outputSchema: import_zod.z.object({
-        success: import_zod.z.boolean().describe("Whether the write succeeded"),
-        path: import_zod.z.string().describe("Path to the written file"),
-        bytesWritten: import_zod.z.number().describe("Number of bytes written"),
-        error: import_zod.z.string().optional().describe("Error message if write failed")
-      }),
+    [builtinToolNames.Write]: (0, import_ai2.tool)({
+      ...builtInTools.Write,
       execute: async ({ path: path2, content }) => {
         const filePath = path2.startsWith("/") ? path2.slice(1) : path2;
         const dir = filePath.includes("/") ? filePath.split("/").slice(0, -1).join("/") : ".";
@@ -2554,20 +2842,8 @@ function getTools(context) {
         }
       }
     }),
-    Edit: (0, import_ai.tool)({
-      description: "Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.",
-      inputSchema: import_zod.z.object({
-        path: import_zod.z.string().describe("Path to the file relative to workspace root"),
-        old_string: import_zod.z.string().describe(
-          "Exact string to find and replace (must be unique in file)"
-        ),
-        new_string: import_zod.z.string().describe("String to replace old_string with")
-      }),
-      outputSchema: import_zod.z.object({
-        success: import_zod.z.boolean().describe("Whether the edit succeeded"),
-        path: import_zod.z.string().describe("Path to the edited file"),
-        error: import_zod.z.string().optional().describe("Error message if edit failed")
-      }),
+    [builtinToolNames.Edit]: (0, import_ai2.tool)({
+      ...builtInTools.Edit,
       execute: async ({ path: path2, old_string, new_string }) => {
         const filePath = path2.startsWith("/") ? path2.slice(1) : path2;
         const result = await context.sandbox.exec({
@@ -2635,109 +2911,277 @@ function getTools(context) {
         }
       }
     }),
-    Bash: (0, import_ai.tool)({
-      description: "Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).",
-      inputSchema: import_zod.z.object({
-        command: import_zod.z.string().describe("The shell command to execute"),
-        waitUntil: import_zod.z.number().optional().describe(
-          "Max ms to wait for completion (default: 30000). Use 0 to run in background and return immediately."
-        )
-      }),
-      outputSchema: import_zod.z.object({
-        pid: import_zod.z.number().describe(
-          "System PID (0 for foreground, >0 for background - use to kill)"
-        ),
-        output: import_zod.z.string().describe("Command stdout+stderr combined (empty for background)"),
-        exitCode: import_zod.z.number().describe("Exit code (-1 for background/running)"),
-        status: import_zod.z.enum(["running", "completed", "failed"]).describe("Process status"),
-        cwd: import_zod.z.string().describe("Current working directory after command"),
-        outputFile: import_zod.z.string().describe("Path to output log (for background processes)")
-      }),
+    [builtinToolNames.Bash]: (0, import_ai2.tool)({
+      ...builtInTools.Bash,
       execute: async ({ command, waitUntil }) => {
         const { createProcessManager: createProcessManager2 } = await Promise.resolve().then(() => (init_process_manager(), process_manager_exports));
         const processManager = createProcessManager2({
           sandbox: context.sandbox,
-          sessionId: context.input.sessionId,
-          generateId: () => crypto.randomUUID()
+          sessionId: context.input.sessionId
         });
         await processManager.init();
         return processManager.run({ command, waitUntil });
       }
-    }),
-    ExecuteMCPTool: (0, import_ai.tool)({
-      description: "Execute a tool from an MCP server.",
-      inputSchema: import_zod.z.object({
-        server: import_zod.z.string().describe("MCP server name"),
-        tool: import_zod.z.string().describe("Tool name to execute"),
-        input: import_zod.z.unknown().describe("Tool input matching the tool's schema")
-      }),
-      outputSchema: import_zod.z.object({
-        result: import_zod.z.unknown().optional().describe(
-          "Tool result (included if small enough, else left in the output file)"
-        ),
-        outputPath: import_zod.z.string().describe("Path to the output file containing the full result"),
-        chars: import_zod.z.number().describe("Total characters in the output")
-      }),
-      execute: async ({ server, tool: toolName, input }) => {
-        const serverConfig = context.mcp?.find((s) => s.name === server);
-        if (!serverConfig) {
-          throw new Error(`Unknown MCP server: ${server}`);
-        }
-        const parsedInput = typeof input === "string" ? JSON.parse(input) : input;
-        const timestamp = Date.now();
-        const outputDir = `.agent/mcp/${server}/.outputs`;
-        const outputFile = `${outputDir}/${timestamp}-${toolName}.txt`;
-        const [res] = await Promise.all([
-          fetch(serverConfig.url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              server,
-              tool: toolName,
-              input: parsedInput,
-              sessionId: context.input.sessionId,
-              messageId: context.event.assistantMessageId,
-              hookToken: context.event.hookToken
-            })
-          }),
-          context.sandbox.exec({ command: "mkdir", args: ["-p", outputDir] })
-        ]);
-        if (!res.ok) {
-          const error = await res.text();
-          throw new Error(`MCP tool call failed: ${error}`);
-        }
-        const json = await res.json();
-        if (json.error) {
-          throw new Error(`MCP tool call failed: ${json.error.message}`);
-        }
-        if (json.result === void 0) {
-          throw new Error("MCP tool call failed: No result in response");
-        }
-        const result = json.result;
-        const resultStr = JSON.stringify(result, null, 2);
-        await context.sandbox.writeFiles({
-          files: [{ path: `${timestamp}-${toolName}.txt`, content: resultStr }],
-          destPath: outputDir
+    })
+  };
+  if (context.apiToolsMetadata.length > 0) {
+    const apiTools = buildApiTools({
+      rpc: context.input.rpc,
+      metadata: context.apiToolsMetadata,
+      session: context.session,
+      sandboxRecord: context.sandboxRecord,
+      context: context.event.context
+    });
+    Object.assign(tools, apiTools);
+  }
+  tools[builtinToolNames.JavaScript] = createJavaScriptTool({
+    tools,
+    session: context.session,
+    sandbox: context.sandbox,
+    onSubToolCall: context.onSubToolCall
+  });
+  return tools;
+}
+async function fetchApiToolsMetadata(opts) {
+  const { rpc } = opts;
+  const result = await rpc({ method: "tools.list", params: {} });
+  if ("error" in result) {
+    console.error("[agent] Failed to fetch tools:", result.error?.message);
+    return [];
+  }
+  return result.result ?? [];
+}
+function buildApiTools(opts) {
+  const { rpc, metadata, session, sandboxRecord, context } = opts;
+  const tools = {};
+  for (const meta of metadata) {
+    tools[meta.name] = (0, import_ai2.tool)({
+      description: meta.description ?? `Custom tool: ${meta.name}`,
+      inputSchema: meta.inputSchema ? (0, import_ai2.jsonSchema)(meta.inputSchema) : import_zod2.z.object({}),
+      execute: async (input) => {
+        const result = await rpc({
+          method: "tools.execute",
+          params: {
+            name: meta.name,
+            input,
+            session,
+            sandboxRecord,
+            context
+          }
         });
-        const MAX_OUTPUT_CHARS = 24e3;
-        if (resultStr.length <= MAX_OUTPUT_CHARS) {
-          return { result, outputPath: outputFile, chars: resultStr.length };
+        if ("error" in result) {
+          throw new Error(`Tool execution failed: ${result.error?.message}`);
         }
-        return { outputPath: outputFile, chars: resultStr.length };
+        return result.result;
       }
-    })
+    });
+  }
+  return tools;
+}
+
+// src/utils/prompt-cache.ts
+var ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST = 4;
+var CLAUDE_LIKE_MODEL_MATCHERS = ["claude", "anthropic"];
+var CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS = {
+  anthropic: {
+    cacheControl: { type: "ephemeral" }
+  },
+  openrouter: {
+    cacheControl: { type: "ephemeral" }
+  },
+  bedrock: {
+    cachePoint: { type: "default" }
+  },
+  openaiCompatible: {
+    cache_control: { type: "ephemeral" }
+  },
+  copilot: {
+    copilot_cache_control: { type: "ephemeral" }
+  }
+};
+function getGatewayProvider(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  return model.slice(0, slashIndex);
+}
+function countAnthropicCacheBreakpoints(messages) {
+  let count = 0;
+  for (const message of messages) {
+    const providerOptions = message.providerOptions;
+    if (providerOptions?.anthropic?.cacheControl) {
+      count += 1;
+    }
+    if (Array.isArray(message.content)) {
+      for (const part of message.content) {
+        const partProviderOptions = part.providerOptions;
+        if (partProviderOptions?.anthropic?.cacheControl) {
+          count += 1;
+        }
+      }
+    }
+  }
+  return count;
+}
+function isClaudeLikeModel(model) {
+  const lower = model.toLowerCase();
+  return CLAUDE_LIKE_MODEL_MATCHERS.some((m) => lower.includes(m));
+}
+function mergeProviderOptions(opts) {
+  const next = { ...opts.current ?? {} };
+  for (const [key, value] of Object.entries(opts.patch)) {
+    next[key] = { ...next[key] ?? {}, ...value };
+  }
+  return next;
+}
+function isCacheableClaudePart(part) {
+  if (!part || typeof part !== "object") {
+    return false;
+  }
+  if ("type" in part && part.type === "text") {
+    const text = part.text;
+    if (typeof text === "string") {
+      return text.trim().length > 0;
+    }
+  }
+  if ("type" in part) {
+    const type = part.type;
+    if (type === "thinking" || type === "reasoning") {
+      return false;
+    }
+  }
+  return true;
+}
+function hasCacheableContent(message) {
+  if (typeof message.content === "string") {
+    return message.content.trim().length > 0;
+  }
+  if (Array.isArray(message.content)) {
+    return message.content.some((part) => isCacheableClaudePart(part));
+  }
+  return false;
+}
+function findLastCacheablePartIndex(content) {
+  for (let i = content.length - 1; i >= 0; i -= 1) {
+    if (isCacheableClaudePart(content[i])) {
+      return i;
+    }
+  }
+  return null;
+}
+function selectClaudeCachingTargets(messages) {
+  const systemIndices = [];
+  const finalIndices = [];
+  for (let i = 0; i < messages.length && systemIndices.length < 2; i += 1) {
+    const message = messages[i];
+    if (message.role === "system" && hasCacheableContent(message)) {
+      systemIndices.push(i);
+    }
+  }
+  for (let i = messages.length - 1; i >= 0 && finalIndices.length < 2; i -= 1) {
+    const message = messages[i];
+    if (message.role !== "system" && hasCacheableContent(message)) {
+      finalIndices.push(i);
+    }
+  }
+  finalIndices.reverse();
+  return [...systemIndices, ...finalIndices];
+}
+function applyClaudePromptCaching(opts) {
+  const existingBreakpoints = countAnthropicCacheBreakpoints(opts.messages);
+  const remainingBudget = Math.max(
+    0,
+    opts.maxBreakpointsPerRequest - existingBreakpoints
+  );
+  if (remainingBudget === 0) {
+    return opts.messages;
+  }
+  const targetIndices = selectClaudeCachingTargets(opts.messages).slice(
+    0,
+    remainingBudget
+  );
+  if (targetIndices.length === 0) {
+    return opts.messages;
+  }
+  const useMessageLevelOptions = opts.providerId === "anthropic" || Boolean(opts.providerId?.includes("bedrock"));
+  const nextMessages = opts.messages.slice();
+  for (const messageIndex of targetIndices) {
+    const message = nextMessages[messageIndex];
+    const shouldUseContentOptions = !useMessageLevelOptions && Array.isArray(message.content) && message.content.length > 0;
+    if (shouldUseContentOptions && Array.isArray(message.content)) {
+      const partIndex = findLastCacheablePartIndex(message.content);
+      if (partIndex !== null) {
+        const part = message.content[partIndex];
+        if (part && typeof part === "object") {
+          const partProviderOptions = part.providerOptions;
+          const nextContent = message.content.slice();
+          nextContent[partIndex] = {
+            ...part,
+            providerOptions: mergeProviderOptions({
+              current: partProviderOptions,
+              patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS
+            })
+          };
+          nextMessages[messageIndex] = {
+            ...message,
+            content: nextContent
+          };
+          continue;
+        }
+      }
+    }
+    const messageProviderOptions = message.providerOptions;
+    nextMessages[messageIndex] = {
+      ...message,
+      providerOptions: mergeProviderOptions({
+        current: messageProviderOptions,
+        patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS
+      })
+    };
+  }
+  return nextMessages;
+}
+function applyPromptCachingToModelRequest(opts) {
+  const provider = getGatewayProvider(opts.model);
+  const providerOptions = {};
+  if ((provider === "openai" || provider === "azure") && opts.openai?.setPromptCacheKey !== false) {
+    providerOptions.openai = { promptCacheKey: opts.sessionId };
+  }
+  const maxBreakpointsPerRequest = opts.anthropic?.maxBreakpointsPerRequest ?? ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST;
+  const cachedMessages = isClaudeLikeModel(opts.model) ? applyClaudePromptCaching({
+    messages: opts.messages,
+    providerId: provider,
+    maxBreakpointsPerRequest
+  }) : opts.messages;
+  return {
+    messages: cachedMessages,
+    providerOptions
   };
 }
 
 // src/utils/ui.ts
+function isSubToolPart(part) {
+  const p = part.part;
+  return typeof p?.toolCallId === "string" && p.toolCallId.startsWith("js_tc_");
+}
 function assembleUIMessages(opts) {
+  let filtered = opts.messages;
+  if (opts.until !== void 0) {
+    const until = opts.until;
+    filtered = filtered.filter((m) => m.createdAt <= until);
+  }
+  if (!opts.includeQueued) {
+    filtered = filtered.filter((m) => m.startedAt !== null);
+  }
+  const parts = opts.excludeSubToolParts ? opts.parts.filter((p) => !isSubToolPart(p)) : opts.parts;
   const partsByMessage = /* @__PURE__ */ new Map();
-  for (const part of opts.parts) {
+  for (const part of parts) {
     const existing = partsByMessage.get(part.messageId) ?? [];
     existing.push(part);
     partsByMessage.set(part.messageId, existing);
   }
-  return opts.messages.map((m) => {
+  return filtered.map((m) => {
     const messageParts = partsByMessage.get(m.id) ?? [];
     messageParts.sort((a, b) => a.index - b.index);
     return {
@@ -2745,7 +3189,27 @@ function assembleUIMessages(opts) {
       role: m.role,
       parts: messageParts.map((p) => p.part)
     };
-  });
+  }).filter((m) => m.parts.length > 0);
+}
+
+// src/utils/usage.ts
+function sum(items, key) {
+  return items.reduce((acc, item) => {
+    const value = item[key];
+    return acc + (typeof value === "number" ? value : 0);
+  }, 0);
+}
+function computeUsageSummary(steps) {
+  return {
+    model: steps[0]?.model ?? "unknown",
+    inputTokens: sum(steps, "inputTokens"),
+    outputTokens: sum(steps, "outputTokens"),
+    totalTokens: sum(steps, "totalTokens"),
+    cacheReadTokens: sum(steps, "cacheReadTokens"),
+    cacheWriteTokens: sum(steps, "cacheWriteTokens"),
+    reasoningTokens: sum(steps, "reasoningTokens"),
+    stepCount: steps.length
+  };
 }
 
 // src/agent-workflow-steps.ts
@@ -2786,42 +3250,15 @@ ${backgroundProcessPrompt}
 
 You can use the Read tool to read any skill's SKILL.md file to learn more about it.`;
 }
-function buildMcpToolsContext(mcp) {
-  if (!mcp || mcp.length === 0) {
-    return "";
-  }
-  const serverDocs = mcp.filter(
-    (s) => Array.isArray(s.tools) && s.tools.length > 0
-  ).map((server) => {
-    const toolDocs = server.tools.map((t) => {
-      let doc = `  - ${t.name}: ${t.description}
-    Input: ${JSON.stringify(t.inputSchema)}`;
-      if (t.outputSchema) {
-        doc += `
-    Output: ${JSON.stringify(t.outputSchema)}`;
-      }
-      return doc;
-    }).join("\n");
-    return `### ${server.name}
-${server.description ?? ""}
-${toolDocs}`;
-  }).join("\n\n");
-  if (!serverDocs) {
-    return "";
-  }
-  return `## MCP Tools
-Use the ExecuteMCPTool to call these custom tools:
-
-${serverDocs}`;
-}
 async function completeMessageStep({
   assistantMessageId,
   input,
-  writable
+  writable,
+  usageSteps
 }) {
   "use step";
-  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
-  const storage = getStorage2(input.storageConfig);
+  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_client(), client_exports));
+  const storage = getStorage2({ config: input.storageConfig, rpc: input.rpc });
   const message = await storage.message.get(assistantMessageId);
   if (message instanceof Error) {
     throw message;
@@ -2829,9 +3266,14 @@ async function completeMessageStep({
   if (!message) {
     throw new Error(`Message ${assistantMessageId} not found`);
   }
+  const usage = usageSteps.length > 0 ? {
+    steps: usageSteps,
+    summary: computeUsageSummary(usageSteps)
+  } : null;
   const result = await storage.message.set({
     ...message,
-    completedAt: Date.now()
+    completedAt: Date.now(),
+    usage
   });
   if (result instanceof Error) {
     throw result;
@@ -2839,73 +3281,114 @@ async function completeMessageStep({
   await writable.close();
 }
 var INTERRUPT_POLL_INTERVAL_MS = 500;
-async function pollForInterrupt({
+function pollForInterrupt({
   storage,
   messageId,
   signal,
   abortController
 }) {
-  while (!signal.aborted) {
-    const message = await storage.message.get(messageId);
-    if (message instanceof Error) {
-      return;
-    }
-    if (message.interruptedAt !== null) {
-      abortController.abort();
-      return;
+  let resolveFirstCheck;
+  const firstCheck = new Promise((resolve) => {
+    resolveFirstCheck = resolve;
+  });
+  const poll = async () => {
+    let isFirst = true;
+    while (!signal.aborted) {
+      const message = await storage.message.get(messageId);
+      if (message instanceof Error) {
+        if (isFirst) {
+          resolveFirstCheck();
+        }
+        return;
+      }
+      if (message.interruptedAt !== null) {
+        abortController.abort();
+        if (isFirst) {
+          resolveFirstCheck();
+        }
+        return;
+      }
+      if (isFirst) {
+        isFirst = false;
+        resolveFirstCheck();
+      }
+      await new Promise(
+        (resolve) => setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)
+      );
     }
-    await new Promise(
-      (resolve) => setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)
-    );
-  }
+  };
+  poll();
+  return { firstCheck };
 }
 async function streamTextStep({
   assistantMessageId,
   input,
   event,
   writable,
-  lastPartIndex
+  lastPartIndex,
+  stepIndexOffset
 }) {
   "use step";
   const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_client(), client_exports));
   const { getSandbox: getSandbox2 } = await Promise.resolve().then(() => (init_sandbox(), sandbox_exports));
-  const storage = getStorage2(input.storageConfig);
-  const session = await storage.session.get(input.sessionId);
-  if (session instanceof Error) {
-    throw session;
-  }
-  session;
-  const sandboxRecord = session.sandboxId ? await storage.sandbox.get(session.sandboxId) : null;
-  if (sandboxRecord instanceof Error) {
-    throw sandboxRecord;
-  }
-  if (!sandboxRecord) {
-    throw new import_workflow.FatalError(`Sandbox not found for session ${input.sessionId}`);
-  }
-  const sandbox = getSandbox2({
-    sandboxRecord,
-    storageConfig: input.storageConfig
-  });
+  const storage = getStorage2({ config: input.storageConfig, rpc: input.rpc });
   const abortController = new AbortController();
   const pollController = new AbortController();
-  const _pollPromise = pollForInterrupt({
+  const { firstCheck } = pollForInterrupt({
     storage,
     messageId: assistantMessageId,
     signal: pollController.signal,
     abortController
   });
-  const [messagesResult, partsResult, skills] = await Promise.all([
+  const [
+    ,
+    messagesResult,
+    partsResult,
+    { session, skills, sandbox, sandboxRecord },
+    apiToolsMetadata
+  ] = await Promise.all([
+    firstCheck,
     storage.message.list(input.sessionId),
     storage.part.listBySession(input.sessionId),
-    discoverSkillsInSandbox({
-      sandbox,
-      skillsDirs: session.skillsDir || [],
-      debug: true
+    storage.session.get(input.sessionId).then(async (session2) => {
+      if (session2 instanceof Error) {
+        throw session2;
+      }
+      const sandboxRecord2 = session2.sandboxId ? await storage.sandbox.get(session2.sandboxId) : null;
+      if (sandboxRecord2 instanceof Error) {
+        throw sandboxRecord2;
+      }
+      if (!sandboxRecord2) {
+        throw new import_workflow2.FatalError(
+          `Sandbox not found for session ${input.sessionId}`
+        );
+      }
+      const sandbox2 = getSandbox2({
+        sandboxRecord: sandboxRecord2,
+        storageConfig: input.storageConfig,
+        storage,
+        rpc: input.rpc
+      });
+      const skills2 = await discoverSkillsInSandbox({
+        sandbox: sandbox2,
+        skillsDirs: session2.skillsDir || [],
+        debug: true
+      });
+      return { session: session2, skills: skills2, sandbox: sandbox2, sandboxRecord: sandboxRecord2 };
+    }),
+    fetchApiToolsMetadata({
+      rpc: input.rpc
     })
   ]);
   if (abortController.signal.aborted) {
     pollController.abort();
-    return { finishReason: "stop", lastPartIndex };
+    return {
+      finishReason: "stop",
+      lastPartIndex,
+      usageSteps: [],
+      pendingApprovals: [],
+      maxSteps: void 0
+    };
   }
   if (messagesResult instanceof Error) {
     throw messagesResult;
@@ -2913,73 +3396,329 @@ async function streamTextStep({
   if (partsResult instanceof Error) {
     throw partsResult;
   }
-  console.log("[agent] Discovered skills:", {
-    count: skills.length,
-    skills: skills.map((s) => ({
-      name: s.name,
-      description: s.description,
-      path: s.skillMdPath
-    })),
-    skillsDirs: session.skillsDir
+  const setStartedPromise = lastPartIndex === 0 ? (async () => {
+    const now = Date.now();
+    const pendingMessages = messagesResult.items.filter(
+      (m) => m.createdAt <= event.createdAt && m.startedAt === null
+    );
+    if (pendingMessages.length > 0) {
+      return await Promise.all(
+        pendingMessages.map(
+          (m) => storage.message.set({
+            ...m,
+            startedAt: now,
+            completedAt: m.role === "assistant" ? null : now
+          })
+        )
+      );
+    }
+  })() : null;
+  const streamWriterRef = { current: null };
+  const subToolPartIds = [];
+  let nextPartIndex = lastPartIndex;
+  const onSubToolCall = async (toolName, toolInput, execute) => {
+    const res = await input.rpc({
+      method: "tools.needsApproval",
+      params: {
+        toolName,
+        input: toolInput,
+        toolCallId: `js_${toolName}_${Date.now()}`,
+        messages: []
+      }
+    });
+    if ("error" in res || res.result !== true) {
+      try {
+        const result2 = await execute();
+        return { result: result2 };
+      } catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+    const approvalId = `js_approval_${(0, import_ulid2.ulid)()}`;
+    const toolCallId = `js_tc_${(0, import_ulid2.ulid)()}`;
+    const partId = `part_${(0, import_ulid2.ulid)()}`;
+    subToolPartIds.push(partId);
+    await storage.part.set({
+      id: partId,
+      index: nextPartIndex++,
+      messageId: assistantMessageId,
+      sessionId: input.sessionId,
+      part: {
+        type: `tool-${toolName}`,
+        toolCallId,
+        state: "approval-requested",
+        input: toolInput,
+        approval: { id: approvalId }
+      }
+    });
+    streamWriterRef.current?.({
+      type: "tool-input-start",
+      toolCallId,
+      toolName
+    });
+    streamWriterRef.current?.({
+      type: "tool-input-available",
+      toolCallId,
+      toolName,
+      input: toolInput
+    });
+    streamWriterRef.current?.({
+      type: "tool-approval-request",
+      approvalId,
+      toolCallId
+    });
+    const POLL_MS = 500;
+    const TIMEOUT_MS = 5 * 60 * 1e3;
+    const start2 = Date.now();
+    while (Date.now() - start2 < TIMEOUT_MS) {
+      const parts = await storage.part.listBySession(input.sessionId);
+      if (!(parts instanceof Error)) {
+        const updated = parts.items.find(
+          (p) => p.id === partId && "state" in p.part && p.part.state === "approval-responded"
+        );
+        if (updated) {
+          const approval = updated.part.approval;
+          if (approval?.approved) {
+            try {
+              const result2 = await execute();
+              streamWriterRef.current?.({
+                type: "tool-output-available",
+                toolCallId,
+                output: result2
+              });
+              return { result: result2 };
+            } catch (err) {
+              const error = err instanceof Error ? err.message : String(err);
+              streamWriterRef.current?.({
+                type: "tool-output-error",
+                toolCallId,
+                errorText: error
+              });
+              return { error };
+            }
+          }
+          streamWriterRef.current?.({
+            type: "tool-output-denied",
+            toolCallId
+          });
+          return {
+            error: `Tool "${toolName}" denied: ${approval?.reason || "user denied"}`
+          };
+        }
+      }
+      await new Promise((r) => setTimeout(r, POLL_MS));
+    }
+    return { error: "Approval timed out" };
+  };
+  const rawTools = getTools({
+    input,
+    event,
+    sandbox,
+    session,
+    sandboxRecord,
+    apiToolsMetadata,
+    onSubToolCall
   });
+  const skillsContext = buildSkillsContext(skills);
+  const systemHeader = joinPromptSections(BASE_SYSTEM_PROMPT, session.system);
+  const systemContext = joinPromptSections(skillsContext);
+  if (!session.model) {
+    throw new import_workflow2.FatalError("Session model is not set");
+  }
+  const systemMessages = [
+    ...systemHeader.trim() ? [{ role: "system", content: systemHeader }] : [],
+    ...systemContext.trim() ? [{ role: "system", content: systemContext }] : []
+  ];
+  const allParts = partsResult.items;
+  const approvedParts = allParts.filter(
+    (p) => p.part && "state" in p.part && p.part.state === "approval-responded" && "approval" in p.part && p.part.approval?.approved === true
+  );
+  const executedApprovals = [];
+  if (approvedParts.length > 0) {
+    const preExecMessages = [
+      ...systemMessages,
+      ...await (0, import_ai3.convertToModelMessages)(
+        assembleUIMessages({
+          messages: messagesResult.items,
+          parts: allParts,
+          until: event.createdAt,
+          includeQueued: true,
+          excludeSubToolParts: true
+        })
+      )
+    ];
+    await Promise.all(
+      approvedParts.map(async (ap) => {
+        if (!ap.part.type.startsWith("tool-")) {
+          return;
+        }
+        const part = ap.part;
+        const toolName = part.type.replace("tool-", "");
+        const toolDef = rawTools[toolName];
+        if (toolDef?.execute && part.input !== void 0) {
+          try {
+            const toolOutput = await toolDef.execute(part.input, {
+              toolCallId: part.toolCallId,
+              messages: preExecMessages,
+              abortSignal: abortController.signal,
+              experimental_context: {
+                session,
+                sandbox,
+                storage,
+                context: event.context
+              }
+            });
+            part.state = "output-available";
+            part.output = toolOutput;
+            executedApprovals.push({
+              toolCallId: part.toolCallId,
+              output: toolOutput
+            });
+          } catch (err) {
+            part.state = "output-error";
+            part.errorText = err instanceof Error ? err.message : String(err);
+            executedApprovals.push({
+              toolCallId: part.toolCallId,
+              output: void 0,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
+          await storage.part.set({ ...ap, part });
+        }
+      })
+    );
+  }
   const uiMessages = assembleUIMessages({
     messages: messagesResult.items,
-    parts: partsResult.items
+    parts: allParts,
+    until: event.createdAt,
+    includeQueued: true,
+    excludeSubToolParts: true
   });
-  const mcp = session.mcp;
-  const skillsContext = buildSkillsContext(skills);
-  console.log("[agent] Skills context added to system prompt:", {
-    hasSkills: skills.length > 0,
-    contextLength: skillsContext.length,
-    contextPreview: skillsContext.slice(0, 200)
+  const modelMessages = [
+    ...systemMessages,
+    ...await (0, import_ai3.convertToModelMessages)(uiMessages)
+  ];
+  const promptCaching = applyPromptCachingToModelRequest({
+    model: session.model,
+    sessionId: input.sessionId,
+    messages: modelMessages
   });
-  const systemPrompt = joinPromptSections(
-    BASE_SYSTEM_PROMPT,
-    session.instructions,
-    skillsContext,
-    buildMcpToolsContext(mcp)
+  const usageSteps = [];
+  let internalStepIndex = 0;
+  const tools = Object.fromEntries(
+    Object.entries(rawTools).map(([name, t]) => [
+      name,
+      {
+        ...t,
+        needsApproval: async (toolInput, opts) => {
+          const res = await input.rpc({
+            method: "tools.needsApproval",
+            params: {
+              toolName: name,
+              input: toolInput,
+              toolCallId: opts.toolCallId,
+              messages: opts.messages
+            }
+          });
+          if ("error" in res) {
+            throw new Error(
+              `tools.needsApproval RPC failed for ${name}: ${res.error.message}`
+            );
+          }
+          return res.result;
+        }
+      }
+    ])
   );
-  console.log("[agent] System prompt built:", {
-    totalLength: systemPrompt.length,
-    hasSkills: skills.length > 0
-  });
-  if (!session.model) {
-    throw new import_workflow.FatalError("Session model is not set");
-  }
-  const result = (0, import_ai2.streamText)({
-    messages: await (0, import_ai2.convertToModelMessages)(uiMessages),
-    tools: getTools({ input, event, mcp, sandbox }),
-    system: systemPrompt,
+  const result = (0, import_ai3.streamText)({
+    messages: promptCaching.messages,
+    tools,
     model: session.model,
-    abortSignal: abortController.signal
+    abortSignal: abortController.signal,
+    activeTools: session.activeTools ?? void 0,
+    providerOptions: promptCaching.providerOptions,
+    stopWhen: (0, import_ai3.stepCountIs)(1),
+    temperature: session.generation?.temperature,
+    topK: session.generation?.topK,
+    topP: session.generation?.topP,
+    frequencyPenalty: session.generation?.frequencyPenalty,
+    presencePenalty: session.generation?.presencePenalty,
+    maxOutputTokens: session.generation?.maxOutputTokens,
+    headers: session.generation?.headers,
+    experimental_context: {
+      session,
+      sandbox,
+      storage,
+      context: event.context
+    },
+    onStepFinish: ({ usage }) => {
+      if (usage) {
+        usageSteps.push({
+          stepIndex: stepIndexOffset + internalStepIndex,
+          model: session.model ?? "unknown",
+          inputTokens: usage.inputTokens ?? 0,
+          outputTokens: usage.outputTokens ?? 0,
+          totalTokens: usage.totalTokens ?? 0,
+          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+          cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+          reasoningTokens: usage.outputTokenDetails?.reasoningTokens ?? 0
+        });
+      }
+      internalStepIndex++;
+    }
   });
   const stepParts = [];
   let wasAborted = false;
   try {
-    await result.toUIMessageStream({
-      generateMessageId: () => assistantMessageId,
-      onFinish: ({ messages }) => {
-        for (const m of messages) {
-          if (m.role === "assistant") {
-            stepParts.push(...m.parts);
+    const stream = (0, import_ai3.createUIMessageStream)({
+      execute: ({ writer }) => {
+        streamWriterRef.current = (event2) => writer.write(event2);
+        for (const ea of executedApprovals) {
+          if (ea.error) {
+            writer.write({
+              type: "tool-output-error",
+              toolCallId: ea.toolCallId,
+              errorText: ea.error
+            });
+          } else {
+            writer.write({
+              type: "tool-output-available",
+              toolCallId: ea.toolCallId,
+              output: ea.output
+            });
           }
         }
+        writer.merge(
+          result.toUIMessageStream({
+            generateMessageId: () => assistantMessageId,
+            onFinish: ({ messages }) => {
+              for (const m of messages) {
+                if (m.role === "assistant") {
+                  stepParts.push(...m.parts);
+                }
+              }
+            }
+          })
+        );
       }
-    }).pipeTo(writable, { preventClose: true });
+    });
+    await stream.pipeTo(writable, { preventClose: true });
   } catch (err) {
     if (abortController.signal.aborted) {
       wasAborted = true;
     } else {
+      console.error("[streamTextStep] stream error:", err);
       throw err;
     }
   } finally {
     pollController.abort();
   }
   await Promise.all(
-    stepParts.map(async (uiPart, index) => {
+    stepParts.map(async (uiPart) => {
       const result2 = await storage.part.set({
         id: `part_${(0, import_ulid2.ulid)()}`,
-        index: lastPartIndex + index,
+        index: nextPartIndex++,
         messageId: assistantMessageId,
         sessionId: input.sessionId,
         part: uiPart
@@ -2990,15 +3729,36 @@ async function streamTextStep({
       return result2;
     })
   );
-  const newLastPartIndex = lastPartIndex + stepParts.length;
+  if (setStartedPromise) {
+    const setStartedResult = await setStartedPromise;
+    if (setStartedResult instanceof Error) {
+      throw setStartedResult;
+    }
+    for (const m of setStartedResult ?? []) {
+      if (m instanceof Error) {
+        throw m;
+      }
+    }
+  }
+  const pendingApprovals = stepParts.filter(
+    (p) => "state" in p && p.state === "approval-requested" && "approval" in p && !!p.approval?.id
+  ).map((p) => ({
+    approvalId: p.approval.id,
+    toolName: "type" in p ? String(p.type).replace("tool-", "") : "unknown"
+  }));
+  const finalFinishReason = wasAborted ? "stop" : await result.finishReason;
   return {
-    finishReason: wasAborted ? "stop" : await result.finishReason,
-    lastPartIndex: newLastPartIndex
+    finishReason: finalFinishReason,
+    lastPartIndex: nextPartIndex,
+    usageSteps,
+    pendingApprovals,
+    maxSteps: session.generation?.maxSteps
   };
 }
 
 // src/agent-workflow.ts
-var agentMessageHook = (0, import_workflow2.defineHook)();
+var agentMessageHook = (0, import_workflow3.defineHook)();
+var approvalHook = (0, import_workflow3.defineHook)();
 async function agentWorkflow({
   input,
   event
@@ -3008,7 +3768,7 @@ async function agentWorkflow({
   const iterator = messageHook[Symbol.asyncIterator]();
   let pendingNext = iterator.next();
   await onMessage({ event, input }).catch((e) => {
-    if (import_workflow2.FatalError.is(e)) {
+    if (import_workflow3.FatalError.is(e)) {
       console.error("Message processing failed permanently:", e.message);
       return;
     }
@@ -3021,7 +3781,7 @@ async function agentWorkflow({
       break;
     }
     await onMessage({ event: result.value, input }).catch((e) => {
-      if (import_workflow2.FatalError.is(e)) {
+      if (import_workflow3.FatalError.is(e)) {
         console.error("Message processing failed permanently:", e.message);
         return;
       }
@@ -3034,9 +3794,10 @@ async function onMessage({
   event,
   input
 }) {
-  const writable = (0, import_workflow2.getWritable)({ namespace: event.assistantMessageId });
+  const writable = (0, import_workflow3.getWritable)({ namespace: event.assistantMessageId });
   let finishReason;
   let lastPartIndex = 0;
+  const usageSteps = [];
   while (finishReason !== "stop") {
     try {
       const result = await streamTextStep({
@@ -3044,10 +3805,24 @@ async function onMessage({
         writable,
         input,
         event,
-        lastPartIndex
+        lastPartIndex,
+        stepIndexOffset: usageSteps.length
       });
       finishReason = result.finishReason;
       lastPartIndex = result.lastPartIndex;
+      usageSteps.push(...result.usageSteps);
+      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {
+        break;
+      }
+      if (result.pendingApprovals.length > 0) {
+        await Promise.all(
+          result.pendingApprovals.map((pending) => {
+            const hook = approvalHook.create({ token: pending.approvalId });
+            const iter = hook[Symbol.asyncIterator]();
+            return iter.next();
+          })
+        );
+      }
     } catch (err) {
       console.error(err);
       throw err;
@@ -3056,12 +3831,14 @@ async function onMessage({
   await completeMessageStep({
     assistantMessageId: event.assistantMessageId,
     input,
-    writable
+    writable,
+    usageSteps
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   agentMessageHook,
-  agentWorkflow
+  agentWorkflow,
+  approvalHook
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/process-manager.ts", "../src/errors.ts", "../src/utils/paginate.ts", "../src/storage/bindings/local-fs-handlers.ts", "../src/storage/bindings/local.ts", "../src/storage/bindings/vercel.ts", "../src/storage/client.ts", "../src/storage/rpc.ts", "../src/storage/handler.ts", "../src/storage/index.ts", "../src/sandbox/write-files.ts", "../src/sandbox/bindings/local.ts", "../src/sandbox/bindings/vercel.ts", "../src/sandbox/client.ts", "../src/sandbox/index.ts", "../src/agent-workflow.ts", "../src/agent-workflow-steps.ts", "../src/skills/parser.ts", "../src/skills/discover.ts", "../src/tools/index.ts", "../src/utils/ui.ts"],
  "sourcesContent": ["import type { BashResult, Sandbox } from \"./types\";\n\nconst DEFAULT_WAIT_UNTIL = 30000;\n\n/**\n * Shell script that handles all process execution logic.\n * Installed to ~/.agent/bin/run.sh during init().\n */\nconst RUN_SCRIPT = `#!/bin/sh\n# Process runner for Agent SDK\n# All parameters passed via environment variables to avoid escaping issues\n# Output is base64 encoded to avoid JSON escaping issues\n\nAGENT_DIR=\"$HOME/.agent\"\nCWD_FILE=\"$AGENT_DIR/cwd/$SESSION_ID\"\n\n# Get current working directory (per-session)\nif [ -f \"$CWD_FILE\" ]; then\n  CWD=$(cat \"$CWD_FILE\")\nelse\n  CWD=\"$HOME\"\nfi\n\n# Decode command\nCMD=$(echo \"$CMD_BASE64\" | base64 -d)\n\n# Background mode (waitUntil = 0)\nif [ \"$WAIT_UNTIL\" = \"0\" ]; then\n  cd \"$CWD\" || cd \"$HOME\"\n\n  # Generate a simple numeric ID for output file\n  OUTPUT_ID=\"$(date +%s)$$\"\n  OUTPUT_FILE=\"$AGENT_DIR/outputs/$OUTPUT_ID.log\"\n\n  # Double-fork to fully detach the process\n  (\n    (\n      eval \"$CMD\"\n      pwd > \"$CWD_FILE\" 2>/dev/null\n    ) > \"$OUTPUT_FILE\" 2>&1 < /dev/null &\n    echo $! > \"$AGENT_DIR/pids/$OUTPUT_ID.pid\"\n  )\n\n  # Small delay to ensure PID file is written\n  sleep 0.05\n\n  # Read PID\n  if [ -f \"$AGENT_DIR/pids/$OUTPUT_ID.pid\" ]; then\n    PID=$(cat \"$AGENT_DIR/pids/$OUTPUT_ID.pid\")\n  else\n    PID=0\n  fi\n\n  # Output JSON result (no output for background, so no encoding needed)\n  printf '{\"pid\":%d,\"outputBase64\":\"\",\"exitCode\":-1,\"status\":\"running\",\"outputFile\":\"%s\",\"cwd\":\"%s\"}\\\\n' \\\\\n    \"$PID\" \"$OUTPUT_FILE\" \"$CWD\"\n  exit 0\nfi\n\n# Foreground mode (waitUntil > 0) - run directly and capture output\ncd \"$CWD\" || cd \"$HOME\"\n\n# Run command, capture output and exit code\nOUTPUT=$(eval \"$CMD\" 2>&1)\nEXIT_CODE=$?\n\n# Update CWD after command\nNEW_CWD=$(pwd)\necho \"$NEW_CWD\" > \"$CWD_FILE\"\n\n# Determine status\nif [ $EXIT_CODE -eq 0 ]; then\n  STATUS=\"completed\"\nelse\n  STATUS=\"failed\"\nfi\n\n# Base64 encode output to avoid ALL escaping issues\nOUTPUT_BASE64=$(printf '%s' \"$OUTPUT\" | base64 | tr -d '\\\\n')\n\n# Output JSON result with base64-encoded output\nprintf '{\"pid\":0,\"outputBase64\":\"%s\",\"exitCode\":%d,\"status\":\"%s\",\"outputFile\":\"\",\"cwd\":\"%s\"}\\\\n' \\\\\n  \"$OUTPUT_BASE64\" \"$EXIT_CODE\" \"$STATUS\" \"$NEW_CWD\"\n`;\n\ntype RunOptions = {\n  command: string;\n  /**\n   * Max ms to wait for completion.\n   * - 0: Background mode - return immediately with PID\n   * - >0: Foreground mode - wait for completion (default: 30000)\n   */\n  waitUntil?: number;\n};\n\n/**\n * Process manager that uses a single shell script to handle all execution logic.\n * Reduces round-trips to the sandbox by doing everything in one exec call.\n */\nexport const createProcessManager = (opts: {\n  sandbox: Sandbox;\n  sessionId: string;\n  generateId: () => string;\n}) => {\n  const { sandbox, sessionId } = opts;\n  let initialized = false;\n\n  const init = async (): Promise<void> => {\n    if (initialized) {\n      return;\n    }\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `mkdir -p $HOME/.agent/bin $HOME/.agent/pids $HOME/.agent/outputs $HOME/.agent/cwd\ncat > $HOME/.agent/bin/run.sh << 'SCRIPT_EOF'\n${RUN_SCRIPT}\nSCRIPT_EOF\nchmod +x $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n    await result.result;\n    initialized = true;\n  };\n\n  const run = async (opts: RunOptions): Promise<BashResult> => {\n    await init();\n\n    const { command, waitUntil = DEFAULT_WAIT_UNTIL } = opts;\n    const cmdBase64 = Buffer.from(command, \"utf-8\").toString(\"base64\");\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `CMD_BASE64=\"${cmdBase64}\" WAIT_UNTIL=\"${waitUntil}\" SESSION_ID=\"${sessionId}\" $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n\n    const { stdout } = await result.result;\n    const parsed = JSON.parse(stdout.trim()) as {\n      pid: number;\n      outputBase64: string;\n      exitCode: number;\n      status: \"running\" | \"completed\" | \"failed\";\n      outputFile: string;\n      cwd: string;\n    };\n\n    // Decode base64 output\n    const output = parsed.outputBase64\n      ? Buffer.from(parsed.outputBase64, \"base64\").toString(\"utf-8\")\n      : \"\";\n\n    return {\n      pid: parsed.pid,\n      output,\n      exitCode: parsed.exitCode,\n      status: parsed.status,\n      cwd: parsed.cwd,\n      outputFile: parsed.outputFile,\n    };\n  };\n\n  const getCwd = async (): Promise<string> => {\n    await init();\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `cat $HOME/.agent/cwd/${sessionId} 2>/dev/null || echo \"$HOME\"`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      return process.cwd();\n    }\n\n    const { stdout } = await result.result;\n    return stdout.trim() || process.cwd();\n  };\n\n  return {\n    init,\n    run,\n    getCwd,\n  };\n};\n\nexport type ProcessManager = ReturnType<typeof createProcessManager>;\n", "import * as errore from \"errore\";\n\nexport class SessionNotFoundError extends errore.createTaggedError({\n  name: \"SessionNotFoundError\",\n  message: \"Session $id not found\",\n}) {}\n\nexport class SessionError extends errore.createTaggedError({\n  name: \"SessionError\",\n  message: \"Session $id failed: $reason\",\n}) {}\n\nexport class SandboxNotFoundError extends errore.createTaggedError({\n  name: \"SandboxNotFoundError\",\n  message: \"Sandbox $id not found\",\n}) {}\n\nexport class StorageError extends errore.createTaggedError({\n  name: \"StorageError\",\n  message: \"$reason\",\n}) {}\n\nexport class SandboxError extends errore.createTaggedError({\n  name: \"SandboxError\",\n  message: \"$reason\",\n}) {}\n\nexport class MessageNotFoundError extends errore.createTaggedError({\n  name: \"MessageNotFoundError\",\n  message: \"Message $id not found\",\n}) {}\n", "import type { ListResult } from \"../storage\";\n\nexport function paginate<T extends { id: string }>(opts: {\n  items: T[];\n  cursor?: string;\n  limit?: number;\n}): ListResult<T> {\n  const { items, cursor, limit = 50 } = opts;\n  const startIndex = cursor ? items.findIndex((m) => m.id === cursor) + 1 : 0;\n  const sliced = items.slice(startIndex, startIndex + limit);\n  const nextCursor =\n    startIndex + limit < items.length ? (sliced.at(-1)?.id ?? null) : null;\n  return { items: sliced, nextCursor };\n}\n", "import { mkdir, readdir, readFile, writeFile } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport { paginate } from \"../../utils/paginate\";\nimport type {\n  Command,\n  Handlers,\n  Message,\n  Part,\n  SandboxRecord,\n  Session,\n} from \"..\";\n\nexport function createFilesystemHandlers(basePath: string): Handlers {\n  const sessionDir = join(basePath, \"session\");\n  const messageDir = join(basePath, \"message\");\n  const partDir = join(basePath, \"part\");\n  const sandboxDir = join(basePath, \"sandbox\");\n  const commandDir = join(basePath, \"command\");\n\n  async function ensureDir(dir: string) {\n    await mkdir(dir, { recursive: true });\n  }\n\n  async function readJson<T>(filePath: string): Promise<T | null> {\n    try {\n      const content = await readFile(filePath, \"utf-8\");\n      return JSON.parse(content) as T;\n    } catch {\n      return null;\n    }\n  }\n\n  async function writeJsonFile(filePath: string, data: unknown) {\n    await ensureDir(dirname(filePath));\n    await writeFile(filePath, JSON.stringify(data, null, 2));\n  }\n\n  async function readAllFromDir<T>(dir: string): Promise<T[]> {\n    try {\n      const files = await readdir(dir);\n      const results = await Promise.all(\n        files\n          .filter((f) => f.endsWith(\".json\"))\n          .map((f) => readJson<T>(join(dir, f)))\n      );\n      return results.filter((r): r is NonNullable<typeof r> => r !== null);\n    } catch {\n      return [];\n    }\n  }\n\n  return {\n    \"session.get\": async ({ id }) => {\n      const session = await readJson<Session>(join(sessionDir, `${id}.json`));\n      return session ?? null;\n    },\n\n    \"session.set\": async (session) => {\n      const now = Date.now();\n      const sessionPath = join(sessionDir, `${session.id}.json`);\n      const existing = await readJson<Session>(sessionPath);\n      const newSession: Session = {\n        ...session,\n        tags: session.tags ?? existing?.tags ?? {},\n        createdAt: existing?.createdAt ?? session.createdAt ?? now,\n        updatedAt: now,\n      };\n      await writeJsonFile(sessionPath, newSession);\n      return newSession;\n    },\n\n    \"session.list\": async ({ tags, cursor, limit }) => {\n      const allSessions = await readAllFromDir<Session>(sessionDir);\n      let filtered = allSessions;\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sessionTags = s.tags ?? {};\n          return Object.entries(tags).every(\n            ([key, value]) => sessionTags[key] === value\n          );\n        });\n      }\n      filtered.sort((a, b) => a.createdAt - b.createdAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"session.listBySandbox\": async ({ sandboxId, tags, cursor, limit }) => {\n      const allSessions = await readAllFromDir<Session>(sessionDir);\n      let filtered = allSessions.filter((s) => s.sandboxId === sandboxId);\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sessionTags = s.tags ?? {};\n          return Object.entries(tags).every(\n            ([key, value]) => sessionTags[key] === value\n          );\n        });\n      }\n      filtered.sort((a, b) => a.createdAt - b.createdAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"session.tag.set\": async ({ sessionId, tags }) => {\n      const sessionPath = join(sessionDir, `${sessionId}.json`);\n      const existing = await readJson<Session>(sessionPath);\n      if (!existing) {\n        throw new Error(`Session ${sessionId} not found`);\n      }\n      const mergedTags = { ...existing.tags, ...tags };\n      const now = Date.now();\n      const updatedSession: Session = {\n        ...existing,\n        tags: mergedTags,\n        updatedAt: now,\n      };\n      await writeJsonFile(sessionPath, updatedSession);\n      return updatedSession;\n    },\n\n    \"message.get\": async ({ id }) => {\n      return await readJson<Message>(join(messageDir, `${id}.json`));\n    },\n\n    \"message.set\": async (message) => {\n      await writeJsonFile(join(messageDir, `${message.id}.json`), message);\n      return message;\n    },\n\n    \"message.list\": async ({ sessionId, cursor, limit }) => {\n      const allMessages = await readAllFromDir<Message>(messageDir);\n      const filtered = allMessages\n        .filter((m) => m.sessionId === sessionId)\n        .sort((a, b) => a.createdAt - b.createdAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.listByMessage\": async ({ messageId, cursor, limit }) => {\n      const allParts = await readAllFromDir<Part>(partDir);\n      const filtered = allParts\n        .filter((p) => p.messageId === messageId)\n        .sort((a, b) => a.index - b.index);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.listBySession\": async ({ sessionId, cursor, limit }) => {\n      const allParts = await readAllFromDir<Part>(partDir);\n      const filtered = allParts\n        .filter((p) => p.sessionId === sessionId)\n        .sort((a, b) => {\n          if (a.messageId !== b.messageId) {\n            return a.messageId.localeCompare(b.messageId);\n          }\n          return a.index - b.index;\n        });\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.set\": async (part) => {\n      await writeJsonFile(join(partDir, `${part.id}.json`), part);\n      return part;\n    },\n\n    \"sandbox.get\": async ({ key }) => {\n      const safeName = Buffer.from(key).toString(\"base64url\");\n      const sandboxPath = join(sandboxDir, `${safeName}.json`);\n      const data = await readJson<SandboxRecord>(sandboxPath);\n      if (!data) {\n        return null;\n      }\n      return data;\n    },\n\n    \"sandbox.set\": async (record) => {\n      const safeName = Buffer.from(record.id).toString(\"base64url\");\n      const sandboxPath = join(sandboxDir, `${safeName}.json`);\n      const existing = await readJson<SandboxRecord>(sandboxPath);\n      const newRecord: SandboxRecord = {\n        ...record,\n        tags: record.tags ?? existing?.tags ?? null,\n      };\n      await writeJsonFile(sandboxPath, newRecord);\n    },\n\n    \"sandbox.list\": async ({ tags, order, cursor, limit }) => {\n      const allSandboxes = await readAllFromDir<SandboxRecord>(sandboxDir);\n      let filtered = allSandboxes;\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sandboxTags = s.tags ?? {};\n          return Object.entries(tags).every(\n            ([key, value]) => sandboxTags[key] === value\n          );\n        });\n      }\n      const sortField = order?.startsWith(\"lastActivityAt\")\n        ? \"lastActivityAt\"\n        : \"createdAt\";\n      const sortDir = order?.endsWith(\"_desc\") ? -1 : 1;\n      filtered.sort(\n        (a, b) => sortDir * ((a[sortField] ?? 0) - (b[sortField] ?? 0))\n      );\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"sandbox.tag.set\": async ({ sandboxId, tags }) => {\n      const safeName = Buffer.from(sandboxId).toString(\"base64url\");\n      const sandboxPath = join(sandboxDir, `${safeName}.json`);\n      const existing = await readJson<SandboxRecord>(sandboxPath);\n      if (!existing) {\n        throw new Error(`Sandbox ${sandboxId} not found`);\n      }\n      const mergedTags = { ...existing.tags, ...tags };\n      const updatedSandbox: SandboxRecord = {\n        ...existing,\n        tags: mergedTags,\n      };\n      await writeJsonFile(sandboxPath, updatedSandbox);\n      return updatedSandbox;\n    },\n\n    \"sandbox.getBySession\": async ({ sessionId }) => {\n      const allSandboxes = await readAllFromDir<SandboxRecord>(sandboxDir);\n      const matching = allSandboxes.filter((s) =>\n        s.id.startsWith(`${sessionId}-`)\n      );\n      if (matching.length === 0) {\n        return null;\n      }\n      matching.sort(\n        (a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0)\n      );\n      return matching[0];\n    },\n\n    \"command.get\": async ({ id }) => {\n      return await readJson<Command>(join(commandDir, `${id}.json`));\n    },\n\n    \"command.set\": async (command) => {\n      await writeJsonFile(join(commandDir, `${command.id}.json`), command);\n      return command;\n    },\n\n    \"command.list\": async ({ sessionId, includeFinished, cursor, limit }) => {\n      const allCommands = await readAllFromDir<Command>(commandDir);\n      let filtered = allCommands.filter((c) => c.sessionId === sessionId);\n      if (!includeFinished) {\n        filtered = filtered.filter((c) => c.status === \"running\");\n      }\n      filtered.sort((a, b) => a.startedAt - b.startedAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n  };\n}\n", "import { type ServerType, serve } from \"@hono/node-server\";\nimport { Hono } from \"hono\";\nimport { handleStorageRpc } from \"..\";\nimport { createFilesystemHandlers } from \"./local-fs-handlers\";\n\nconst DEFAULT_STORAGE_DIR = \".agent-storage\";\n\nlet startPromise: Promise<string> | null = null;\nlet serverInstance: { url: string; server: ServerType } | null = null;\n\nexport function startLocalStorage(opts?: {\n  path?: string;\n  port?: number;\n}): Promise<string> {\n  if (startPromise) {\n    return startPromise;\n  }\n\n  startPromise = new Promise((resolve) => {\n    const handlers = createFilesystemHandlers(\n      opts?.path ?? DEFAULT_STORAGE_DIR\n    );\n    const app = new Hono();\n\n    app.post(\"/\", async (c) => {\n      const body = await c.req.json();\n      const response = await handleStorageRpc(body, handlers);\n      return c.json(response);\n    });\n\n    const port = opts?.port ?? 0;\n    const server = serve({\n      fetch: app.fetch,\n      port,\n    });\n\n    server.on(\"listening\", () => {\n      const address = server.address();\n      const actualPort = typeof address === \"object\" ? address?.port : port;\n      const url = `http://localhost:${actualPort}`;\n\n      serverInstance = { url, server };\n      console.log(`[agent] Local storage server started at ${url}`);\n      resolve(url);\n    });\n  });\n\n  return startPromise;\n}\n\nexport function stopLocalStorage(): void {\n  if (serverInstance) {\n    serverInstance.server.close();\n    serverInstance = null;\n    startPromise = null;\n  }\n}\n\nif (typeof process !== \"undefined\") {\n  process.on(\"SIGTERM\", stopLocalStorage);\n  process.on(\"SIGINT\", stopLocalStorage);\n}\n", "const VERCEL_STORAGE_URL =\n  \"https://agent-sdk-storage-nine.labs.vercel.dev/api/storage\";\n\nexport type VercelStorageConfig = {\n  url: string;\n  headers: Record<string, string>;\n};\n\nexport async function getVercelStorageConfig(): Promise<VercelStorageConfig> {\n  let token: string | null = null;\n\n  try {\n    const { getVercelOidcToken } = await import(\"@vercel/oidc\");\n    token = await getVercelOidcToken();\n  } catch {\n    // OIDC not available (local dev, non-Vercel environment)\n  }\n\n  return {\n    url: VERCEL_STORAGE_URL,\n    headers: token ? { Authorization: `Bearer ${token}` } : {},\n  };\n}\n", "import type { z } from \"zod\";\nimport {\n  MessageNotFoundError,\n  SandboxNotFoundError,\n  SessionNotFoundError,\n  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  ResolvedStorage,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport function getStorageClient({ url, headers }: ResolvedStorage): Storage {\n  async function rpc<M extends keyof StorageMethods>(\n    method: M,\n    params: z.infer<StorageMethods[M][\"params\"]>\n  ): Promise<z.infer<StorageMethods[M][\"result\"]>> {\n    const res = await fetch(url, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\", ...headers },\n      body: JSON.stringify({ method, params }),\n    });\n\n    if (!res.ok) {\n      throw new StorageError({\n        reason: `HTTP ${res.status}: ${res.statusText}`,\n      });\n    }\n\n    const json = (await res.json()) as RpcResponse<\n      z.infer<StorageMethods[M][\"result\"]>\n    >;\n\n    if (\"error\" in json) {\n      throw new StorageError({ reason: json.error.message });\n    }\n\n    return json.result;\n  }\n\n  return {\n    session: {\n      get: async (id) => {\n        try {\n          const result = await rpc(\"session.get\", { id });\n          if (result === null) {\n            return new SessionNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (session) => {\n        try {\n          return await rpc(\"session.set\", session);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"session.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sessionId, tags }) => {\n          try {\n            return await rpc(\"session.tag.set\", { sessionId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    message: {\n      list: async (sessionId, opts) => {\n        try {\n          return await rpc(\"message.list\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      get: async (id) => {\n        try {\n          const result = await rpc(\"message.get\", { id });\n          if (result === null) {\n            return new MessageNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (message) => {\n        try {\n          return await rpc(\"message.set\", message);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    part: {\n      listByMessage: async (messageId, opts) => {\n        try {\n          const result = await rpc(\"part.listByMessage\", {\n            messageId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySession: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"part.listBySession\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (part) => {\n        try {\n          return (await rpc(\"part.set\", part)) as Part;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    sandbox: {\n      get: async (key) => {\n        try {\n          const result = await rpc(\"sandbox.get\", { key });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: key });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      getBySession: async (sessionId) => {\n        try {\n          const result = await rpc(\"sandbox.getBySession\", { sessionId });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: sessionId });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (record) => {\n        try {\n          await rpc(\"sandbox.set\", record);\n          return record;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"sandbox.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sandboxId, tags }) => {\n          try {\n            return await rpc(\"sandbox.tag.set\", { sandboxId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    command: {\n      get: async (id) => {\n        try {\n          return (await rpc(\"command.get\", { id })) as Command | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (command) => {\n        try {\n          return (await rpc(\"command.set\", command)) as Command;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"command.list\", {\n            sessionId,\n            includeFinished: opts?.includeFinished,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Command>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n  };\n}\n\nasync function resolveStorageUrl(\n  config: StorageConfig\n): Promise<ResolvedStorage> {\n  switch (config.type) {\n    case \"local\": {\n      const { startLocalStorage } = await import(\"./bindings/local\");\n      return { url: await startLocalStorage({ path: config.path }) };\n    }\n    case \"vercel\": {\n      const { getVercelStorageConfig } = await import(\"./bindings/vercel\");\n      return getVercelStorageConfig();\n    }\n    case \"custom\": {\n      return { url: config.url, headers: config.headers };\n    }\n    default: {\n      config satisfies never;\n      throw new Error(\n        `Unknown storage type: ${(config as { type: string }).type}`\n      );\n    }\n  }\n}\n\nexport function getStorage(storageConfig: StorageConfig): Storage {\n  let clientPromise: Promise<Storage> | null = null;\n  const getClient = () => {\n    if (!clientPromise) {\n      clientPromise = resolveStorageUrl(storageConfig).then((resolved) =>\n        getStorageClient(resolved)\n      );\n    }\n    return clientPromise;\n  };\n\n  return {\n    session: {\n      get: async (id) => (await getClient()).session.get(id),\n      set: async (session) => (await getClient()).session.set(session),\n      list: async (opts) => (await getClient()).session.list(opts),\n      tag: {\n        set: async (opts) => (await getClient()).session.tag.set(opts),\n      },\n    },\n    message: {\n      list: async (sessionId, opts) =>\n        (await getClient()).message.list(sessionId, opts),\n      get: async (id) => (await getClient()).message.get(id),\n      set: async (message) => (await getClient()).message.set(message),\n    },\n    part: {\n      listByMessage: async (messageId, opts) =>\n        (await getClient()).part.listByMessage(messageId, opts),\n      listBySession: async (sessionId, opts) =>\n        (await getClient()).part.listBySession(sessionId, opts),\n      set: async (part) => (await getClient()).part.set(part),\n    },\n    sandbox: {\n      get: async (key) => (await getClient()).sandbox.get(key),\n      set: async (opts) => (await getClient()).sandbox.set(opts),\n      getBySession: async (sessionId) =>\n        (await getClient()).sandbox.getBySession(sessionId),\n      list: async (opts) => (await getClient()).sandbox.list(opts),\n      tag: {\n        set: async (opts) => (await getClient()).sandbox.tag.set(opts),\n      },\n    },\n    command: {\n      get: async (id) => (await getClient()).command.get(id),\n      set: async (command) => (await getClient()).command.set(command),\n      list: async (sessionId, opts) =>\n        (await getClient()).command.list(sessionId, opts),\n    },\n  };\n}\n", "import { z } from \"zod\";\n\nconst VercelLifecycleConfigSchema = z.object({\n  stopAfterInactiveMs: z.number().optional(),\n  snapshotBeforeTimeoutMs: z.number().optional(),\n  snapshotId: z.string().optional(),\n  autoStart: z.boolean().optional(),\n});\n\nexport const SandboxConfigSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"vercel\"),\n    resources: z.object({ vcpus: z.number() }).optional(),\n    ports: z.array(z.number()).optional(),\n    lifecycle: VercelLifecycleConfigSchema.optional(),\n  }),\n  z.object({\n    type: z.literal(\"local\"),\n    path: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"custom\"),\n    url: z.string(),\n    headers: z.record(z.string(), z.string()).optional(),\n  }),\n]);\n\nexport type SandboxConfig = z.infer<typeof SandboxConfigSchema>;\n\nexport const SessionSchema = z.object({\n  id: z.string(),\n  createdAt: z.number(),\n  updatedAt: z.number(),\n  runId: z.string().nullable(),\n  lastMessageId: z.string().nullable(),\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  instructions: z.string().nullable(),\n  model: z.string().nullable(),\n  mcp: z.unknown().nullable(), // TODO\n  sandboxId: z.string().nullable(),\n  skillsDir: z.array(z.string()).nullable(),\n  hookToken: z.string().nullable(),\n});\n\nexport const MessageSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  role: z.enum([\"user\", \"assistant\", \"system\"]),\n  createdAt: z.number(),\n  completedAt: z.number().nullable(),\n  interruptedAt: z.number().nullable(),\n  mcpContext: z.unknown().nullable(),\n});\n\n/**\n * The `part` field corresponds to `UIMessage[\"parts\"][number]` from the `ai` package.\n * We use `z.unknown()` because the exact shape varies by part type (text, tool-call,\n * tool-result, etc.) and may evolve with the AI SDK. The RPC layer just passes it through.\n */\nexport const PartSchema = z.object({\n  id: z.string(),\n  messageId: z.string(),\n  sessionId: z.string(),\n  index: z.number(),\n  part: z.unknown(),\n});\n\nexport const CommandResultSchema = z.object({\n  stdout: z.string(),\n  stderr: z.string(),\n  exitCode: z.number(),\n  completedAt: z.number(),\n});\n\nexport const SandboxRecordSchema = z.object({\n  id: z.string(),\n  config: SandboxConfigSchema,\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  createdAt: z.number().nullable(),\n  lastActivityAt: z.number().nullable(),\n  acquiringLockId: z.string().nullable(),\n  acquiringLockAt: z.number().nullable(),\n  providerMetadata: z\n    .discriminatedUnion(\"provider\", [\n      z.object({\n        provider: z.literal(\"vercel\"),\n        sandboxId: z.string().nullable(),\n        snapshotId: z.string().nullable(),\n      }),\n    ])\n    .optional(),\n});\n\nconst CommandBaseSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  command: z.string(),\n  args: z.array(z.string()).optional(),\n  startedAt: z.number(),\n});\n\nexport const CommandSchema = z.discriminatedUnion(\"status\", [\n  CommandBaseSchema.extend({ status: z.literal(\"running\") }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"completed\"),\n    result: CommandResultSchema,\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"killed\"),\n    result: CommandResultSchema.optional(),\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"failed\"),\n    result: CommandResultSchema,\n  }),\n]);\n\nfunction ListResultSchema<T extends z.ZodTypeAny>(itemSchema: T) {\n  return z.object({\n    items: z.array(itemSchema),\n    nextCursor: z.string().nullable(),\n  });\n}\n\nexport const methods = {\n  \"session.get\": {\n    params: z.object({ id: z.string() }),\n    result: SessionSchema.nullable(),\n  },\n  \"session.set\": {\n    params: SessionSchema,\n    result: SessionSchema,\n  },\n  \"session.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.listBySandbox\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.tag.set\": {\n    params: z.object({\n      sessionId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SessionSchema,\n  },\n  \"message.get\": {\n    params: z.object({ id: z.string() }),\n    result: MessageSchema.nullable(),\n  },\n  \"message.set\": {\n    params: MessageSchema,\n    result: MessageSchema,\n  },\n  \"message.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(MessageSchema),\n  },\n  \"part.listByMessage\": {\n    params: z.object({\n      messageId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.listBySession\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.set\": {\n    params: PartSchema,\n    result: PartSchema,\n  },\n  \"sandbox.get\": {\n    params: z.object({ key: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.getBySession\": {\n    params: z.object({ sessionId: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.set\": {\n    params: SandboxRecordSchema,\n    result: z.void(),\n  },\n  \"sandbox.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"lastActivityAt_asc\",\n          \"lastActivityAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SandboxRecordSchema),\n  },\n  \"sandbox.tag.set\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SandboxRecordSchema,\n  },\n  \"command.get\": {\n    params: z.object({ id: z.string() }),\n    result: CommandSchema.nullable(),\n  },\n  \"command.set\": {\n    params: CommandSchema,\n    result: CommandSchema,\n  },\n  \"command.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      includeFinished: z.boolean().optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(CommandSchema),\n  },\n} as const;\n\nexport type StorageMethods = typeof methods;\nexport type MethodName = keyof StorageMethods;\n", "import type { z } from \"zod\";\nimport { type MethodName, methods, type StorageMethods } from \"./rpc\";\n\nexport type Handlers = {\n  [K in MethodName]: (\n    params: z.infer<StorageMethods[K][\"params\"]>\n  ) => Promise<z.infer<StorageMethods[K][\"result\"]>>;\n};\n\nexport type RpcRequest = {\n  method: string;\n  params: unknown;\n};\n\nexport type RpcSuccessResponse<T = unknown> = {\n  result: T;\n};\n\nexport type RpcErrorResponse = {\n  error: { code: string; message: string };\n};\n\nexport type RpcResponse<T = unknown> = RpcSuccessResponse<T> | RpcErrorResponse;\n\nexport async function handleStorageRpc(\n  body: RpcRequest,\n  handlers: Handlers\n): Promise<RpcResponse> {\n  const { method, params } = body;\n\n  if (!(method in methods)) {\n    return {\n      error: { code: \"METHOD_NOT_FOUND\", message: `Unknown method: ${method}` },\n    };\n  }\n\n  const methodName = method as MethodName;\n  const schema = methods[methodName].params;\n  const parsed = schema.safeParse(params);\n\n  if (!parsed.success) {\n    return {\n      error: {\n        code: \"INVALID_PARAMS\",\n        message: parsed.error.issues\n          .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n          .join(\", \"),\n      },\n    };\n  }\n\n  try {\n    const handler = handlers[methodName] as (\n      params: unknown\n    ) => Promise<unknown>;\n    const result = await handler(parsed.data);\n    return { result };\n  } catch (e) {\n    return {\n      error: {\n        code: \"INTERNAL_ERROR\",\n        message: e instanceof Error ? e.message : String(e),\n      },\n    };\n  }\n}\n", "export { getStorage } from \"./client\";\nexport {\n  type Handlers,\n  handleStorageRpc,\n  type RpcErrorResponse,\n  type RpcRequest,\n  type RpcResponse,\n  type RpcSuccessResponse,\n} from \"./handler\";\nexport {\n  CommandResultSchema,\n  CommandSchema,\n  MessageSchema,\n  type MethodName,\n  methods,\n  PartSchema,\n  type SandboxConfig,\n  SandboxConfigSchema,\n  SandboxRecordSchema,\n  SessionSchema,\n  type StorageMethods,\n} from \"./rpc\";\nexport type {\n  Command,\n  ListResult,\n  Message,\n  Part,\n  ResolvedStorage,\n  SandboxRecord,\n  Session,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n", "import * as path from \"node:path\";\nimport type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\n\n/**\n * Writes files to a sandbox at the specified destination path.\n * Shell scripts (.sh files) are automatically made executable.\n *\n * For small files (<100KB total), uses single exec with heredoc.\n * For large files, writes base64 chunks then decodes to avoid ARG_MAX limits.\n */\nexport async function writeFiles(opts: {\n  sandbox: Pick<Sandbox, \"exec\">;\n  files: UploadableFile[];\n  destPath: string;\n}): Promise<void> {\n  const { sandbox, files, destPath } = opts;\n\n  if (files.length === 0) {\n    return;\n  }\n\n  const filePaths = files.map((file) =>\n    path.posix.join(destPath, file.path)\n  );\n  const parentDirs = Array.from(\n    new Set(filePaths.map((p) => path.posix.dirname(p)))\n  );\n  const shellScripts = filePaths.filter((p) => p.endsWith(\".sh\"));\n\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", ...parentDirs],\n  });\n  if (mkdirResult instanceof Error) {\n    throw mkdirResult;\n  }\n  await mkdirResult.result;\n\n  const CHUNK_SIZE = 50_000;\n\n  for (let i = 0; i < files.length; i++) {\n    const file = files[i];\n    const fullPath = filePaths[i];\n    const base64Content = toBase64(file.content);\n\n    if (base64Content.length < CHUNK_SIZE) {\n      const marker = `EOF_${i}`;\n      const execResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n        ],\n      });\n\n      if (execResult instanceof Error) {\n        throw execResult;\n      }\n\n      const { exitCode, stderr } = await execResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles failed with exit code ${exitCode}: ${stderr}`\n        );\n      }\n    } else {\n      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;\n\n      const clearResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\"-c\", `> ${quote(tempB64)}`],\n      });\n      if (clearResult instanceof Error) {\n        throw clearResult;\n      }\n      await clearResult.result;\n\n      for (\n        let offset = 0;\n        offset < base64Content.length;\n        offset += CHUNK_SIZE\n      ) {\n        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);\n        const marker = `CHUNK_${offset}`;\n        const appendResult = await sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n          ],\n        });\n\n        if (appendResult instanceof Error) {\n          throw appendResult;\n        }\n\n        const { exitCode, stderr } = await appendResult.result;\n        if (exitCode !== 0) {\n          throw new Error(\n            `writeFiles chunk failed with exit code ${exitCode}: ${stderr}`\n          );\n        }\n      }\n\n      const decodeResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n        ],\n      });\n\n      if (decodeResult instanceof Error) {\n        throw decodeResult;\n      }\n\n      const { exitCode, stderr } = await decodeResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles decode failed with exit code ${exitCode}: ${stderr}`\n        );\n      }\n    }\n  }\n\n  if (shellScripts.length > 0) {\n    const chmodResult = await sandbox.exec({\n      command: \"chmod\",\n      args: [\"+x\", ...shellScripts],\n    });\n    if (chmodResult instanceof Error) {\n      throw chmodResult;\n    }\n    await chmodResult.result;\n  }\n}\n\nfunction toBase64(content: string | Buffer): string {\n  if (typeof content === \"string\") {\n    return Buffer.from(content).toString(\"base64\");\n  }\n  return content.toString(\"base64\");\n}\n\nfunction quote(s: string): string {\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`;\n}\n", "import type { ChildProcess } from \"node:child_process\";\nimport { spawn } from \"node:child_process\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport {\n  getStorage,\n  type SandboxRecord,\n  type StorageConfig,\n} from \"../../storage\";\nimport type { LogEntry, Sandbox } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport const localSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"local\" } };\n  storageConfig: StorageConfig;\n}): Sandbox<TTags> => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n  const storage = getStorage(storageConfig);\n\n  const sandbox: Sandbox<TTags> = {\n    id: sandboxRecord.id,\n    config: sandboxRecord.config,\n    exec: ({ command, args, signal }) => {\n      return errore.tryAsync({\n        try: () => {\n          const commandId = `command_${ulid()}`;\n\n          const child = spawn(command, args, {\n            cwd: basePath,\n            signal,\n          });\n\n          processes.set(commandId, child);\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logQueue: LogEntry[] = [];\n          let logResolve: (() => void) | null = null;\n          let closed = false;\n\n          child.stdout.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stdout += str;\n            logQueue.push({ stream: \"stdout\", data: str });\n            logResolve?.();\n          });\n\n          child.stderr.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stderr += str;\n            logQueue.push({ stream: \"stderr\", data: str });\n            logResolve?.();\n          });\n\n          const result = new Promise<{\n            stdout: string;\n            stderr: string;\n            exitCode: number;\n          }>((resolve, reject) => {\n            child.on(\"error\", (err) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              reject(err);\n            });\n\n            child.on(\"close\", (code: number | null) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              resolve({ stdout, stderr, exitCode: code ?? 0 });\n            });\n          });\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            while (!closed || logQueue.length > 0) {\n              const entry = logQueue.shift();\n              if (entry) {\n                yield entry;\n              } else if (!closed) {\n                await new Promise<void>((resolve) => {\n                  logResolve = resolve;\n                });\n                logResolve = null;\n              }\n            }\n          }\n\n          return Promise.resolve({ commandId, logs, result });\n        },\n        catch: (e: unknown) =>\n          new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getDomain: (port) => {\n      return Promise.resolve(`http://localhost:${port}`);\n    },\n\n    kill: async ({ commandId, storage }) => {\n      const child = processes.get(commandId);\n      if (!child) {\n        return new SandboxError({\n          reason: `Command ${commandId} not found or already finished`,\n        });\n      }\n\n      child.kill(\"SIGTERM\");\n\n      const cmd = await storage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await storage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  return sandbox;\n};\n", "import * as errore from \"errore\";\nimport { Sandbox as VercelSandboxSDK } from \"sandbox\";\nimport { SandboxError, SandboxNotFoundError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport {\n  getStorage,\n  type SandboxRecord,\n  type Storage,\n  type StorageConfig,\n} from \"../../storage\";\nimport type {\n  LogEntry,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxStatus,\n} from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport type VercelSandboxCreateOptions = Extract<\n  Parameters<typeof VercelSandboxSDK.create>[0],\n  // biome-ignore lint/complexity/noBannedTypes: .\n  {}\n>;\n\nexport const VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1000; // 5 hours\nconst LOCK_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes - if lock older than this, consider it stale\nconst LOCK_POLL_INTERVAL_MS = 200;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\n/**\n * Module-level cache for in-flight sandbox creation promises.\n * Prevents parallel requests within the same process from creating duplicate sandboxes.\n */\nconst createPromises = new Map<string, Promise<SandboxError | string>>();\n\nconst ACTIVITY_THROTTLE_MS = 10_000;\nconst lastActivitySent = new Map<string, number>();\n\nconst DEFAULT_VCPUS = 2;\n\nexport const vercelSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  enableLifecycleWorkflow = true,\n  storage: storageOverride,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"vercel\" } };\n  storageConfig: StorageConfig;\n  enableLifecycleWorkflow?: boolean;\n  storage?: Storage;\n}): Sandbox<TTags> => {\n  const { id, config } = sandboxRecord;\n  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;\n  const ports = config.ports;\n  const storage = storageOverride ?? getStorage(storageConfig);\n  const initialVercel =\n    sandboxRecord.providerMetadata?.provider === \"vercel\"\n      ? sandboxRecord.providerMetadata\n      : null;\n\n  type SandboxInstance = Awaited<ReturnType<typeof VercelSandboxSDK.get>>;\n  let sandboxPromise: Promise<SandboxError | SandboxInstance> | null = null;\n  const HOME_DIR = \"/home/vercel-sandbox\";\n\n  async function pollForSandboxId(): Promise<SandboxError | string> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.sandbox.get(id);\n      if (record instanceof Error) {\n        return new SandboxError({ reason: record.message, cause: record });\n      }\n      const vercelSandboxId =\n        record?.providerMetadata?.provider === \"vercel\"\n          ? record.providerMetadata.sandboxId\n          : null;\n      if (vercelSandboxId) {\n        return vercelSandboxId;\n      }\n      if (!record?.acquiringLockAt) {\n        const finalCheck = await storage.sandbox.get(id);\n        if (finalCheck instanceof Error) {\n          return new SandboxError({\n            reason: finalCheck.message,\n            cause: finalCheck,\n          });\n        }\n        const finalVercelSandboxId =\n          finalCheck?.providerMetadata?.provider === \"vercel\"\n            ? finalCheck.providerMetadata.sandboxId\n            : null;\n        if (finalVercelSandboxId) {\n          return finalVercelSandboxId;\n        }\n        return doGetOrCreateSandboxId();\n      }\n    }\n    return new SandboxError({\n      reason: \"Timed out waiting for sandbox creation by another process\",\n    });\n  }\n\n  async function createSandboxFromSnapshot(\n    snapshotId: string\n  ): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          source: { type: \"snapshot\", snapshotId },\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId,\n          },\n        });\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function createFreshSandbox(): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId: null,\n          },\n        });\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function doGetOrCreateSandboxId(): Promise<SandboxError | string> {\n    if (initialVercel?.sandboxId) {\n      return initialVercel.sandboxId;\n    }\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error) {\n      if (existing instanceof SandboxNotFoundError) {\n        // Sandbox doesn't exist yet, continue with creation\n      } else {\n        return new SandboxError({ reason: existing.message, cause: existing });\n      }\n    }\n\n    const existingRecord =\n      existing instanceof SandboxNotFoundError ? null : existing;\n    const existingVercel =\n      existingRecord?.providerMetadata?.provider === \"vercel\"\n        ? existingRecord.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      return existingVercel.sandboxId;\n    }\n\n    const hasActiveLock =\n      existingRecord?.acquiringLockId &&\n      existingRecord.acquiringLockAt &&\n      Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;\n\n    if (hasActiveLock) {\n      return pollForSandboxId();\n    }\n\n    const lockId = crypto.randomUUID();\n    const now = Date.now();\n    await storage.sandbox.set({\n      id,\n      config,\n      tags: existingRecord?.tags ?? sandboxRecord.tags,\n      createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,\n      lastActivityAt:\n        existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,\n      acquiringLockId: lockId,\n      acquiringLockAt: now,\n      providerMetadata: {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId:\n          existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null,\n      },\n    });\n\n    const afterLock = await storage.sandbox.get(id);\n    if (afterLock instanceof Error) {\n      return new SandboxError({ reason: afterLock.message, cause: afterLock });\n    }\n    if (afterLock?.acquiringLockId !== lockId) {\n      return pollForSandboxId();\n    }\n\n    const snapshotId =\n      existingVercel?.snapshotId ??\n      initialVercel?.snapshotId ??\n      config.lifecycle?.snapshotId;\n    if (snapshotId) {\n      const result = await createSandboxFromSnapshot(snapshotId);\n      if (!(result instanceof Error)) {\n        return result;\n      }\n    }\n\n    return createFreshSandbox();\n  }\n\n  function getOrCreateSandboxId(): Promise<SandboxError | string> {\n    const cached = createPromises.get(id);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = doGetOrCreateSandboxId().finally(() => {\n      createPromises.delete(id);\n    });\n    createPromises.set(id, promise);\n    return promise;\n  }\n\n  async function doGetSandbox(): Promise<SandboxError | SandboxInstance> {\n    const vercelSandboxId = await getOrCreateSandboxId();\n    if (vercelSandboxId instanceof Error) {\n      return vercelSandboxId;\n    }\n\n    return errore.tryAsync({\n      try: () =>\n        VercelSandboxSDK.get({\n          sandboxId: vercelSandboxId,\n          ...getTestCredentials(),\n        }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function getSandbox(): Promise<SandboxError | SandboxInstance> {\n    if (!sandboxPromise) {\n      sandboxPromise = doGetSandbox();\n    }\n    return sandboxPromise;\n  }\n\n  async function updateLastActivity(): Promise<void> {\n    const now = Date.now();\n    const lastSent = lastActivitySent.get(id);\n    if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {\n      return;\n    }\n    lastActivitySent.set(id, now);\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n    await storage.sandbox.set({\n      id: existing.id,\n      config: existing.config,\n      tags: existing.tags,\n      createdAt: existing.createdAt,\n      lastActivityAt: now,\n      acquiringLockId: null,\n      acquiringLockAt: null,\n      providerMetadata: existingVercel ?? {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId: null,\n      },\n    });\n\n    if (enableLifecycleWorkflow) {\n      // todo re-enable once we figure out why workflow throws a bunch of errors in dev\n      // const lifecycleInput: SandboxLifecycleInput = {\n      //   id,\n      //   storageConfig,\n      //   initialConfig: config,\n      // };\n      // try {\n      //   await sandboxActivityHook.resume(id, {\n      //     type: \"activity\",\n      //     newConfig: config,\n      //   });\n      // } catch {\n      //   await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]);\n      // }\n    }\n  }\n\n  const lifecycle: SandboxLifecycle = {\n    start: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      await updateLastActivity();\n      return sandbox.status as SandboxStatus;\n    },\n\n    snapshot: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          const existing = await storage.sandbox.get(id);\n          const snapshot = await sandbox.snapshot();\n          await storage.sandbox.set({\n            id,\n            config,\n            tags: existing instanceof Error ? null : (existing?.tags ?? null),\n            createdAt:\n              existing instanceof Error ? null : (existing?.createdAt ?? null),\n            lastActivityAt:\n              existing instanceof Error\n                ? null\n                : (existing?.lastActivityAt ?? null),\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: snapshot.snapshotId,\n            },\n          });\n          return { snapshotId: snapshot.snapshotId };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    stop: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          await sandbox.stop();\n          const existing = await storage.sandbox.get(id);\n          if (existing instanceof Error || !existing) {\n            return undefined;\n          }\n          await storage.sandbox.set({\n            id: existing.id,\n            config: existing.config,\n            tags: existing.tags,\n            createdAt: existing.createdAt,\n            lastActivityAt: existing.lastActivityAt,\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: null,\n            },\n          });\n          return undefined;\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getStatus: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.status as SandboxStatus;\n    },\n\n    getCreatedAt: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.createdAt;\n    },\n\n    getRemainingTimeout: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.timeout;\n    },\n  };\n\n  const sandbox: Sandbox<TTags> = {\n    id,\n    config,\n    exec: async ({ command, args, signal }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const updatePromise = updateLastActivity();\n\n      const execResult = await errore.tryAsync({\n        try: async () => {\n          const output = await instance.runCommand({\n            cwd: HOME_DIR,\n            args,\n            cmd: command,\n            signal,\n          });\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logBuffer: LogEntry[] = [];\n          const state = {\n            resolve: null as (() => void) | null,\n            consumed: false,\n          };\n\n          const consumeLogs = (async () => {\n            for await (const log of output.logs()) {\n              const entry: LogEntry =\n                log.stream === \"stdout\"\n                  ? { stream: \"stdout\", data: log.data }\n                  : { stream: \"stderr\", data: log.data };\n\n              if (log.stream === \"stdout\") {\n                stdout += log.data;\n              } else {\n                stderr += log.data;\n              }\n\n              logBuffer.push(entry);\n              state.resolve?.();\n            }\n            state.consumed = true;\n            state.resolve?.();\n          })();\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            let index = 0;\n            while (!state.consumed || index < logBuffer.length) {\n              if (index < logBuffer.length) {\n                yield logBuffer[index++];\n              } else {\n                await new Promise<void>((resolve) => {\n                  state.resolve = resolve;\n                });\n                state.resolve = null;\n              }\n            }\n          }\n\n          const result = consumeLogs.then(() => ({\n            stdout,\n            stderr,\n            exitCode: output.exitCode,\n          }));\n\n          return { commandId: output.cmdId, logs, result };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n\n      await updatePromise;\n      return execResult;\n    },\n\n    getDomain: async (port) => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      try {\n        return sandbox.domain(port);\n      } catch (e) {\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    kill: async ({ commandId, storage: cmdStorage }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const cmd = await cmdStorage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await cmdStorage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n      return undefined;\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    lifecycle,\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n  }\n\n  return sandbox;\n};\n", "import type { TagsSchema } from \"../index\";\nimport type { SandboxRecord, StorageConfig } from \"../storage\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { Sandbox } from \"./types\";\n\nexport function getSandbox<TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n}): Sandbox<TTags> {\n  const { config } = sandboxRecord;\n  switch (config.type) {\n    case \"local\":\n      return localSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storageConfig,\n      });\n    case \"vercel\":\n      return vercelSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"vercel\" };\n        },\n        storageConfig,\n      });\n    case \"custom\":\n      throw new Error(\"Custom sandboxes are not supported\");\n    default:\n      config satisfies never;\n      throw new Error(\n        `Unknown sandbox type: ${\n          // biome-ignore lint/suspicious/noExplicitAny: .\n          (config as any).type\n        }`\n      );\n  }\n}\n", "export { getSandbox } from \"./client\";\nexport type {\n  ExecResult,\n  LogEntry,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxLifecycleInput,\n  SandboxStatus,\n  Terminal,\n  TerminalMetadata,\n  VercelSandboxLifecycleConfig,\n} from \"./types\";\n", "import type { FinishReason } from \"ai\";\nimport { defineHook, FatalError, getWritable } from \"workflow\";\nimport { completeMessageStep, streamTextStep } from \"./agent-workflow-steps\";\nimport type { StorageConfig } from \"./storage\";\n\nexport type AgentInput = {\n  sessionId: string;\n  storageConfig: StorageConfig;\n};\n\nexport type AgentMessageInput = {\n  assistantMessageId: string;\n  hookToken: string;\n};\n\nexport const agentMessageHook = defineHook<AgentMessageInput>();\n\nexport async function agentWorkflow({\n  input,\n  event,\n}: {\n  input: AgentInput;\n  event: AgentMessageInput;\n}) {\n  \"use workflow\";\n\n  const messageHook = agentMessageHook.create({ token: input.sessionId });\n  const iterator = messageHook[Symbol.asyncIterator]();\n  let pendingNext = iterator.next();\n\n  await onMessage({ event, input }).catch((e) => {\n    if (FatalError.is(e)) {\n      console.error(\"Message processing failed permanently:\", e.message);\n      return;\n    }\n    throw e;\n  });\n\n  while (true) {\n    const result = await pendingNext;\n\n    if (result.done) {\n      console.error(\"Unexpected: message hook iterator done\");\n      break;\n    }\n\n    await onMessage({ event: result.value, input }).catch((e) => {\n      if (FatalError.is(e)) {\n        console.error(\"Message processing failed permanently:\", e.message);\n        return;\n      }\n      throw e;\n    });\n    pendingNext = iterator.next();\n  }\n}\n\nasync function onMessage({\n  event,\n  input,\n}: {\n  event: AgentMessageInput;\n  input: AgentInput;\n}) {\n  const writable = getWritable({ namespace: event.assistantMessageId });\n\n  let finishReason: FinishReason | undefined;\n  let lastPartIndex = 0;\n\n  while (finishReason !== \"stop\") {\n    try {\n      const result = await streamTextStep({\n        assistantMessageId: event.assistantMessageId,\n        writable,\n        input,\n        event,\n        lastPartIndex,\n      });\n      finishReason = result.finishReason;\n      lastPartIndex = result.lastPartIndex;\n    } catch (err) {\n      console.error(err);\n      throw err;\n    }\n  }\n\n  await completeMessageStep({\n    assistantMessageId: event.assistantMessageId,\n    input,\n    writable,\n  });\n}\n", "import {\n  convertToModelMessages,\n  type FinishReason,\n  streamText,\n  type UIMessage,\n} from \"ai\";\nimport { ulid } from \"ulid\";\nimport { FatalError } from \"workflow\";\nimport type { McpServerSchema } from \"./mcp\";\nimport { discoverSkillsInSandbox } from \"./skills/discover\";\nimport type { SkillSummary } from \"./skills/types\";\nimport type { Storage, StorageConfig } from \"./storage\";\nimport { getTools } from \"./tools\";\nimport { assembleUIMessages } from \"./utils/ui\";\n\nconst BASE_SYSTEM_PROMPT =\n  \"You are an AI assistant with basic tools to interact with your environment. Explore and work freely.\";\n\nfunction joinPromptSections(\n  ...sections: (string | undefined | null)[]\n): string {\n  return sections.filter((s) => s?.trim()).join(\"\\n\\n\");\n}\n\nconst backgroundProcessPrompt = `## Background Processes\nThese background process instructions are for you to manipulate the processes, do not be to verbose to the user about the response details like \"how to debug the process output\" the user will have an UI.\n\nUse \\`waitUntil: 0\\` for dev servers that should run indefinitely.\nIt is a good practice to check the output log after running processes like dev servers to make sure they started correctly.\n\nTo run a background process:\nBash({ command: \"npm run dev\", waitUntil: 0 })\nReturns immediately with \\`pid\\` and \\`outputFile\\` path.\n\nTo check a process's output:\nBash({ command: \"tail -100 {outputFile}\" })\n\nTo kill a process:\nBash({ command: \"kill {pid}\" })       // Graceful\nBash({ command: \"kill -9 {pid}\" })    // Force\n\nTo list all processes:\nBash({ command: \"ps aux | grep node\" })\n`;\n\nfunction buildSkillsContext(skills: SkillSummary[]): string {\n  if (skills.length === 0) {\n    return \"\";\n  }\n\n  const skillLines = skills\n    .map((s) => `- ${s.name}: ${s.description}\\n  Path: ${s.skillMdPath}`)\n    .join(\"\\n\");\n\n  return `## Available Skills\n${skillLines}\n\n${backgroundProcessPrompt}\n\nYou can use the Read tool to read any skill's SKILL.md file to learn more about it.`;\n}\n\nfunction buildMcpToolsContext(\n  mcp: McpServerSchema[] | null | undefined\n): string {\n  if (!mcp || mcp.length === 0) {\n    return \"\";\n  }\n\n  const serverDocs = mcp\n    .filter(\n      (\n        s\n      ): s is McpServerSchema & {\n        tools: NonNullable<McpServerSchema[\"tools\"]>;\n      } => Array.isArray(s.tools) && s.tools.length > 0\n    )\n    .map((server) => {\n      const toolDocs = server.tools\n        .map((t) => {\n          let doc = `  - ${t.name}: ${\n            t.description\n          }\\n    Input: ${JSON.stringify(t.inputSchema)}`;\n          if (t.outputSchema) {\n            doc += `\\n    Output: ${JSON.stringify(t.outputSchema)}`;\n          }\n          return doc;\n        })\n        .join(\"\\n\");\n      return `### ${server.name}\\n${server.description ?? \"\"}\\n${toolDocs}`;\n    })\n    .join(\"\\n\\n\");\n\n  if (!serverDocs) {\n    return \"\";\n  }\n\n  return `## MCP Tools\nUse the ExecuteMCPTool to call these custom tools:\n\n${serverDocs}`;\n}\n\nexport type AgentInput = {\n  sessionId: string;\n  storageConfig: StorageConfig;\n};\n\nexport type AgentMessageInput = {\n  assistantMessageId: string;\n  hookToken: string;\n};\n\nexport async function completeMessageStep({\n  assistantMessageId,\n  input,\n  writable,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  writable: WritableStream;\n}) {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage\");\n  const storage = getStorage(input.storageConfig);\n\n  const message = await storage.message.get(assistantMessageId);\n  if (message instanceof Error) {\n    throw message;\n  }\n  if (!message) {\n    throw new Error(`Message ${assistantMessageId} not found`);\n  }\n\n  const result = await storage.message.set({\n    ...message,\n    completedAt: Date.now(),\n  });\n  if (result instanceof Error) {\n    throw result;\n  }\n\n  await writable.close();\n}\n\nconst INTERRUPT_POLL_INTERVAL_MS = 500;\n\nasync function pollForInterrupt({\n  storage,\n  messageId,\n  signal,\n  abortController,\n}: {\n  storage: Storage;\n  messageId: string;\n  signal: AbortSignal;\n  abortController: AbortController;\n}): Promise<void> {\n  while (!signal.aborted) {\n    const message = await storage.message.get(messageId);\n    if (message instanceof Error) {\n      return;\n    }\n    if (message.interruptedAt !== null) {\n      abortController.abort();\n      return;\n    }\n    await new Promise((resolve) =>\n      setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)\n    );\n  }\n}\n\nexport async function streamTextStep({\n  assistantMessageId,\n  input,\n  event,\n  writable,\n  lastPartIndex,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  event: AgentMessageInput;\n  writable: WritableStream;\n  lastPartIndex: number;\n}): Promise<{ finishReason: FinishReason; lastPartIndex: number }> {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const { getSandbox } = await import(\"./sandbox\");\n\n  const storage = getStorage(input.storageConfig);\n  const session = await storage.session.get(input.sessionId);\n\n  if (session instanceof Error) {\n    throw session;\n  }\n  session;\n\n  const sandboxRecord = session.sandboxId\n    ? await storage.sandbox.get(session.sandboxId)\n    : null;\n  if (sandboxRecord instanceof Error) {\n    throw sandboxRecord;\n  }\n  if (!sandboxRecord) {\n    throw new FatalError(`Sandbox not found for session ${input.sessionId}`);\n  }\n\n  const sandbox = getSandbox({\n    sandboxRecord,\n    storageConfig: input.storageConfig,\n  });\n\n  const abortController = new AbortController();\n  const pollController = new AbortController();\n\n  const _pollPromise = pollForInterrupt({\n    storage,\n    messageId: assistantMessageId,\n    signal: pollController.signal,\n    abortController,\n  });\n\n  const [messagesResult, partsResult, skills] = await Promise.all([\n    storage.message.list(input.sessionId),\n    storage.part.listBySession(input.sessionId),\n    discoverSkillsInSandbox({\n      sandbox,\n      skillsDirs: session.skillsDir || [],\n      debug: true,\n    }),\n  ]);\n\n  if (abortController.signal.aborted) {\n    pollController.abort();\n    return { finishReason: \"stop\" as FinishReason, lastPartIndex };\n  }\n\n  if (messagesResult instanceof Error) {\n    throw messagesResult;\n  }\n  if (partsResult instanceof Error) {\n    throw partsResult;\n  }\n\n  console.log(\"[agent] Discovered skills:\", {\n    count: skills.length,\n    skills: skills.map((s) => ({\n      name: s.name,\n      description: s.description,\n      path: s.skillMdPath,\n    })),\n    skillsDirs: session.skillsDir,\n  });\n\n  const uiMessages = assembleUIMessages({\n    messages: messagesResult.items,\n    parts: partsResult.items,\n  });\n\n  const mcp = session.mcp as McpServerSchema[] | null;\n\n  const skillsContext = buildSkillsContext(skills);\n  console.log(\"[agent] Skills context added to system prompt:\", {\n    hasSkills: skills.length > 0,\n    contextLength: skillsContext.length,\n    contextPreview: skillsContext.slice(0, 200),\n  });\n\n  const systemPrompt = joinPromptSections(\n    BASE_SYSTEM_PROMPT,\n    session.instructions,\n    skillsContext,\n    buildMcpToolsContext(mcp)\n  );\n\n  console.log(\"[agent] System prompt built:\", {\n    totalLength: systemPrompt.length,\n    hasSkills: skills.length > 0,\n  });\n\n  if (!session.model) {\n    throw new FatalError(\"Session model is not set\");\n  }\n\n  const result = streamText({\n    messages: await convertToModelMessages(uiMessages),\n    tools: getTools({ input, event, mcp, sandbox }),\n    system: systemPrompt,\n    model: session.model,\n    abortSignal: abortController.signal,\n  });\n\n  const stepParts: UIMessage[\"parts\"] = [];\n  let wasAborted = false;\n\n  try {\n    await result\n      .toUIMessageStream({\n        generateMessageId: () => assistantMessageId,\n        onFinish: ({ messages }) => {\n          for (const m of messages) {\n            if (m.role === \"assistant\") {\n              stepParts.push(...m.parts);\n            }\n          }\n        },\n      })\n      .pipeTo(writable, { preventClose: true });\n  } catch (err) {\n    if (abortController.signal.aborted) {\n      wasAborted = true;\n    } else {\n      throw err;\n    }\n  } finally {\n    pollController.abort();\n  }\n\n  await Promise.all(\n    stepParts.map(async (uiPart, index) => {\n      const result = await storage.part.set({\n        id: `part_${ulid()}`,\n        index: lastPartIndex + index,\n        messageId: assistantMessageId,\n        sessionId: input.sessionId,\n        part: uiPart,\n      });\n      if (result instanceof Error) {\n        throw result;\n      }\n      return result;\n    })\n  );\n\n  const newLastPartIndex = lastPartIndex + stepParts.length;\n\n  return {\n    finishReason: wasAborted\n      ? (\"stop\" as FinishReason)\n      : await result.finishReason,\n    lastPartIndex: newLastPartIndex,\n  };\n}\n", "import type { SkillsDir } from \"./types\";\n\n/**\n * Parsed frontmatter from a SKILL.md file.\n */\nexport type SkillFrontmatter = {\n  name: string;\n  description: string;\n};\n\n/**\n * Parses YAML frontmatter from a SKILL.md file content.\n * Frontmatter must be at the start of the file, delimited by `---` markers.\n *\n * @example\n * ```markdown\n * ---\n * name: csv\n * description: Analyze CSV data\n * ---\n * # CSV Skill\n * ...\n * ```\n *\n * @returns Parsed name and description, or null if frontmatter is missing/invalid\n */\nexport function parseSkillFrontmatter(\n  content: string\n): SkillFrontmatter | null {\n  const trimmed = content.trim();\n\n  if (!trimmed.startsWith(\"---\")) {\n    return null;\n  }\n\n  const endMarkerIndex = trimmed.indexOf(\"---\", 3);\n  if (endMarkerIndex === -1) {\n    return null;\n  }\n\n  const frontmatterBlock = trimmed.slice(3, endMarkerIndex).trim();\n  const parsed = parseSimpleYaml(frontmatterBlock);\n\n  if (!(parsed.name && parsed.description)) {\n    return null;\n  }\n\n  return {\n    name: String(parsed.name),\n    description: String(parsed.description),\n  };\n}\n\n/**\n * Parses simple YAML key-value pairs (single-line values only).\n * This avoids adding a full YAML parser dependency for basic frontmatter.\n */\nfunction parseSimpleYaml(yaml: string): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  for (const line of yaml.split(\"\\n\")) {\n    const trimmedLine = line.trim();\n    if (!trimmedLine || trimmedLine.startsWith(\"#\")) {\n      continue;\n    }\n\n    const colonIndex = trimmedLine.indexOf(\":\");\n    if (colonIndex === -1) {\n      continue;\n    }\n\n    const key = trimmedLine.slice(0, colonIndex).trim();\n    let value = trimmedLine.slice(colonIndex + 1).trim();\n\n    // Remove surrounding quotes if present\n    if (\n      (value.startsWith('\"') && value.endsWith('\"')) ||\n      (value.startsWith(\"'\") && value.endsWith(\"'\"))\n    ) {\n      value = value.slice(1, -1);\n    }\n\n    if (key) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Normalizes skillsDir to an array of strings.\n */\nexport function normalizeSkillsDirs(skillsDir?: SkillsDir): string[] {\n  if (!skillsDir) {\n    return [];\n  }\n  return Array.isArray(skillsDir) ? skillsDir : [skillsDir];\n}\n", "import type { Sandbox } from \"../sandbox\";\nimport { parseSkillFrontmatter } from \"./parser\";\nimport type { SkillSummary } from \"./types\";\n\n/**\n * Discovers skills from directories inside the sandbox by finding and parsing SKILL.md files.\n * Scans each directory for subdirectories containing SKILL.md, extracts frontmatter metadata,\n * and returns summaries for use in the system prompt.\n *\n * @returns Array of skill summaries (deduplicated by name, first occurrence wins)\n */\nexport async function discoverSkillsInSandbox(opts: {\n  sandbox: Sandbox;\n  skillsDirs: string[];\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDirs, debug } = opts;\n\n  console.log(\"[discover] discoverSkillsInSandbox called:\", {\n    skillsDirs,\n    skillsDirsLength: skillsDirs?.length,\n    debug,\n  });\n\n  const summaries: SkillSummary[] = [];\n  const seenNames = new Set<string>();\n\n  for (const skillsDir of skillsDirs) {\n    const dirSummaries = await discoverSkillsInDirectory({\n      sandbox,\n      skillsDir,\n      debug,\n    });\n\n    for (const summary of dirSummaries) {\n      if (!seenNames.has(summary.name)) {\n        seenNames.add(summary.name);\n        summaries.push(summary);\n      }\n    }\n  }\n\n  return summaries;\n}\n\nasync function discoverSkillsInDirectory(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDir, debug } = opts;\n  const skillPaths = await findSkillFiles({ sandbox, skillsDir, debug });\n\n  if (skillPaths.length === 0) {\n    return [];\n  }\n\n  const summaries: SkillSummary[] = [];\n\n  for (const skillMdPath of skillPaths) {\n    const summary = await parseSkillFile({ sandbox, skillMdPath, debug });\n    if (summary) {\n      summaries.push(summary);\n    }\n  }\n\n  return summaries;\n}\n\nasync function findSkillFiles(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<string[]> {\n  const { sandbox, skillsDir, debug } = opts;\n\n  console.log(\"[discover] findSkillFiles called:\", {\n    skillsDir,\n    debug,\n  });\n\n  console.log(\"[discover] Executing find command:\", {\n    command: \"find\",\n    args: [skillsDir, \"-name\", \"SKILL.md\", \"-type\", \"f\"],\n  });\n\n  const execResult = await sandbox.exec({\n    command: \"find\",\n    args: [skillsDir, \"-name\", \"SKILL.md\", \"-type\", \"f\"],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to scan skills directory \"${skillsDir}\": ${execResult.message}`\n      );\n    }\n    return [];\n  }\n\n  const { stdout, stderr, exitCode } = await execResult.result;\n  if (debug) {\n    console.log(\n      `[discover] find result: exitCode=${exitCode}, stdout=\"${stdout.trim()}\", stderr=\"${stderr.trim()}\"`\n    );\n  }\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(\n        `[discover] Skills directory not found or inaccessible: ${skillsDir}`\n      );\n    }\n    return [];\n  }\n\n  const paths = stdout\n    .trim()\n    .split(\"\\n\")\n    .filter((p) => p.length > 0);\n  if (debug) {\n    console.log(\"[discover] Found skill paths:\", paths);\n  }\n  return paths;\n}\n\nasync function parseSkillFile(opts: {\n  sandbox: Sandbox;\n  skillMdPath: string;\n  debug?: boolean;\n}): Promise<SkillSummary | null> {\n  const { sandbox, skillMdPath, debug } = opts;\n  const execResult = await sandbox.exec({\n    command: \"cat\",\n    args: [skillMdPath],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to read skill file \"${skillMdPath}\": ${execResult.message}`\n      );\n    }\n    return null;\n  }\n\n  const { stdout, exitCode } = await execResult.result;\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);\n    }\n    return null;\n  }\n\n  const parsed = parseSkillFrontmatter(stdout);\n\n  if (!parsed) {\n    if (debug) {\n      console.warn(\n        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`\n      );\n    }\n    return null;\n  }\n\n  return {\n    name: parsed.name,\n    description: parsed.description,\n    skillMdPath,\n  };\n}\n", "import { type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { AgentInput, AgentMessageInput } from \"../agent-workflow\";\nimport type { McpServerSchema } from \"../mcp\";\nimport type { Sandbox } from \"../sandbox\";\n\nexport type ToolContext = {\n  input: AgentInput;\n  event: AgentMessageInput;\n  mcp: McpServerSchema[] | null;\n  sandbox: Sandbox;\n  waitUntil?: (promise: Promise<unknown>) => void;\n};\n\nexport function getTools(context: ToolContext) {\n  return {\n    Read: tool({\n      description:\n        \"Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.\",\n      inputSchema: z.object({\n        path: z\n          .string()\n          .describe(\"Path to the file relative to workspace root\"),\n        startLine: z\n          .number()\n          .optional()\n          .describe(\n            \"Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size.\"\n          ),\n        endLine: z\n          .number()\n          .optional()\n          .describe(\n            \"Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size.\"\n          ),\n      }),\n      outputSchema: z.object({\n        content: z.string().describe(\"File content\"),\n        metadata: z.object({\n          totalLines: z.number().describe(\"Total number of lines in the file\"),\n          linesShown: z\n            .number()\n            .describe(\"Number of lines included in this response\"),\n          startLine: z.number().describe(\"First line number shown (1-indexed)\"),\n          endLine: z.number().describe(\"Last line number shown (1-indexed)\"),\n          isPaginated: z\n            .boolean()\n            .describe(\"Whether this is a partial view of the file\"),\n          fileSize: z\n            .string()\n            .describe(\"Human-readable file size (e.g., '2.5K', '1.2M')\"),\n          path: z\n            .string()\n            .describe(\"Path to the file relative to workspace root\"),\n        }),\n      }),\n      execute: async ({ path, startLine, endLine }) => {\n        const filePath = path;\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            FILE=\"$1\"\n            START_LINE=\"$2\"\n            END_LINE=\"$3\"\n\n            # Resolve symlinks and check file exists\n            if [ -L \"$FILE\" ]; then\n              RESOLVED=$(readlink -f \"$FILE\" 2>/dev/null || echo \"\")\n              if [ -z \"$RESOLVED\" ] || [ ! -e \"$RESOLVED\" ]; then\n                echo \"Error: Broken symlink - $FILE points to non-existent target\" >&2\n                exit 1\n              fi\n              FILE=\"$RESOLVED\"\n            elif [ ! -e \"$FILE\" ]; then\n              echo \"Error: File not found - $FILE\" >&2\n              exit 1\n            fi\n\n            # Get metadata (count actual lines, not just newlines)\n            TOTAL_LINES=$(awk 'END{print NR}' \"$FILE\")\n            FILE_SIZE=$(ls -lh \"$FILE\" | awk '{print $5}')\n\n            # Determine range\n            PAGE_SIZE=100\n            if [ -n \"$START_LINE\" ] && [ -n \"$END_LINE\" ]; then\n              # Both provided - use exact range\n              ACTUAL_START=$START_LINE\n              ACTUAL_END=$END_LINE\n            elif [ -n \"$START_LINE\" ]; then\n              # Only startLine - read PAGE_SIZE lines from there\n              ACTUAL_START=$START_LINE\n              ACTUAL_END=$((START_LINE + PAGE_SIZE - 1))\n              [ \"$ACTUAL_END\" -gt \"$TOTAL_LINES\" ] && ACTUAL_END=$TOTAL_LINES\n            elif [ -n \"$END_LINE\" ]; then\n              # Only endLine - read from beginning to endLine\n              ACTUAL_START=1\n              ACTUAL_END=$END_LINE\n            elif [ \"$TOTAL_LINES\" -gt 200 ]; then\n              # No range, large file - paginate\n              ACTUAL_START=1\n              ACTUAL_END=$PAGE_SIZE\n            else\n              # No range, small file - show all\n              ACTUAL_START=1\n              ACTUAL_END=$TOTAL_LINES\n            fi\n\n            # Output metadata first (separated by ||| for parsing)\n            echo \"$TOTAL_LINES|$FILE_SIZE|$ACTUAL_START|$ACTUAL_END\"\n            echo \"|||CONTENT|||\"\n\n            # Read content\n            if [ \"$ACTUAL_START\" -eq 1 ] && [ \"$ACTUAL_END\" -eq \"$TOTAL_LINES\" ]; then\n              cat \"$FILE\"\n            else\n              sed -n \"\\${ACTUAL_START},\\${ACTUAL_END}p\" \"$FILE\"\n            fi\n          `,\n            \"--\",\n            filePath,\n            startLine?.toString() || \"\",\n            endLine?.toString() || \"\",\n          ],\n        });\n\n        if (result instanceof Error) {\n          console.error(\"[Read Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          console.error(`[Read Tool] Error: ${stderr}`);\n          return {\n            content: `Error: ${stderr}`,\n            metadata: {\n              totalLines: 0,\n              linesShown: 0,\n              startLine: 0,\n              endLine: 0,\n              isPaginated: false,\n              fileSize: \"0\",\n              path: filePath,\n            },\n          };\n        }\n\n        const [metadataLine, ...rest] = stdout.split(\"|||CONTENT|||\");\n        const content = rest.join(\"|||CONTENT|||\").trimStart();\n        const [totalLinesStr, fileSize, actualStartStr, actualEndStr] =\n          metadataLine.trim().split(\"|\");\n\n        const totalLines = Number.parseInt(totalLinesStr, 10);\n        const actualStart = Number.parseInt(actualStartStr, 10);\n        const actualEnd = Number.parseInt(actualEndStr, 10);\n\n        if (\n          Number.isNaN(totalLines) ||\n          Number.isNaN(actualStart) ||\n          Number.isNaN(actualEnd)\n        ) {\n          console.error(\n            `[Read Tool] Failed to parse metadata: ${metadataLine}`\n          );\n          return {\n            content: `Error: Failed to parse file metadata. Raw output: ${stdout.slice(\n              0,\n              500\n            )}`,\n            metadata: {\n              totalLines: 0,\n              linesShown: 0,\n              startLine: 0,\n              endLine: 0,\n              isPaginated: false,\n              fileSize: \"unknown\",\n              path: filePath,\n            },\n          };\n        }\n\n        return {\n          metadata: {\n            totalLines,\n            linesShown: Math.max(0, actualEnd - actualStart + 1),\n            startLine: actualStart,\n            endLine: actualEnd,\n            isPaginated: actualEnd < totalLines,\n            fileSize: fileSize || \"unknown\",\n            path: filePath,\n          },\n          content,\n        };\n      },\n    }),\n    Grep: tool({\n      description:\n        \"Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.\",\n      inputSchema: z.object({\n        pattern: z\n          .string()\n          .describe(\"Regex pattern to search for (ripgrep syntax)\"),\n        path: z\n          .string()\n          .optional()\n          .describe(\n            \"Path to search in (defaults to workspace root). Can be a file or directory.\"\n          ),\n        fileType: z\n          .string()\n          .optional()\n          .describe(\n            \"File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters.\"\n          ),\n        glob: z\n          .string()\n          .optional()\n          .describe(\n            \"Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')\"\n          ),\n        caseSensitive: z\n          .boolean()\n          .optional()\n          .default(true)\n          .describe(\"Whether search is case-sensitive (default: true)\"),\n        contextLines: z\n          .number()\n          .optional()\n          .describe(\n            \"Number of context lines to show before and after each match\"\n          ),\n        maxCount: z\n          .number()\n          .optional()\n          .describe(\n            \"Maximum number of matches per file (useful for limiting output)\"\n          ),\n        filesWithMatches: z\n          .boolean()\n          .optional()\n          .default(false)\n          .describe(\n            \"Only show file paths that contain matches, not the matching lines themselves\"\n          ),\n      }),\n      outputSchema: z.object({\n        matches: z\n          .string()\n          .describe(\n            \"Search results with file paths, line numbers, and matching content\"\n          ),\n        summary: z.object({\n          matchCount: z.number().describe(\"Number of matches found\"),\n          fileCount: z.number().describe(\"Number of files containing matches\"),\n          searchPath: z.string().describe(\"Path that was searched\"),\n          pattern: z.string().describe(\"Pattern that was searched for\"),\n        }),\n      }),\n      execute: async ({\n        pattern,\n        path,\n        fileType,\n        glob,\n        caseSensitive,\n        contextLines,\n        maxCount,\n        filesWithMatches,\n      }) => {\n        const searchPath = path ?? \".\";\n\n        const args: string[] = [];\n\n        args.push(\"--line-number\");\n        args.push(\"--heading\");\n        args.push(\"--color\", \"never\");\n\n        if (!caseSensitive) {\n          args.push(\"-i\");\n        }\n\n        if (fileType) {\n          args.push(\"--type\", fileType);\n        }\n\n        if (glob) {\n          args.push(\"--glob\", glob);\n        }\n\n        if (contextLines !== undefined) {\n          args.push(\"-C\", String(contextLines));\n        }\n\n        if (maxCount !== undefined) {\n          args.push(\"--max-count\", String(maxCount));\n        }\n\n        if (filesWithMatches) {\n          args.push(\"--files-with-matches\");\n        }\n\n        args.push(\"--\", pattern, searchPath);\n\n        const result = await context.sandbox.exec({ command: \"rg\", args });\n\n        if (result instanceof Error) {\n          console.error(\"[Grep Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr && !stderr.toLowerCase().includes(\"no matches\")) {\n          console.error(`[Grep Tool] Warning: ${stderr}`);\n        }\n\n        // Truncate output to prevent \"input too long\" errors (50k chars \u2248 12.5k tokens)\n        const MAX_GREP_OUTPUT_CHARS = 50_000;\n        let finalOutput = stdout;\n        let wasTruncated = false;\n        if (finalOutput.length > MAX_GREP_OUTPUT_CHARS) {\n          finalOutput =\n            finalOutput.slice(0, MAX_GREP_OUTPUT_CHARS) +\n            \"\\n\\n[Output truncated - use more specific pattern or path]\";\n          wasTruncated = true;\n        }\n\n        const lines = finalOutput\n          .trim()\n          .split(\"\\n\")\n          .filter((l) => l.length > 0);\n        const fileCount = filesWithMatches\n          ? lines.length\n          : new Set(\n              lines\n                .filter((l) => !l.startsWith(\" \") && l.includes(\":\"))\n                .map((l) => l.split(\":\")[0])\n            ).size;\n\n        return {\n          summary: {\n            matchCount: filesWithMatches\n              ? 0\n              : lines.filter((l) => l.includes(\":\")).length,\n            fileCount,\n            searchPath,\n            pattern,\n            wasTruncated,\n          },\n          matches: finalOutput || \"(no matches found)\",\n        };\n      },\n    }),\n    List: tool({\n      description:\n        \"Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.\",\n      inputSchema: z.object({\n        path: z\n          .string()\n          .optional()\n          .describe(\"Path to list (defaults to workspace root)\"),\n        depth: z\n          .number()\n          .optional()\n          .describe(\n            \"Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping\"\n          ),\n        includeHidden: z\n          .boolean()\n          .optional()\n          .default(false)\n          .describe(\n            \"Include hidden files and directories (those starting with '.')\"\n          ),\n        filesOnly: z\n          .boolean()\n          .optional()\n          .default(false)\n          .describe(\"Only show files, not directories\"),\n        pattern: z\n          .string()\n          .optional()\n          .describe(\"Glob pattern to filter results (e.g., '*.ts', '*test*')\"),\n      }),\n      outputSchema: z.object({\n        listing: z\n          .string()\n          .describe(\n            \"Directory tree listing showing paths relative to search root\"\n          ),\n        summary: z.object({\n          totalItems: z.number().describe(\"Total number of items found\"),\n          totalFiles: z.number().describe(\"Total number of files found\"),\n          totalDirs: z.number().describe(\"Total number of directories found\"),\n          searchPath: z.string().describe(\"Path that was listed\"),\n          depth: z\n            .number()\n            .optional()\n            .describe(\"Maximum depth used (if specified)\"),\n        }),\n      }),\n      execute: async ({ path, depth, includeHidden, filesOnly, pattern }) => {\n        const searchPath = path ?? \".\";\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            SEARCH_PATH=\"$1\"\n            DEPTH=\"$2\"\n            INCLUDE_HIDDEN=\"$3\"\n            FILES_ONLY=\"$4\"\n            PATTERN=\"$5\"\n\n            # Build find command arguments\n            FIND_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && FIND_ARGS=\"$FIND_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && FIND_ARGS=\"$FIND_ARGS ! -path '*/.*'\"\n            [ \"$FILES_ONLY\" = \"true\" ] && FIND_ARGS=\"$FIND_ARGS -type f\"\n            [ -n \"$PATTERN\" ] && FIND_ARGS=\"$FIND_ARGS -name '$PATTERN'\"\n\n            # Get listing\n            LISTING=$(eval \"find '$SEARCH_PATH' $FIND_ARGS\" 2>/dev/null | sort)\n\n            # Get counts\n            COUNT_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && COUNT_ARGS=\"$COUNT_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && COUNT_ARGS=\"$COUNT_ARGS ! -path '*/.*'\"\n\n            FILE_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type f\" 2>/dev/null | wc -l)\n            DIR_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type d\" 2>/dev/null | wc -l)\n\n            # Output: counts first, then listing\n            echo \"$FILE_COUNT|$DIR_COUNT\"\n            echo \"|||LISTING|||\"\n            echo \"$LISTING\" | sed \"s|^$SEARCH_PATH|.|\"\n          `,\n            \"--\",\n            searchPath,\n            depth?.toString() || \"\",\n            includeHidden ? \"true\" : \"false\",\n            filesOnly ? \"true\" : \"false\",\n            pattern || \"\",\n          ],\n        });\n\n        if (result instanceof Error) {\n          console.error(\"[List Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          console.warn(`[List Tool] stderr: ${stderr}`);\n        }\n\n        const [countsLine, ...rest] = stdout.split(\"|||LISTING|||\");\n        const listing = rest.join(\"|||LISTING|||\").trim();\n        const [fileCountStr, dirCountStr] = countsLine.trim().split(\"|\");\n\n        const totalFiles = Number.parseInt(fileCountStr, 10) || 0;\n        const totalDirs = Number.parseInt(dirCountStr, 10) || 0;\n        const lines = listing.split(\"\\n\").filter((l) => l.length > 0);\n\n        return {\n          summary: {\n            totalItems: lines.length,\n            totalFiles,\n            totalDirs,\n            searchPath,\n            depth,\n          },\n          listing,\n        };\n      },\n    }),\n    Write: tool({\n      description:\n        \"Write content to a file. Creates parent directories automatically. Overwrites existing files.\",\n      inputSchema: z.object({\n        path: z\n          .string()\n          .describe(\"Path to the file relative to workspace root\"),\n        content: z.string().describe(\"Content to write to the file\"),\n      }),\n      outputSchema: z.object({\n        success: z.boolean().describe(\"Whether the write succeeded\"),\n        path: z.string().describe(\"Path to the written file\"),\n        bytesWritten: z.number().describe(\"Number of bytes written\"),\n        error: z.string().optional().describe(\"Error message if write failed\"),\n      }),\n      execute: async ({ path, content }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          if (dir !== \".\") {\n            await context.sandbox.exec({ command: \"mkdir\", args: [\"-p\", dir] });\n          }\n\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content }],\n            destPath: dir,\n          });\n\n          return {\n            success: true,\n            path: filePath,\n            bytesWritten: Buffer.byteLength(content, \"utf8\"),\n          };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return {\n            success: false,\n            path: filePath,\n            bytesWritten: 0,\n            error: errorMsg,\n          };\n        }\n      },\n    }),\n    Edit: tool({\n      description:\n        \"Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.\",\n      inputSchema: z.object({\n        path: z\n          .string()\n          .describe(\"Path to the file relative to workspace root\"),\n        old_string: z\n          .string()\n          .describe(\n            \"Exact string to find and replace (must be unique in file)\"\n          ),\n        new_string: z.string().describe(\"String to replace old_string with\"),\n      }),\n      outputSchema: z.object({\n        success: z.boolean().describe(\"Whether the edit succeeded\"),\n        path: z.string().describe(\"Path to the edited file\"),\n        error: z.string().optional().describe(\"Error message if edit failed\"),\n      }),\n      execute: async ({ path, old_string, new_string }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            FILE=\"$1\"\n            \n            if [ ! -f \"$FILE\" ]; then\n              echo \"FILE_NOT_FOUND\"\n              exit 0\n            fi\n            \n            CONTENT=$(cat \"$FILE\")\n            echo \"$CONTENT\"\n          `,\n            \"--\",\n            filePath,\n          ],\n        });\n\n        if (result instanceof Error) {\n          return { success: false, path: filePath, error: result.message };\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          return { success: false, path: filePath, error: stderr };\n        }\n\n        if (stdout === \"FILE_NOT_FOUND\") {\n          return {\n            success: false,\n            path: filePath,\n            error: `File not found: ${filePath}`,\n          };\n        }\n\n        const content = stdout;\n        const occurrences = content.split(old_string).length - 1;\n\n        if (occurrences === 0) {\n          return {\n            success: false,\n            path: filePath,\n            error: \"old_string not found in file\",\n          };\n        }\n\n        if (occurrences > 1) {\n          return {\n            success: false,\n            path: filePath,\n            error: `old_string appears ${occurrences} times in file (must be unique). Include more surrounding context to make the match unique.`,\n          };\n        }\n\n        const newContent = content.replace(old_string, new_string);\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content: newContent }],\n            destPath: dir,\n          });\n\n          return { success: true, path: filePath };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return { success: false, path: filePath, error: errorMsg };\n        }\n      },\n    }),\n    Bash: tool({\n      description:\n        \"Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).\",\n      inputSchema: z.object({\n        command: z.string().describe(\"The shell command to execute\"),\n        waitUntil: z\n          .number()\n          .optional()\n          .describe(\n            \"Max ms to wait for completion (default: 30000). Use 0 to run in background and return immediately.\"\n          ),\n      }),\n      outputSchema: z.object({\n        pid: z\n          .number()\n          .describe(\n            \"System PID (0 for foreground, >0 for background - use to kill)\"\n          ),\n        output: z\n          .string()\n          .describe(\"Command stdout+stderr combined (empty for background)\"),\n        exitCode: z.number().describe(\"Exit code (-1 for background/running)\"),\n        status: z\n          .enum([\"running\", \"completed\", \"failed\"])\n          .describe(\"Process status\"),\n        cwd: z.string().describe(\"Current working directory after command\"),\n        outputFile: z\n          .string()\n          .describe(\"Path to output log (for background processes)\"),\n      }),\n      execute: async ({ command, waitUntil }) => {\n        const { createProcessManager } = await import(\n          \"../sandbox/process-manager\"\n        );\n\n        const processManager = createProcessManager({\n          sandbox: context.sandbox,\n          sessionId: context.input.sessionId,\n          generateId: () => crypto.randomUUID(),\n        });\n\n        await processManager.init();\n        return processManager.run({ command, waitUntil });\n      },\n    }),\n    ExecuteMCPTool: tool({\n      description: \"Execute a tool from an MCP server.\",\n      inputSchema: z.object({\n        server: z.string().describe(\"MCP server name\"),\n        tool: z.string().describe(\"Tool name to execute\"),\n        input: z.unknown().describe(\"Tool input matching the tool's schema\"),\n      }),\n      outputSchema: z.object({\n        result: z\n          .unknown()\n          .optional()\n          .describe(\n            \"Tool result (included if small enough, else left in the output file)\"\n          ),\n        outputPath: z\n          .string()\n          .describe(\"Path to the output file containing the full result\"),\n        chars: z.number().describe(\"Total characters in the output\"),\n      }),\n      execute: async ({ server, tool: toolName, input }) => {\n        const serverConfig = context.mcp?.find((s) => s.name === server);\n        if (!serverConfig) {\n          throw new Error(`Unknown MCP server: ${server}`);\n        }\n\n        const parsedInput =\n          typeof input === \"string\" ? JSON.parse(input) : input;\n\n        const timestamp = Date.now();\n        const outputDir = `.agent/mcp/${server}/.outputs`;\n        const outputFile = `${outputDir}/${timestamp}-${toolName}.txt`;\n\n        const [res] = await Promise.all([\n          fetch(serverConfig.url, {\n            method: \"POST\",\n            headers: { \"Content-Type\": \"application/json\" },\n            body: JSON.stringify({\n              server,\n              tool: toolName,\n              input: parsedInput,\n              sessionId: context.input.sessionId,\n              messageId: context.event.assistantMessageId,\n              hookToken: context.event.hookToken,\n            }),\n          }),\n          context.sandbox.exec({ command: \"mkdir\", args: [\"-p\", outputDir] }),\n        ]);\n\n        if (!res.ok) {\n          const error = await res.text();\n          throw new Error(`MCP tool call failed: ${error}`);\n        }\n\n        const json = (await res.json()) as {\n          result?: unknown;\n          error?: { code: string; message: string };\n        };\n\n        if (json.error) {\n          throw new Error(`MCP tool call failed: ${json.error.message}`);\n        }\n\n        if (json.result === undefined) {\n          throw new Error(\"MCP tool call failed: No result in response\");\n        }\n\n        const result = json.result;\n        const resultStr = JSON.stringify(result, null, 2);\n\n        await context.sandbox.writeFiles({\n          files: [{ path: `${timestamp}-${toolName}.txt`, content: resultStr }],\n          destPath: outputDir,\n        });\n\n        const MAX_OUTPUT_CHARS = 24_000;\n        if (resultStr.length <= MAX_OUTPUT_CHARS) {\n          return { result, outputPath: outputFile, chars: resultStr.length };\n        }\n\n        return { outputPath: outputFile, chars: resultStr.length };\n      },\n    }),\n  } satisfies ToolSet;\n}\n\nexport type AgentTools = ReturnType<typeof getTools>;\nexport type AgentToolName = keyof AgentTools;\n", "import type { UIMessage } from \"ai\";\nimport type { Message, Part } from \"../storage\";\n\nexport function assembleUIMessages(opts: {\n  messages: Message[];\n  parts: Part[];\n}): UIMessage[] {\n  const partsByMessage = new Map<string, Part[]>();\n  for (const part of opts.parts) {\n    const existing = partsByMessage.get(part.messageId) ?? [];\n    existing.push(part);\n    partsByMessage.set(part.messageId, existing);\n  }\n\n  return opts.messages.map((m) => {\n    const messageParts = partsByMessage.get(m.id) ?? [];\n    messageParts.sort((a, b) => a.index - b.index);\n    return {\n      id: m.id,\n      role: m.role,\n      parts: messageParts.map((p) => p.part),\n    } satisfies UIMessage;\n  });\n}\n"],
  "mappings": "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",
  "names": ["opts", "startLocalStorage", "getVercelStorageConfig", "import_zod", "exitCode", "stderr", "errore", "init_local", "storage", "sandboxRecord", "errore", "init_vercel", "sandbox", "VercelSandboxSDK", "getSandbox", "sandboxRecord", "init_client", "init_local", "init_vercel", "init_client", "import_workflow", "import_ai", "import_ulid", "path", "createProcessManager", "getStorage", "getSandbox", "result"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/process-manager.ts", "../src/errors.ts", "../src/storage/client.ts", "../src/sandbox/write-files.ts", "../src/sandbox/bindings/local.ts", "../src/sandbox/bindings/vercel-sdk.ts", "../src/storage/rpc.ts", "../src/storage/handler.ts", "../src/storage/index.ts", "../src/sandbox/bindings/lifecycle-workflow-steps.ts", "../src/sandbox/bindings/lifecycle-workflow.ts", "../src/sandbox/bindings/vercel.ts", "../src/sandbox/client.ts", "../src/sandbox/index.ts", "../src/agent-workflow.ts", "../src/agent-workflow-steps.ts", "../src/skills/parser.ts", "../src/skills/discover.ts", "../src/tools/index.ts", "../src/tools/javascript.ts", "../src/utils/prompt-cache.ts", "../src/utils/ui.ts", "../src/utils/usage.ts"],
  "sourcesContent": ["import type { BashResult, Sandbox } from \"./types\";\n\nexport const DEFAULT_WAIT_UNTIL = 2000;\n\n/**\n * Shell script that handles all process execution logic.\n * Installed to ~/.agent/bin/run.sh during init().\n */\nconst RUN_SCRIPT = `#!/bin/sh\n# Process runner for Agent SDK\n# All parameters passed via environment variables to avoid escaping issues\n# Output is base64 encoded to avoid JSON escaping issues\n\nAGENT_DIR=\"$HOME/.agent\"\nCWD_FILE=\"$AGENT_DIR/cwd/$SESSION_ID\"\n\n# Get current working directory (per-session)\nif [ -f \"$CWD_FILE\" ]; then\n  CWD=$(cat \"$CWD_FILE\")\nelse\n  CWD=\"$HOME\"\nfi\n\n# Decode command\nCMD=$(echo \"$CMD_BASE64\" | base64 -d)\n\n# Background mode (waitUntil = 0)\nif [ \"$WAIT_UNTIL\" = \"0\" ]; then\n  cd \"$CWD\" || cd \"$HOME\"\n\n  # Generate a simple numeric ID for output file\n  OUTPUT_ID=\"$(date +%s)$$\"\n  OUTPUT_FILE=\"$AGENT_DIR/outputs/$OUTPUT_ID.log\"\n\n  # Double-fork to fully detach the process\n  (\n    (\n      eval \"$CMD\"\n      pwd > \"$CWD_FILE\" 2>/dev/null\n    ) > \"$OUTPUT_FILE\" 2>&1 < /dev/null &\n    echo $! > \"$AGENT_DIR/pids/$OUTPUT_ID.pid\"\n  )\n\n  # Small delay to ensure PID file is written\n  sleep 0.05\n\n  # Read PID\n  if [ -f \"$AGENT_DIR/pids/$OUTPUT_ID.pid\" ]; then\n    PID=$(cat \"$AGENT_DIR/pids/$OUTPUT_ID.pid\")\n  else\n    PID=0\n  fi\n\n  # Output JSON result (no output for background, so no encoding needed)\n  printf '{\"pid\":%d,\"outputBase64\":\"\",\"exitCode\":-1,\"status\":\"running\",\"outputFile\":\"%s\",\"cwd\":\"%s\"}\\\\n' \\\\\n    \"$PID\" \"$OUTPUT_FILE\" \"$CWD\"\n  exit 0\nfi\n\n# Foreground mode (waitUntil > 0) - run directly and capture output\ncd \"$CWD\" || cd \"$HOME\"\n\n# Run command, capture output and exit code\nOUTPUT=$(eval \"$CMD\" 2>&1)\nEXIT_CODE=$?\n\n# Update CWD after command\nNEW_CWD=$(pwd)\necho \"$NEW_CWD\" > \"$CWD_FILE\"\n\n# Determine status\nif [ $EXIT_CODE -eq 0 ]; then\n  STATUS=\"completed\"\nelse\n  STATUS=\"failed\"\nfi\n\n# Base64 encode output to avoid ALL escaping issues\nOUTPUT_BASE64=$(printf '%s' \"$OUTPUT\" | base64 | tr -d '\\\\n')\n\n# Output JSON result with base64-encoded output\nprintf '{\"pid\":0,\"outputBase64\":\"%s\",\"exitCode\":%d,\"status\":\"%s\",\"outputFile\":\"\",\"cwd\":\"%s\"}\\\\n' \\\\\n  \"$OUTPUT_BASE64\" \"$EXIT_CODE\" \"$STATUS\" \"$NEW_CWD\"\n`;\n\ntype RunOptions = {\n  command: string;\n  /**\n   * Max ms to wait for completion.\n   * - 0: Background mode - return immediately with PID\n   * - >0: Foreground mode - wait for completion (default: 30000)\n   */\n  waitUntil?: number;\n};\n\n/**\n * Process manager that uses a single shell script to handle all execution logic.\n * Reduces round-trips to the sandbox by doing everything in one exec call.\n */\nexport const createProcessManager = (opts: {\n  sandbox: Sandbox;\n  sessionId: string;\n}) => {\n  const { sandbox, sessionId } = opts;\n  let initialized = false;\n\n  const init = async (): Promise<void> => {\n    if (initialized) {\n      return;\n    }\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `mkdir -p $HOME/.agent/bin $HOME/.agent/pids $HOME/.agent/outputs $HOME/.agent/cwd\ncat > $HOME/.agent/bin/run.sh << 'SCRIPT_EOF'\n${RUN_SCRIPT}\nSCRIPT_EOF\nchmod +x $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n    await result.result;\n    initialized = true;\n  };\n\n  const run = async (opts: RunOptions): Promise<BashResult> => {\n    await init();\n\n    const { command, waitUntil = DEFAULT_WAIT_UNTIL } = opts;\n    const cmdBase64 = Buffer.from(command, \"utf-8\").toString(\"base64\");\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `CMD_BASE64=\"${cmdBase64}\" WAIT_UNTIL=\"${waitUntil}\" SESSION_ID=\"${sessionId}\" $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n\n    const { stdout } = await result.result;\n    const parsed = JSON.parse(stdout.trim()) as {\n      pid: number;\n      outputBase64: string;\n      exitCode: number;\n      status: \"running\" | \"completed\" | \"failed\";\n      outputFile: string;\n      cwd: string;\n    };\n\n    // Decode base64 output\n    const output = parsed.outputBase64\n      ? Buffer.from(parsed.outputBase64, \"base64\").toString(\"utf-8\")\n      : \"\";\n\n    return {\n      pid: parsed.pid,\n      output,\n      exitCode: parsed.exitCode,\n      status: parsed.status,\n      cwd: parsed.cwd,\n      outputFile: parsed.outputFile,\n    };\n  };\n\n  const getCwd = async (): Promise<string> => {\n    await init();\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `cat $HOME/.agent/cwd/${sessionId} 2>/dev/null || echo \"$HOME\"`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      return process.cwd();\n    }\n\n    const { stdout } = await result.result;\n    return stdout.trim() || process.cwd();\n  };\n\n  return {\n    init,\n    run,\n    getCwd,\n  };\n};\n\nexport type ProcessManager = ReturnType<typeof createProcessManager>;\n", "import * as errore from \"errore\";\n\nexport class SessionNotFoundError extends errore.createTaggedError({\n  name: \"SessionNotFoundError\",\n  message: \"Session $id not found\",\n}) {}\n\nexport class SessionError extends errore.createTaggedError({\n  name: \"SessionError\",\n  message: \"Session $id failed: $reason\",\n}) {}\n\nexport class SandboxNotFoundError extends errore.createTaggedError({\n  name: \"SandboxNotFoundError\",\n  message: \"Sandbox $id not found\",\n}) {}\n\nexport class StorageError extends errore.createTaggedError({\n  name: \"StorageError\",\n  message: \"$reason\",\n}) {}\n\nexport class SandboxError extends errore.createTaggedError({\n  name: \"SandboxError\",\n  message: \"$reason\",\n}) {}\n\nexport class MessageNotFoundError extends errore.createTaggedError({\n  name: \"MessageNotFoundError\",\n  message: \"Message $id not found\",\n}) {}\n", "import type { z } from \"zod\";\nimport {\n  MessageNotFoundError,\n  SandboxNotFoundError,\n  SessionNotFoundError,\n  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport type RpcFn = (params: {\n  name?: string;\n  method: string;\n  params: unknown;\n}) => Promise<RpcResponse<unknown>>;\n\nexport function getStorageClient(rpcFn: RpcFn, name?: string): Storage {\n  async function rpc<M extends keyof StorageMethods>(\n    method: M,\n    params: z.infer<StorageMethods[M][\"params\"]>\n  ): Promise<z.infer<StorageMethods[M][\"result\"]>> {\n    const result = await rpcFn({ name, method, params });\n\n    if (\"error\" in result) {\n      throw new StorageError({ reason: result.error.message });\n    }\n\n    return result.result as z.infer<StorageMethods[M][\"result\"]>;\n  }\n\n  return {\n    session: {\n      get: async (id) => {\n        try {\n          const result = await rpc(\"session.get\", { id });\n          if (result === null) {\n            return new SessionNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (session) => {\n        try {\n          return await rpc(\"session.set\", session);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"session.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sessionId, tags }) => {\n          try {\n            return await rpc(\"session.tag.set\", { sessionId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    message: {\n      list: async (sessionId, opts) => {\n        try {\n          return await rpc(\"message.list\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      get: async (id) => {\n        try {\n          const result = await rpc(\"message.get\", { id });\n          if (result === null) {\n            return new MessageNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (message) => {\n        try {\n          return await rpc(\"message.set\", message);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    part: {\n      listByMessage: async (messageId, opts) => {\n        try {\n          const result = await rpc(\"part.listByMessage\", {\n            messageId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySession: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"part.listBySession\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (part) => {\n        try {\n          return (await rpc(\"part.set\", part)) as Part;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"part.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    sandbox: {\n      get: async (key) => {\n        try {\n          const result = await rpc(\"sandbox.get\", { key });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: key });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      getBySession: async (sessionId) => {\n        try {\n          const result = await rpc(\"sandbox.getBySession\", { sessionId });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: sessionId });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (record) => {\n        try {\n          await rpc(\"sandbox.set\", record);\n          return record;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"sandbox.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sandboxId, tags }) => {\n          try {\n            return await rpc(\"sandbox.tag.set\", { sandboxId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    command: {\n      get: async (id) => {\n        try {\n          return (await rpc(\"command.get\", { id })) as Command | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (command) => {\n        try {\n          return (await rpc(\"command.set\", command)) as Command;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"command.list\", {\n            sessionId,\n            includeFinished: opts?.includeFinished,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Command>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n  };\n}\n\nexport const DEFAULT_NAMESPACE = \"default\";\nexport const LOCAL_STORAGE_VERSION = \"v1\";\n\nexport function getStorage(opts: {\n  config: StorageConfig;\n  rpc: RpcFn;\n}): Storage {\n  const name = opts.config.name ?? DEFAULT_NAMESPACE;\n  return getStorageClient(opts.rpc, name);\n}\n", "import * as path from \"node:path\";\nimport type { UploadableFile } from \"../skills/types\";\nimport type { Sandbox } from \"./types\";\n\n/**\n * Writes files to a sandbox at the specified destination path.\n * Shell scripts (.sh files) are automatically made executable.\n *\n * For small files (<100KB total), uses single exec with heredoc.\n * For large files, writes base64 chunks then decodes to avoid ARG_MAX limits.\n */\nexport async function writeFiles(opts: {\n  sandbox: Pick<Sandbox, \"exec\">;\n  files: UploadableFile[];\n  destPath: string;\n}): Promise<void> {\n  const { sandbox, files, destPath } = opts;\n\n  if (files.length === 0) {\n    return;\n  }\n\n  const filePaths = files.map((file) => path.posix.join(destPath, file.path));\n  const parentDirs = Array.from(\n    new Set(filePaths.map((p) => path.posix.dirname(p)))\n  );\n  const shellScripts = filePaths.filter((p) => p.endsWith(\".sh\"));\n\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", ...parentDirs],\n  });\n  if (mkdirResult instanceof Error) {\n    throw mkdirResult;\n  }\n  await mkdirResult.result;\n\n  const CHUNK_SIZE = 50_000;\n\n  for (let i = 0; i < files.length; i++) {\n    const file = files[i];\n    const fullPath = filePaths[i];\n    const base64Content = toBase64(file.content);\n\n    if (base64Content.length < CHUNK_SIZE) {\n      const marker = `EOF_${i}`;\n      const execResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d > ${quote(fullPath)} << '${marker}'\n${base64Content}\n${marker}`,\n        ],\n      });\n\n      if (execResult instanceof Error) {\n        throw execResult;\n      }\n\n      const { exitCode, stderr } = await execResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles failed with exit code ${exitCode}: ${stderr}`\n        );\n      }\n    } else {\n      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;\n\n      const clearResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\"-c\", `> ${quote(tempB64)}`],\n      });\n      if (clearResult instanceof Error) {\n        throw clearResult;\n      }\n      await clearResult.result;\n\n      for (\n        let offset = 0;\n        offset < base64Content.length;\n        offset += CHUNK_SIZE\n      ) {\n        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);\n        const marker = `CHUNK_${offset}`;\n        const appendResult = await sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `cat >> ${quote(tempB64)} << '${marker}'\n${chunk}\n${marker}`,\n          ],\n        });\n\n        if (appendResult instanceof Error) {\n          throw appendResult;\n        }\n\n        const { exitCode, stderr } = await appendResult.result;\n        if (exitCode !== 0) {\n          throw new Error(\n            `writeFiles chunk failed with exit code ${exitCode}: ${stderr}`\n          );\n        }\n      }\n\n      const decodeResult = await sandbox.exec({\n        command: \"bash\",\n        args: [\n          \"-c\",\n          `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`,\n        ],\n      });\n\n      if (decodeResult instanceof Error) {\n        throw decodeResult;\n      }\n\n      const { exitCode, stderr } = await decodeResult.result;\n      if (exitCode !== 0) {\n        throw new Error(\n          `writeFiles decode failed with exit code ${exitCode}: ${stderr}`\n        );\n      }\n    }\n  }\n\n  if (shellScripts.length > 0) {\n    const chmodResult = await sandbox.exec({\n      command: \"chmod\",\n      args: [\"+x\", ...shellScripts],\n    });\n    if (chmodResult instanceof Error) {\n      throw chmodResult;\n    }\n    await chmodResult.result;\n  }\n}\n\nfunction toBase64(content: string | Buffer): string {\n  if (typeof content === \"string\") {\n    return Buffer.from(content).toString(\"base64\");\n  }\n  return content.toString(\"base64\");\n}\n\nfunction quote(s: string): string {\n  return `'${s.replace(/'/g, \"'\\\\''\")}'`;\n}\n", "import type { ChildProcess } from \"node:child_process\";\nimport { spawn } from \"node:child_process\";\nimport * as errore from \"errore\";\nimport { ulid } from \"ulid\";\nimport { SandboxError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type { SandboxRecord, Storage } from \"../../storage\";\nimport type { LogEntry, Sandbox } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport const localSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storage,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"local\" } };\n  storage: Storage;\n}): Sandbox<TTags> => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n\n  const sandbox: Sandbox<TTags> = {\n    id: sandboxRecord.id,\n    config: sandboxRecord.config,\n    exec: ({ command, args, signal }) => {\n      return errore.tryAsync({\n        try: () => {\n          const commandId = `command_${ulid()}`;\n\n          const child = spawn(command, args, {\n            cwd: basePath,\n            signal,\n          });\n\n          processes.set(commandId, child);\n\n          let stdout = \"\";\n          let stderr = \"\";\n          const logQueue: LogEntry[] = [];\n          let logResolve: (() => void) | null = null;\n          let closed = false;\n\n          child.stdout.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stdout += str;\n            logQueue.push({ stream: \"stdout\", data: str });\n            logResolve?.();\n          });\n\n          child.stderr.on(\"data\", (data: string | Buffer) => {\n            const str = String(data);\n            stderr += str;\n            logQueue.push({ stream: \"stderr\", data: str });\n            logResolve?.();\n          });\n\n          const result = new Promise<{\n            stdout: string;\n            stderr: string;\n            exitCode: number;\n          }>((resolve, reject) => {\n            child.on(\"error\", (err) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              reject(err);\n            });\n\n            child.on(\"close\", (code: number | null) => {\n              processes.delete(commandId);\n              closed = true;\n              logResolve?.();\n              resolve({ stdout, stderr, exitCode: code ?? 0 });\n            });\n          });\n\n          async function* logs(): AsyncIterable<LogEntry> {\n            while (!closed || logQueue.length > 0) {\n              const entry = logQueue.shift();\n              if (entry) {\n                yield entry;\n              } else if (!closed) {\n                await new Promise<void>((resolve) => {\n                  logResolve = resolve;\n                });\n                logResolve = null;\n              }\n            }\n          }\n\n          return Promise.resolve({ commandId, logs, result });\n        },\n        catch: (e: unknown) =>\n          new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getDomain: (port) => {\n      return Promise.resolve(`http://localhost:${port}`);\n    },\n\n    kill: async ({ commandId, storage }) => {\n      const child = processes.get(commandId);\n      if (!child) {\n        return new SandboxError({\n          reason: `Command ${commandId} not found or already finished`,\n        });\n      }\n\n      child.kill(\"SIGTERM\");\n\n      const cmd = await storage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await storage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(sandbox.id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: sandbox.id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  return sandbox;\n};\n", "export { Sandbox } from \"sandbox\";\n", "import { z } from \"zod\";\n\nconst VercelLifecycleConfigSchema = z.object({\n  pollIntervalMs: z.number().optional(),\n  stopAfterInactiveMs: z.number().optional(),\n  snapshotBeforeTimeoutMs: z.number().optional(),\n  snapshotId: z.string().optional(),\n  autoStart: z.boolean().optional(),\n});\n\nexport const SandboxConfigSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"vercel\"),\n    resources: z.object({ vcpus: z.number() }).optional(),\n    ports: z.array(z.number()).optional(),\n    lifecycle: VercelLifecycleConfigSchema.optional(),\n  }),\n  z.object({\n    type: z.literal(\"local\"),\n    path: z.string().optional(),\n  }),\n  z.object({\n    type: z.literal(\"custom\"),\n    url: z.string(),\n    headers: z.record(z.string(), z.string()).optional(),\n  }),\n]);\n\nexport type SandboxConfig = z.infer<typeof SandboxConfigSchema>;\n\nconst GenerationSchema = z.object({\n  maxSteps: z.number().optional(),\n  temperature: z.number().optional(),\n  topK: z.number().optional(),\n  topP: z.number().optional(),\n  frequencyPenalty: z.number().optional(),\n  presencePenalty: z.number().optional(),\n  maxOutputTokens: z.number().optional(),\n  headers: z.record(z.string(), z.string()).optional(),\n});\n\nexport const SessionSchema = z.object({\n  id: z.string(),\n  createdAt: z.number(),\n  updatedAt: z.number(),\n  runId: z.string().nullable(),\n  lastMessageId: z.string().nullable(),\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  system: z.string().nullable(),\n  model: z.string().nullable(),\n  sandboxId: z.string().nullable(),\n  skillsDir: z.array(z.string()).nullable(),\n  hookToken: z.string().nullable(),\n  activeTools: z.array(z.string()).nullable(),\n  generation: GenerationSchema.nullable().default(null),\n});\n\nexport const StepUsageSchema = z.object({\n  stepIndex: z.number(),\n  model: z.string(),\n  inputTokens: z.number(),\n  outputTokens: z.number(),\n  totalTokens: z.number(),\n  cacheReadTokens: z.number(),\n  cacheWriteTokens: z.number(),\n  reasoningTokens: z.number(),\n});\n\nexport const UsageSummarySchema = z.object({\n  model: z.string(),\n  inputTokens: z.number(),\n  outputTokens: z.number(),\n  totalTokens: z.number(),\n  cacheReadTokens: z.number(),\n  cacheWriteTokens: z.number(),\n  reasoningTokens: z.number(),\n  stepCount: z.number(),\n});\n\nexport const MessageUsageSchema = z.object({\n  steps: z.array(StepUsageSchema),\n  summary: UsageSummarySchema,\n});\n\nexport type MessageUsage = z.infer<typeof MessageUsageSchema>;\nexport type UsageSummary = z.infer<typeof UsageSummarySchema>;\nexport type StepUsage = z.infer<typeof StepUsageSchema>;\n\nexport const MessageSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  role: z.enum([\"user\", \"assistant\", \"system\"]),\n  createdAt: z.number(),\n  startedAt: z.number().nullable(),\n  completedAt: z.number().nullable(),\n  interruptedAt: z.number().nullable(),\n  usage: MessageUsageSchema.nullable(),\n});\n\n/**\n * The `part` field corresponds to `UIMessage[\"parts\"][number]` from the `ai` package.\n * We use `z.unknown()` because the exact shape varies by part type (text, tool-call,\n * tool-result, etc.) and may evolve with the AI SDK. The RPC layer just passes it through.\n */\nexport const PartSchema = z.object({\n  id: z.string(),\n  messageId: z.string(),\n  sessionId: z.string(),\n  index: z.number(),\n  part: z.unknown(),\n});\n\nexport const CommandResultSchema = z.object({\n  stdout: z.string(),\n  stderr: z.string(),\n  exitCode: z.number(),\n  completedAt: z.number(),\n});\n\nexport const SandboxRecordSchema = z.object({\n  id: z.string(),\n  config: SandboxConfigSchema,\n  tags: z.record(z.string(), z.unknown()).nullable(),\n  createdAt: z.number().nullable(),\n  lastActivityAt: z.number().nullable(),\n  acquiringLockId: z.string().nullable(),\n  acquiringLockAt: z.number().nullable(),\n  providerMetadata: z\n    .discriminatedUnion(\"provider\", [\n      z.object({\n        provider: z.literal(\"vercel\"),\n        sandboxId: z.string().nullable(),\n        snapshotId: z.string().nullable(),\n      }),\n    ])\n    .optional(),\n});\n\nconst CommandBaseSchema = z.object({\n  id: z.string(),\n  sessionId: z.string(),\n  command: z.string(),\n  args: z.array(z.string()).optional(),\n  startedAt: z.number(),\n});\n\nexport const CommandSchema = z.discriminatedUnion(\"status\", [\n  CommandBaseSchema.extend({ status: z.literal(\"running\") }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"completed\"),\n    result: CommandResultSchema,\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"killed\"),\n    result: CommandResultSchema.optional(),\n  }),\n  CommandBaseSchema.extend({\n    status: z.literal(\"failed\"),\n    result: CommandResultSchema,\n  }),\n]);\n\nfunction ListResultSchema<T extends z.ZodTypeAny>(itemSchema: T) {\n  return z.object({\n    items: z.array(itemSchema),\n    nextCursor: z.string().nullable(),\n  });\n}\n\nconst methods = {\n  \"session.get\": {\n    params: z.object({ id: z.string() }),\n    result: SessionSchema.nullable(),\n  },\n  \"session.set\": {\n    params: SessionSchema,\n    result: SessionSchema,\n  },\n  \"session.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.listBySandbox\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"updatedAt_asc\",\n          \"updatedAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SessionSchema),\n  },\n  \"session.tag.set\": {\n    params: z.object({\n      sessionId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SessionSchema,\n  },\n  \"message.get\": {\n    params: z.object({ id: z.string() }),\n    result: MessageSchema.nullable(),\n  },\n  \"message.set\": {\n    params: MessageSchema,\n    result: MessageSchema,\n  },\n  \"message.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(MessageSchema),\n  },\n  \"part.listByMessage\": {\n    params: z.object({\n      messageId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.listBySession\": {\n    params: z.object({\n      sessionId: z.string(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(PartSchema),\n  },\n  \"part.set\": {\n    params: PartSchema,\n    result: PartSchema,\n  },\n  \"part.delete\": {\n    params: z.object({ id: z.string() }),\n    result: z.void(),\n  },\n  \"sandbox.get\": {\n    params: z.object({ key: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.getBySession\": {\n    params: z.object({ sessionId: z.string() }),\n    result: SandboxRecordSchema.nullable(),\n  },\n  \"sandbox.set\": {\n    params: SandboxRecordSchema,\n    result: z.void(),\n  },\n  \"sandbox.list\": {\n    params: z.object({\n      tags: z.record(z.string(), z.unknown()).optional(),\n      order: z\n        .enum([\n          \"createdAt_asc\",\n          \"createdAt_desc\",\n          \"lastActivityAt_asc\",\n          \"lastActivityAt_desc\",\n        ])\n        .optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(SandboxRecordSchema),\n  },\n  \"sandbox.tag.set\": {\n    params: z.object({\n      sandboxId: z.string(),\n      tags: z.record(z.string(), z.unknown()),\n    }),\n    result: SandboxRecordSchema,\n  },\n  \"command.get\": {\n    params: z.object({ id: z.string() }),\n    result: CommandSchema.nullable(),\n  },\n  \"command.set\": {\n    params: CommandSchema,\n    result: CommandSchema,\n  },\n  \"command.list\": {\n    params: z.object({\n      sessionId: z.string(),\n      includeFinished: z.boolean().optional(),\n      cursor: z.string().optional(),\n      limit: z.number().optional(),\n    }),\n    result: ListResultSchema(CommandSchema),\n  },\n} as const;\n\nexport { methods };\nexport type StorageMethods = typeof methods;\nexport type MethodName = keyof StorageMethods;\nexport const STORAGE_RPC_METHODS = Object.keys(methods) as MethodName[];\n", "import type { z } from \"zod\";\nimport { type MethodName, methods, type StorageMethods } from \"./rpc\";\n\nexport type Handlers = {\n  [K in MethodName]: (\n    params: z.infer<StorageMethods[K][\"params\"]>\n  ) => Promise<z.infer<StorageMethods[K][\"result\"]>>;\n};\n\nexport type RpcRequest = {\n  method: string;\n  params: unknown;\n};\n\nexport type RpcSuccessResponse<T = unknown> = {\n  result: T;\n};\n\nexport type RpcErrorResponse = {\n  error: { code: string; message: string };\n};\n\nexport type RpcResponse<T = unknown> = RpcSuccessResponse<T> | RpcErrorResponse;\n\nexport async function handleStorageRpc(\n  body: RpcRequest,\n  handlers: Handlers\n): Promise<RpcResponse> {\n  const { method, params } = body;\n\n  if (!(method in methods)) {\n    return {\n      error: { code: \"METHOD_NOT_FOUND\", message: `Unknown method: ${method}` },\n    };\n  }\n\n  const methodName = method as MethodName;\n  const schema = methods[methodName].params;\n  const parsed = schema.safeParse(params);\n\n  if (!parsed.success) {\n    return {\n      error: {\n        code: \"INVALID_PARAMS\",\n        message: parsed.error.issues\n          .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n          .join(\", \"),\n      },\n    };\n  }\n\n  try {\n    const handler = handlers[methodName] as (\n      params: unknown\n    ) => Promise<unknown>;\n    const result = await handler(parsed.data);\n    return { result };\n  } catch (e) {\n    return {\n      error: {\n        code: \"INTERNAL_ERROR\",\n        message: e instanceof Error ? e.message : String(e),\n      },\n    };\n  }\n}\n", "export {\n  DEFAULT_NAMESPACE,\n  getStorage,\n  LOCAL_STORAGE_VERSION,\n  type RpcFn,\n} from \"./client\";\nexport {\n  type Handlers,\n  handleStorageRpc,\n  type RpcErrorResponse,\n  type RpcRequest,\n  type RpcResponse,\n  type RpcSuccessResponse,\n} from \"./handler\";\nexport {\n  type MessageUsage,\n  type MethodName,\n  type SandboxConfig,\n  STORAGE_RPC_METHODS,\n  type StepUsage,\n  type StorageMethods,\n  type UsageSummary,\n} from \"./rpc\";\nexport type {\n  Command,\n  ListResult,\n  Message,\n  Part,\n  ResolvedStorage,\n  SandboxRecord,\n  Session,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n", "import type { SandboxLifecycleInput } from \"../types\";\n\nconst DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;\nconst SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1000;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\nexport type LifecycleStepResult =\n  | { action: \"continue\"; nextPollMs: number }\n  | {\n      action: \"exit\";\n      reason: \"sandboxId_changed\" | \"idle\" | \"timeout\" | \"not_found\";\n    };\n\nexport async function checkAndSnapshotStep(\n  input: SandboxLifecycleInput\n): Promise<Error | LifecycleStepResult> {\n  \"use step\";\n\n  const { Sandbox: VercelSandboxSDK } = await import(\"./vercel-sdk\");\n  const { getStorage } = await import(\"../../storage\");\n  const storage = getStorage({\n    config: input.storageConfig,\n    rpc: input.rpc,\n  });\n  const record = await storage.sandbox.get(input.id);\n  if (record instanceof Error) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const currentSandboxId =\n    record.providerMetadata?.provider === \"vercel\"\n      ? record.providerMetadata.sandboxId\n      : null;\n\n  if (currentSandboxId !== input.vercelSandboxId) {\n    return { action: \"exit\", reason: \"sandboxId_changed\" };\n  }\n\n  if (!currentSandboxId) {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const config = record.config;\n  if (config.type !== \"vercel\") {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const pollIntervalMs =\n    config.lifecycle?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const idleTimeoutMs =\n    config.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n  const snapshotBeforeTimeoutMs =\n    config.lifecycle?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;\n\n  const now = Date.now();\n  const lastActivity = record.lastActivityAt ?? record.createdAt ?? now;\n  const idleDuration = now - lastActivity;\n  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;\n\n  let shouldSnapshotDueToTimeout = false;\n  try {\n    const sandbox = await VercelSandboxSDK.get({\n      sandboxId: currentSandboxId,\n      ...getTestCredentials(),\n    });\n    if (sandbox.timeout < snapshotBeforeTimeoutMs) {\n      shouldSnapshotDueToTimeout = true;\n    }\n  } catch {\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {\n    try {\n      const sandbox = await VercelSandboxSDK.get({\n        sandboxId: currentSandboxId,\n        ...getTestCredentials(),\n      });\n      const snapshot = await sandbox.snapshot();\n      await storage.sandbox.set({\n        ...record,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: snapshot.snapshotId,\n        },\n      });\n    } catch (e) {\n      return e instanceof Error ? e : new Error(String(e));\n    }\n    return {\n      action: \"exit\",\n      reason: shouldSnapshotDueToIdle ? \"idle\" : \"timeout\",\n    };\n  }\n\n  return { action: \"continue\", nextPollMs: pollIntervalMs };\n}\n", "import { sleep } from \"workflow\";\nimport type { SandboxLifecycleInput } from \"../types\";\nimport { checkAndSnapshotStep } from \"./lifecycle-workflow-steps\";\n\nexport type { SandboxLifecycleInput };\n\nconst DEFAULT_POLL_MS = 2 * 60 * 1000;\n\nexport async function sandboxLifecycleWorkflow({\n  input,\n}: {\n  input: SandboxLifecycleInput;\n}) {\n  \"use workflow\";\n\n  let nextPollMs = DEFAULT_POLL_MS;\n\n  while (true) {\n    await sleep(nextPollMs);\n\n    const result = await checkAndSnapshotStep(input);\n\n    if (result instanceof Error || result.action === \"exit\") {\n      break;\n    }\n\n    nextPollMs = result.nextPollMs;\n  }\n}\n", "import * as errore from \"errore\";\nimport { Sandbox as VercelSandboxSDK } from \"sandbox\";\nimport { start } from \"workflow/api\";\nimport { SandboxError, SandboxNotFoundError } from \"../../errors\";\nimport type { TagsSchema } from \"../../index\";\nimport type {\n  RpcFn,\n  SandboxRecord,\n  Storage,\n  StorageConfig,\n} from \"../../storage\";\nimport type {\n  LogEntry,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxLifecycleInput,\n  SandboxStatus,\n} from \"../types\";\nimport { writeFiles } from \"../write-files\";\nimport { sandboxLifecycleWorkflow } from \"./lifecycle-workflow\";\n\nexport type VercelSandboxCreateOptions = Extract<\n  Parameters<typeof VercelSandboxSDK.create>[0],\n  // biome-ignore lint/complexity/noBannedTypes: .\n  {}\n>;\n\nexport const VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1000; // 5 hours\nconst LOCK_TIMEOUT_MS = 2 * 60 * 1000; // 2 minutes - if lock older than this, consider it stale\nconst LOCK_POLL_INTERVAL_MS = 200;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\n/**\n * Module-level cache for in-flight sandbox creation promises.\n * Prevents parallel requests within the same process from creating duplicate sandboxes.\n */\nconst createPromises = new Map<string, Promise<SandboxError | string>>();\n\nconst ACTIVITY_THROTTLE_MS = 10_000;\nconst lastActivitySent = new Map<string, number>();\n\nconst DEFAULT_VCPUS = 2;\n\nfunction isSandboxGoneError(e: unknown): boolean {\n  if (!(e instanceof Error)) {\n    return false;\n  }\n\n  const errorWithResponse = e as { response?: { status?: number } };\n  const errorWithCause = e as { cause?: { response?: { status?: number } } };\n\n  const status =\n    errorWithResponse.response?.status ??\n    errorWithCause.cause?.response?.status;\n\n  if (status === 410 || status === 422) {\n    return true;\n  }\n\n  const message = e.message || String(e);\n  if (\n    message.includes(\"Expected a stream of command data\") ||\n    message.includes(\"Expected a stream of logs\")\n  ) {\n    return true;\n  }\n\n  return false;\n}\n\nexport const vercelSandbox = <TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  enableLifecycleWorkflow,\n  storage,\n  rpc,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"vercel\" } };\n  storageConfig: StorageConfig;\n  enableLifecycleWorkflow: boolean;\n  storage: Storage;\n  rpc: RpcFn;\n}): Sandbox<TTags> => {\n  const { id, config } = sandboxRecord;\n  const vcpus = config.resources?.vcpus ?? DEFAULT_VCPUS;\n  const ports = config.ports;\n  const initialVercel =\n    sandboxRecord.providerMetadata?.provider === \"vercel\"\n      ? sandboxRecord.providerMetadata\n      : null;\n\n  type SandboxInstance = Awaited<ReturnType<typeof VercelSandboxSDK.get>>;\n  let sandboxPromise: Promise<SandboxError | SandboxInstance> | null = null;\n  let recoveredFromStale = false;\n  const HOME_DIR = \"/home/vercel-sandbox\";\n\n  async function pollForSandboxId(): Promise<SandboxError | string> {\n    const deadline = Date.now() + LOCK_TIMEOUT_MS;\n    while (Date.now() < deadline) {\n      await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));\n      const record = await storage.sandbox.get(id);\n      if (record instanceof Error) {\n        return new SandboxError({ reason: record.message, cause: record });\n      }\n      const vercelSandboxId =\n        record?.providerMetadata?.provider === \"vercel\"\n          ? record.providerMetadata.sandboxId\n          : null;\n      if (vercelSandboxId) {\n        return vercelSandboxId;\n      }\n      if (!record?.acquiringLockAt) {\n        const finalCheck = await storage.sandbox.get(id);\n        if (finalCheck instanceof Error) {\n          return new SandboxError({\n            reason: finalCheck.message,\n            cause: finalCheck,\n          });\n        }\n        const finalVercelSandboxId =\n          finalCheck?.providerMetadata?.provider === \"vercel\"\n            ? finalCheck.providerMetadata.sandboxId\n            : null;\n        if (finalVercelSandboxId) {\n          return finalVercelSandboxId;\n        }\n        return doGetOrCreateSandboxId();\n      }\n    }\n    return new SandboxError({\n      reason: \"Timed out waiting for sandbox creation by another process\",\n    });\n  }\n\n  async function startLifecycleWorkflow(\n    vercelSandboxId: string\n  ): Promise<void> {\n    if (!enableLifecycleWorkflow) {\n      return;\n    }\n    const lifecycleInput: SandboxLifecycleInput = {\n      id,\n      vercelSandboxId,\n      storageConfig,\n      rpc,\n    };\n    await start(sandboxLifecycleWorkflow, [{ input: lifecycleInput }]).catch(\n      // biome-ignore lint/suspicious/noEmptyBlockStatements: intentionally ignored - workflow start is fire-and-forget\n      () => {}\n    );\n  }\n\n  async function createSandboxFromSnapshot(\n    snapshotId: string\n  ): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          source: { type: \"snapshot\", snapshotId },\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function createFreshSandbox(): Promise<SandboxError | string> {\n    return await errore.tryAsync({\n      try: async () => {\n        const sandbox = await VercelSandboxSDK.create({\n          resources: { vcpus },\n          timeout: VERCEL_MAX_TIMEOUT_MS,\n          ports,\n          ...getTestCredentials(),\n        });\n        const now = Date.now();\n        await storage.sandbox.set({\n          id,\n          config,\n          tags: sandboxRecord.tags,\n          createdAt: now,\n          lastActivityAt: now,\n          acquiringLockId: null,\n          acquiringLockAt: null,\n          providerMetadata: {\n            provider: \"vercel\",\n            sandboxId: sandbox.sandboxId,\n            snapshotId: null,\n          },\n        });\n        await startLifecycleWorkflow(sandbox.sandboxId);\n        return sandbox.sandboxId;\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  async function doGetOrCreateSandboxId(): Promise<SandboxError | string> {\n    if (initialVercel?.sandboxId && !recoveredFromStale) {\n      return initialVercel.sandboxId;\n    }\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error) {\n      if (existing instanceof SandboxNotFoundError) {\n        // Sandbox doesn't exist yet, continue with creation\n      } else {\n        return new SandboxError({ reason: existing.message, cause: existing });\n      }\n    }\n\n    const existingRecord =\n      existing instanceof SandboxNotFoundError ? null : existing;\n    const existingVercel =\n      existingRecord?.providerMetadata?.provider === \"vercel\"\n        ? existingRecord.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      return existingVercel.sandboxId;\n    }\n\n    const hasActiveLock =\n      existingRecord?.acquiringLockId &&\n      existingRecord.acquiringLockAt &&\n      Date.now() - existingRecord.acquiringLockAt < LOCK_TIMEOUT_MS;\n\n    if (hasActiveLock) {\n      return pollForSandboxId();\n    }\n\n    const lockId = crypto.randomUUID();\n    const now = Date.now();\n    await storage.sandbox.set({\n      id,\n      config,\n      tags: existingRecord?.tags ?? sandboxRecord.tags,\n      createdAt: existingRecord?.createdAt ?? sandboxRecord.createdAt,\n      lastActivityAt:\n        existingRecord?.lastActivityAt ?? sandboxRecord.lastActivityAt,\n      acquiringLockId: lockId,\n      acquiringLockAt: now,\n      providerMetadata: {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId:\n          existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null,\n      },\n    });\n\n    const afterLock = await storage.sandbox.get(id);\n    if (afterLock instanceof Error) {\n      return new SandboxError({ reason: afterLock.message, cause: afterLock });\n    }\n    if (afterLock?.acquiringLockId !== lockId) {\n      return pollForSandboxId();\n    }\n\n    const snapshotId =\n      existingVercel?.snapshotId ??\n      initialVercel?.snapshotId ??\n      config.lifecycle?.snapshotId;\n    if (snapshotId) {\n      const result = await createSandboxFromSnapshot(snapshotId);\n      if (!(result instanceof Error)) {\n        return result;\n      }\n    }\n\n    return createFreshSandbox();\n  }\n\n  function getOrCreateSandboxId(): Promise<SandboxError | string> {\n    const cached = createPromises.get(id);\n    if (cached) {\n      return cached;\n    }\n\n    const promise = doGetOrCreateSandboxId().finally(() => {\n      createPromises.delete(id);\n    });\n    createPromises.set(id, promise);\n    return promise;\n  }\n\n  async function doGetSandbox(): Promise<SandboxError | SandboxInstance> {\n    const vercelSandboxId = await getOrCreateSandboxId();\n    if (vercelSandboxId instanceof Error) {\n      return vercelSandboxId;\n    }\n\n    return errore.tryAsync({\n      try: () =>\n        VercelSandboxSDK.get({\n          sandboxId: vercelSandboxId,\n          ...getTestCredentials(),\n        }),\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n  }\n\n  function getSandbox(): Promise<SandboxError | SandboxInstance> {\n    if (!sandboxPromise) {\n      sandboxPromise = doGetSandbox();\n    }\n    return sandboxPromise;\n  }\n\n  async function recoverFromStaleSandbox(): Promise<void> {\n    sandboxPromise = null;\n    recoveredFromStale = true;\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      await storage.sandbox.set({\n        id: existing.id,\n        config: existing.config,\n        tags: existing.tags,\n        createdAt: existing.createdAt,\n        lastActivityAt: existing.lastActivityAt,\n        acquiringLockId: null,\n        acquiringLockAt: null,\n        providerMetadata: {\n          provider: \"vercel\",\n          sandboxId: null,\n          snapshotId: existingVercel.snapshotId,\n        },\n      });\n    }\n  }\n\n  async function updateLastActivity(): Promise<void> {\n    const now = Date.now();\n    const lastSent = lastActivitySent.get(id);\n    if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {\n      return;\n    }\n    lastActivitySent.set(id, now);\n\n    const existing = await storage.sandbox.get(id);\n    if (existing instanceof Error || !existing) {\n      return;\n    }\n    const existingVercel =\n      existing.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n    await storage.sandbox.set({\n      id: existing.id,\n      config: existing.config,\n      tags: existing.tags,\n      createdAt: existing.createdAt,\n      lastActivityAt: now,\n      acquiringLockId: null,\n      acquiringLockAt: null,\n      providerMetadata: existingVercel ?? {\n        provider: \"vercel\",\n        sandboxId: null,\n        snapshotId: null,\n      },\n    });\n  }\n\n  const lifecycle: SandboxLifecycle = {\n    start: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      await updateLastActivity();\n      return sandbox.status as SandboxStatus;\n    },\n\n    snapshot: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          const existing = await storage.sandbox.get(id);\n          const snapshot = await sandbox.snapshot();\n          await storage.sandbox.set({\n            id,\n            config,\n            tags: existing instanceof Error ? null : (existing?.tags ?? null),\n            createdAt:\n              existing instanceof Error ? null : (existing?.createdAt ?? null),\n            lastActivityAt:\n              existing instanceof Error\n                ? null\n                : (existing?.lastActivityAt ?? null),\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: snapshot.snapshotId,\n            },\n          });\n          return { snapshotId: snapshot.snapshotId };\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    stop: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      return errore.tryAsync({\n        try: async () => {\n          await sandbox.stop();\n          const existing = await storage.sandbox.get(id);\n          if (existing instanceof Error || !existing) {\n            return undefined;\n          }\n          await storage.sandbox.set({\n            id: existing.id,\n            config: existing.config,\n            tags: existing.tags,\n            createdAt: existing.createdAt,\n            lastActivityAt: existing.lastActivityAt,\n            acquiringLockId: null,\n            acquiringLockAt: null,\n            providerMetadata: {\n              provider: \"vercel\",\n              sandboxId: null,\n              snapshotId: null,\n            },\n          });\n          return undefined;\n        },\n        catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n      });\n    },\n\n    getStatus: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.status as SandboxStatus;\n    },\n\n    getCreatedAt: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.createdAt;\n    },\n\n    getRemainingTimeout: async () => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n      return sandbox.timeout;\n    },\n  };\n\n  async function doExec({\n    command,\n    args,\n    signal,\n  }: {\n    command: string;\n    args?: string[];\n    signal?: AbortSignal;\n  }): Promise<\n    | SandboxError\n    | {\n        commandId: string;\n        logs: () => AsyncIterable<LogEntry>;\n        result: Promise<{ stdout: string; stderr: string; exitCode: number }>;\n      }\n  > {\n    const instance = await getSandbox();\n    if (instance instanceof Error) {\n      return instance;\n    }\n\n    const updatePromise = updateLastActivity();\n\n    /**\n     * detached: true makes runCommand return immediately with a Command handle\n     * instead of blocking until the process exits. This is critical for\n     * long-running commands where the caller needs to interact with the process\n     * (e.g. reading logs and writing files) while it's still running.\n     */\n    const execResult = await errore.tryAsync({\n      try: async () => {\n        const output = await instance.runCommand({\n          cwd: HOME_DIR,\n          args,\n          cmd: command,\n          signal,\n          detached: true,\n        });\n\n        let stdout = \"\";\n        let stderr = \"\";\n        const logBuffer: LogEntry[] = [];\n        const state = {\n          resolve: null as (() => void) | null,\n          consumed: false,\n        };\n\n        const consumeLogs = (async () => {\n          try {\n            for await (const log of output.logs()) {\n              const entry: LogEntry =\n                log.stream === \"stdout\"\n                  ? { stream: \"stdout\", data: log.data }\n                  : { stream: \"stderr\", data: log.data };\n\n              if (log.stream === \"stdout\") {\n                stdout += log.data;\n              } else {\n                stderr += log.data;\n              }\n\n              logBuffer.push(entry);\n              state.resolve?.();\n            }\n          } catch {\n            // Sandbox may have been stopped - logs endpoint returns 422\n          }\n          state.consumed = true;\n          state.resolve?.();\n        })();\n\n        async function* logs(): AsyncIterable<LogEntry> {\n          let index = 0;\n          while (!state.consumed || index < logBuffer.length) {\n            if (index < logBuffer.length) {\n              yield logBuffer[index++];\n            } else {\n              await new Promise<void>((resolve) => {\n                state.resolve = resolve;\n              });\n              state.resolve = null;\n            }\n          }\n        }\n\n        const result = consumeLogs.then(async () => {\n          try {\n            const finished = await output.wait();\n            return {\n              stdout,\n              stderr,\n              exitCode: finished.exitCode,\n            };\n          } catch (e) {\n            if (isSandboxGoneError(e)) {\n              return { stdout, stderr, exitCode: 1 };\n            }\n            throw e;\n          }\n        });\n\n        return { commandId: output.cmdId, logs, result };\n      },\n      catch: (e) => new SandboxError({ reason: String(e), cause: e }),\n    });\n\n    await updatePromise;\n    return execResult;\n  }\n\n  const sandbox: Sandbox<TTags> = {\n    id,\n    config,\n    exec: async (opts) => {\n      const result = await doExec(opts);\n\n      if (result instanceof SandboxError && isSandboxGoneError(result.cause)) {\n        await recoverFromStaleSandbox();\n        return await doExec(opts);\n      }\n\n      return result;\n    },\n\n    getDomain: async (port) => {\n      const sandbox = await getSandbox();\n      if (sandbox instanceof Error) {\n        return sandbox;\n      }\n\n      try {\n        return sandbox.domain(port);\n      } catch (e) {\n        return new SandboxError({ reason: String(e), cause: e });\n      }\n    },\n\n    kill: async ({ commandId, storage: cmdStorage }) => {\n      const instance = await getSandbox();\n      if (instance instanceof Error) {\n        return instance;\n      }\n\n      const cmd = await cmdStorage.command.get(commandId);\n      if (cmd instanceof Error) {\n        return new SandboxError({ reason: cmd.message, cause: cmd });\n      }\n      if (cmd && cmd.status === \"running\") {\n        const result = await cmdStorage.command.set({\n          ...cmd,\n          status: \"killed\",\n        });\n        if (result instanceof Error) {\n          return new SandboxError({ reason: result.message, cause: result });\n        }\n      }\n      return undefined;\n    },\n\n    writeFiles: (opts) => writeFiles({ sandbox, ...opts }),\n\n    lifecycle,\n\n    tag: {\n      list: async () => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return (sandboxRecord.tags ?? {}) as TTags;\n      },\n      get: async (key: string) => {\n        const sandboxRecord = await storage.sandbox.get(id);\n        if (sandboxRecord instanceof Error) {\n          return sandboxRecord;\n        }\n        return sandboxRecord.tags?.[key as string] as\n          | TTags[typeof key]\n          | undefined;\n      },\n      set: async (key: string, value: unknown) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: { [key]: value } as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n      setMany: async (tags: Record<string, unknown>) => {\n        const result = await storage.sandbox.tag.set({\n          sandboxId: id,\n          tags: tags as Record<string, unknown>,\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      },\n    },\n  };\n\n  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n  }\n\n  return sandbox;\n};\n", "import type { TagsSchema } from \"../index\";\nimport type { RpcFn, SandboxRecord, Storage, StorageConfig } from \"../storage\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { Sandbox } from \"./types\";\n\nexport function getSandbox<TTags extends TagsSchema = TagsSchema>({\n  sandboxRecord,\n  storageConfig,\n  storage,\n  rpc,\n  enableLifecycleWorkflow = true,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n  storage: Storage;\n  rpc: RpcFn;\n  enableLifecycleWorkflow?: boolean;\n}): Sandbox<TTags> {\n  switch (sandboxRecord.config.type) {\n    case \"local\":\n      return localSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storage,\n      });\n    case \"vercel\":\n      return vercelSandbox<TTags>({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"vercel\" };\n        },\n        storageConfig,\n        storage,\n        rpc,\n        enableLifecycleWorkflow,\n      });\n    case \"custom\":\n      throw new Error(\"Custom sandboxes are not supported\");\n    default:\n      sandboxRecord.config satisfies never;\n      throw new Error(\n        `Unknown sandbox type: ${\n          // biome-ignore lint/suspicious/noExplicitAny: .\n          (sandboxRecord.config as any).type\n        }`\n      );\n  }\n}\n", "export { getSandbox } from \"./client\";\nexport type {\n  ExecResult,\n  LogEntry,\n  Sandbox,\n  SandboxLifecycle,\n  SandboxLifecycleInput,\n  SandboxStatus,\n  Terminal,\n  TerminalMetadata,\n  VercelSandboxLifecycleConfig,\n} from \"./types\";\n", "import type { FinishReason } from \"ai\";\nimport { defineHook, FatalError, getWritable } from \"workflow\";\nimport { completeMessageStep, streamTextStep } from \"./agent-workflow-steps\";\nimport type { RpcPayload, RpcResult } from \"./client\";\nimport type { StorageConfig } from \"./storage\";\nimport type { StepUsage } from \"./utils/usage\";\n\nexport type AgentInput = {\n  sessionId: string;\n  storageConfig: StorageConfig;\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n};\n\nexport type AgentMessageInput = {\n  assistantMessageId: string;\n  hookToken: string;\n  createdAt: number;\n  context: Record<string, unknown>;\n};\n\nexport type ApprovalResponse = {\n  approved: boolean;\n  reason?: string;\n};\n\nexport const agentMessageHook = defineHook<AgentMessageInput>();\nexport const approvalHook = defineHook<ApprovalResponse>();\n\nexport async function agentWorkflow({\n  input,\n  event,\n}: {\n  input: AgentInput;\n  event: AgentMessageInput;\n}) {\n  \"use workflow\";\n\n  const messageHook = agentMessageHook.create({ token: input.sessionId });\n  const iterator = messageHook[Symbol.asyncIterator]();\n  let pendingNext = iterator.next();\n\n  await onMessage({ event, input }).catch((e) => {\n    if (FatalError.is(e)) {\n      console.error(\"Message processing failed permanently:\", e.message);\n      return;\n    }\n    throw e;\n  });\n\n  while (true) {\n    const result = await pendingNext;\n\n    if (result.done) {\n      console.error(\"Unexpected: message hook iterator done\");\n      break;\n    }\n\n    await onMessage({ event: result.value, input }).catch((e) => {\n      if (FatalError.is(e)) {\n        console.error(\"Message processing failed permanently:\", e.message);\n        return;\n      }\n      throw e;\n    });\n    pendingNext = iterator.next();\n  }\n}\n\nasync function onMessage({\n  event,\n  input,\n}: {\n  event: AgentMessageInput;\n  input: AgentInput;\n}) {\n  const writable = getWritable({ namespace: event.assistantMessageId });\n\n  let finishReason: FinishReason | undefined;\n  let lastPartIndex = 0;\n  const usageSteps: StepUsage[] = [];\n\n  while (finishReason !== \"stop\") {\n    try {\n      const result = await streamTextStep({\n        assistantMessageId: event.assistantMessageId,\n        writable,\n        input,\n        event,\n        lastPartIndex,\n        stepIndexOffset: usageSteps.length,\n      });\n      finishReason = result.finishReason;\n      lastPartIndex = result.lastPartIndex;\n      usageSteps.push(...result.usageSteps);\n\n      if (result.maxSteps != null && usageSteps.length >= result.maxSteps) {\n        break;\n      }\n\n      // If tools need approval, suspend workflow until all are resolved\n      if (result.pendingApprovals.length > 0) {\n        await Promise.all(\n          result.pendingApprovals.map((pending) => {\n            const hook = approvalHook.create({ token: pending.approvalId });\n            const iter = hook[Symbol.asyncIterator]();\n            return iter.next();\n          })\n        );\n        // All hooks resolved \u2014 approval responses are now in storage.\n        // Loop continues \u2192 next streamTextStep reads updated parts.\n      }\n    } catch (err) {\n      console.error(err);\n      throw err;\n    }\n  }\n\n  await completeMessageStep({\n    assistantMessageId: event.assistantMessageId,\n    input,\n    writable,\n    usageSteps,\n  });\n}\n", "import {\n  convertToModelMessages,\n  createUIMessageStream,\n  type FinishReason,\n  stepCountIs,\n  streamText,\n  type UIMessage,\n} from \"ai\";\nimport { ulid } from \"ulid\";\nimport { FatalError } from \"workflow\";\nimport type { AgentInput, AgentMessageInput } from \"./agent-workflow\";\nimport { discoverSkillsInSandbox } from \"./skills/discover\";\nimport type { SkillSummary } from \"./skills/types\";\nimport type { SandboxRecord, Storage } from \"./storage\";\nimport { fetchApiToolsMetadata, getTools } from \"./tools\";\nimport type { OnSubToolCall } from \"./tools/javascript\";\nimport { applyPromptCachingToModelRequest } from \"./utils/prompt-cache\";\nimport { assembleUIMessages } from \"./utils/ui\";\nimport { computeUsageSummary, type StepUsage } from \"./utils/usage\";\n\nconst BASE_SYSTEM_PROMPT =\n  \"You are an AI assistant with basic tools to interact with your environment. Explore and work freely.\";\n\nfunction joinPromptSections(\n  ...sections: (string | undefined | null)[]\n): string {\n  return sections.filter((s) => s?.trim()).join(\"\\n\\n\");\n}\n\nconst backgroundProcessPrompt = `## Background Processes\nThese background process instructions are for you to manipulate the processes, do not be to verbose to the user about the response details like \"how to debug the process output\" the user will have an UI.\n\nUse \\`waitUntil: 0\\` for dev servers that should run indefinitely.\nIt is a good practice to check the output log after running processes like dev servers to make sure they started correctly.\n\nTo run a background process:\nBash({ command: \"npm run dev\", waitUntil: 0 })\nReturns immediately with \\`pid\\` and \\`outputFile\\` path.\n\nTo check a process's output:\nBash({ command: \"tail -100 {outputFile}\" })\n\nTo kill a process:\nBash({ command: \"kill {pid}\" })       // Graceful\nBash({ command: \"kill -9 {pid}\" })    // Force\n\nTo list all processes:\nBash({ command: \"ps aux | grep node\" })\n`;\n\nfunction buildSkillsContext(skills: SkillSummary[]): string {\n  if (skills.length === 0) {\n    return \"\";\n  }\n\n  const skillLines = skills\n    .map((s) => `- ${s.name}: ${s.description}\\n  Path: ${s.skillMdPath}`)\n    .join(\"\\n\");\n\n  return `## Available Skills\n${skillLines}\n\n${backgroundProcessPrompt}\n\nYou can use the Read tool to read any skill's SKILL.md file to learn more about it.`;\n}\n\nexport async function completeMessageStep({\n  assistantMessageId,\n  input,\n  writable,\n  usageSteps,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  writable: WritableStream;\n  usageSteps: StepUsage[];\n}) {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const storage = getStorage({ config: input.storageConfig, rpc: input.rpc });\n\n  const message = await storage.message.get(assistantMessageId);\n  if (message instanceof Error) {\n    throw message;\n  }\n  if (!message) {\n    throw new Error(`Message ${assistantMessageId} not found`);\n  }\n\n  const usage =\n    usageSteps.length > 0\n      ? {\n          steps: usageSteps,\n          summary: computeUsageSummary(usageSteps),\n        }\n      : null;\n\n  const result = await storage.message.set({\n    ...message,\n    completedAt: Date.now(),\n    usage,\n  });\n  if (result instanceof Error) {\n    throw result;\n  }\n\n  await writable.close();\n}\n\nconst INTERRUPT_POLL_INTERVAL_MS = 500;\n\nfunction pollForInterrupt({\n  storage,\n  messageId,\n  signal,\n  abortController,\n}: {\n  storage: Storage;\n  messageId: string;\n  signal: AbortSignal;\n  abortController: AbortController;\n}): { firstCheck: Promise<void> } {\n  let resolveFirstCheck: () => void;\n  const firstCheck = new Promise<void>((resolve) => {\n    resolveFirstCheck = resolve;\n  });\n\n  const poll = async () => {\n    let isFirst = true;\n    while (!signal.aborted) {\n      const message = await storage.message.get(messageId);\n      if (message instanceof Error) {\n        if (isFirst) {\n          resolveFirstCheck();\n        }\n        return;\n      }\n      if (message.interruptedAt !== null) {\n        abortController.abort();\n        if (isFirst) {\n          resolveFirstCheck();\n        }\n        return;\n      }\n      if (isFirst) {\n        isFirst = false;\n        resolveFirstCheck();\n      }\n      await new Promise((resolve) =>\n        setTimeout(resolve, INTERRUPT_POLL_INTERVAL_MS)\n      );\n    }\n  };\n\n  poll();\n  return { firstCheck };\n}\n\nexport async function streamTextStep({\n  assistantMessageId,\n  input,\n  event,\n  writable,\n  lastPartIndex,\n  stepIndexOffset,\n}: {\n  assistantMessageId: string;\n  input: AgentInput;\n  event: AgentMessageInput;\n  writable: WritableStream;\n  lastPartIndex: number;\n  stepIndexOffset: number;\n}): Promise<{\n  finishReason: FinishReason;\n  lastPartIndex: number;\n  usageSteps: StepUsage[];\n  pendingApprovals: { approvalId: string; toolName: string }[];\n  maxSteps: number | undefined;\n}> {\n  \"use step\";\n\n  const { getStorage } = await import(\"./storage/client\");\n  const { getSandbox } = await import(\"./sandbox\");\n\n  const storage = getStorage({ config: input.storageConfig, rpc: input.rpc });\n\n  const abortController = new AbortController();\n  const pollController = new AbortController();\n\n  const { firstCheck } = pollForInterrupt({\n    storage,\n    messageId: assistantMessageId,\n    signal: pollController.signal,\n    abortController,\n  });\n\n  const [\n    ,\n    messagesResult,\n    partsResult,\n    { session, skills, sandbox, sandboxRecord },\n    apiToolsMetadata,\n  ] = await Promise.all([\n    firstCheck,\n    storage.message.list(input.sessionId),\n    storage.part.listBySession(input.sessionId),\n    storage.session.get(input.sessionId).then(async (session) => {\n      if (session instanceof Error) {\n        throw session;\n      }\n      const sandboxRecord = session.sandboxId\n        ? await storage.sandbox.get(session.sandboxId)\n        : null;\n      if (sandboxRecord instanceof Error) {\n        throw sandboxRecord;\n      }\n      if (!sandboxRecord) {\n        throw new FatalError(\n          `Sandbox not found for session ${input.sessionId}`\n        );\n      }\n      const sandbox = getSandbox({\n        sandboxRecord,\n        storageConfig: input.storageConfig,\n        storage,\n        rpc: input.rpc,\n      });\n      const skills = await discoverSkillsInSandbox({\n        sandbox,\n        skillsDirs: session.skillsDir || [],\n        debug: true,\n      });\n      return { session, skills, sandbox, sandboxRecord };\n    }),\n    fetchApiToolsMetadata({\n      rpc: input.rpc,\n    }),\n  ]);\n\n  if (abortController.signal.aborted) {\n    pollController.abort();\n    return {\n      finishReason: \"stop\" as FinishReason,\n      lastPartIndex,\n      usageSteps: [],\n      pendingApprovals: [],\n      maxSteps: undefined,\n    };\n  }\n\n  if (messagesResult instanceof Error) {\n    throw messagesResult;\n  }\n  if (partsResult instanceof Error) {\n    throw partsResult;\n  }\n\n  /**\n   * On first iteration, mark all messages in this batch as started.\n   * User messages are also marked as completed (they're done).\n   * The assistant message is only marked as started (streaming in progress).\n   */\n  const setStartedPromise =\n    lastPartIndex === 0\n      ? (async () => {\n          const now = Date.now();\n          const pendingMessages = messagesResult.items.filter(\n            (m) => m.createdAt <= event.createdAt && m.startedAt === null\n          );\n          if (pendingMessages.length > 0) {\n            return await Promise.all(\n              pendingMessages.map((m) =>\n                storage.message.set({\n                  ...m,\n                  startedAt: now,\n                  completedAt: m.role === \"assistant\" ? null : now,\n                })\n              )\n            );\n          }\n        })()\n      : null;\n\n  // Mutable ref so onSubToolCall can write to the stream once available\n  const streamWriterRef: {\n    current: ((event: unknown) => void) | null;\n  } = { current: null };\n\n  const subToolPartIds: string[] = [];\n  // Shared counter for part indices \u2014 sub-tool parts increment this during\n  // the stream, then stepParts continue from where it left off.\n  let nextPartIndex = lastPartIndex;\n\n  const onSubToolCall: OnSubToolCall = async (toolName, toolInput, execute) => {\n    // Check if this tool needs approval via RPC\n    const res = await input.rpc({\n      method: \"tools.needsApproval\",\n      params: {\n        toolName,\n        input: toolInput,\n        toolCallId: `js_${toolName}_${Date.now()}`,\n        messages: [],\n      },\n    });\n\n    if (\"error\" in res || res.result !== true) {\n      // No approval needed \u2014 just execute\n      try {\n        const result = await execute();\n        return { result };\n      } catch (err) {\n        return { error: err instanceof Error ? err.message : String(err) };\n      }\n    }\n\n    // Approval needed \u2014 surface to user via stream events\n    const approvalId = `js_approval_${ulid()}`;\n    const toolCallId = `js_tc_${ulid()}`;\n    const partId = `part_${ulid()}`;\n    subToolPartIds.push(partId);\n\n    // Store approval-request part\n    await storage.part.set({\n      id: partId,\n      index: nextPartIndex++,\n      messageId: assistantMessageId,\n      sessionId: input.sessionId,\n      part: {\n        type: `tool-${toolName}`,\n        toolCallId,\n        state: \"approval-requested\",\n        input: toolInput,\n        approval: { id: approvalId },\n      } as unknown as UIMessage[\"parts\"][number],\n    });\n\n    // Write stream events for the UI\n    // tool-input-start is required \u2014 the AI SDK client creates the tool part\n    // when it sees this event. Without it, subsequent events are ignored.\n    streamWriterRef.current?.({\n      type: \"tool-input-start\",\n      toolCallId,\n      toolName,\n    });\n    streamWriterRef.current?.({\n      type: \"tool-input-available\",\n      toolCallId,\n      toolName,\n      input: toolInput,\n    });\n    streamWriterRef.current?.({\n      type: \"tool-approval-request\",\n      approvalId,\n      toolCallId,\n    });\n\n    // Poll storage for approval response\n    const POLL_MS = 500;\n    const TIMEOUT_MS = 5 * 60 * 1000;\n    const start = Date.now();\n\n    while (Date.now() - start < TIMEOUT_MS) {\n      const parts = await storage.part.listBySession(input.sessionId);\n      if (!(parts instanceof Error)) {\n        const updated = parts.items.find(\n          (p) =>\n            p.id === partId &&\n            \"state\" in p.part &&\n            (p.part as { state: string }).state === \"approval-responded\"\n        );\n        if (updated) {\n          const approval = (\n            updated.part as {\n              approval?: { approved?: boolean; reason?: string };\n            }\n          ).approval;\n          if (approval?.approved) {\n            try {\n              const result = await execute();\n              streamWriterRef.current?.({\n                type: \"tool-output-available\",\n                toolCallId,\n                output: result,\n              });\n              return { result };\n            } catch (err) {\n              const error = err instanceof Error ? err.message : String(err);\n              streamWriterRef.current?.({\n                type: \"tool-output-error\",\n                toolCallId,\n                errorText: error,\n              });\n              return { error };\n            }\n          }\n          // Denied\n          streamWriterRef.current?.({\n            type: \"tool-output-denied\",\n            toolCallId,\n          });\n          return {\n            error: `Tool \"${toolName}\" denied: ${approval?.reason || \"user denied\"}`,\n          };\n        }\n      }\n      await new Promise((r) => setTimeout(r, POLL_MS));\n    }\n\n    return { error: \"Approval timed out\" };\n  };\n\n  const rawTools = getTools({\n    input,\n    event,\n    sandbox,\n    session,\n    sandboxRecord: sandboxRecord as SandboxRecord,\n    apiToolsMetadata,\n    onSubToolCall,\n  });\n\n  const skillsContext = buildSkillsContext(skills);\n  const systemHeader = joinPromptSections(BASE_SYSTEM_PROMPT, session.system);\n  const systemContext = joinPromptSections(skillsContext);\n\n  if (!session.model) {\n    throw new FatalError(\"Session model is not set\");\n  }\n\n  const systemMessages = [\n    ...(systemHeader.trim()\n      ? [{ role: \"system\" as const, content: systemHeader }]\n      : []),\n    ...(systemContext.trim()\n      ? [{ role: \"system\" as const, content: systemContext }]\n      : []),\n  ];\n\n  // Execute approved tools before building final messages for streamText.\n  // This ensures the model sees complete tool call + result pairs,\n  // and toUIMessageStream won't encounter orphaned tool results.\n  const allParts = partsResult.items;\n  const approvedParts = allParts.filter(\n    (p) =>\n      p.part &&\n      \"state\" in p.part &&\n      (p.part as { state: string }).state === \"approval-responded\" &&\n      \"approval\" in p.part &&\n      (p.part as { approval?: { approved?: boolean } }).approval?.approved ===\n        true\n  );\n\n  const executedApprovals: {\n    toolCallId: string;\n    output: unknown;\n    error?: string;\n  }[] = [];\n\n  if (approvedParts.length > 0) {\n    // Build model messages pre-execution for the tool execute context\n    const preExecMessages = [\n      ...systemMessages,\n      ...(await convertToModelMessages(\n        assembleUIMessages({\n          messages: messagesResult.items,\n          parts: allParts,\n          until: event.createdAt,\n          includeQueued: true,\n          excludeSubToolParts: true,\n        })\n      )),\n    ];\n\n    await Promise.all(\n      approvedParts.map(async (ap) => {\n        if (!ap.part.type.startsWith(\"tool-\")) {\n          return;\n        }\n        const part = ap.part as Extract<\n          UIMessage[\"parts\"][number],\n          { type: `tool-${string}` }\n        >;\n        const toolName = part.type.replace(\"tool-\", \"\");\n        const toolDef = rawTools[toolName];\n\n        if (toolDef?.execute && part.input !== undefined) {\n          try {\n            const toolOutput = await toolDef.execute(part.input, {\n              toolCallId: part.toolCallId,\n              messages: preExecMessages,\n              abortSignal: abortController.signal,\n              experimental_context: {\n                session,\n                sandbox,\n                storage,\n                context: event.context,\n              },\n            });\n            part.state = \"output-available\";\n            part.output = toolOutput;\n            executedApprovals.push({\n              toolCallId: part.toolCallId,\n              output: toolOutput,\n            });\n          } catch (err) {\n            part.state = \"output-error\";\n            part.errorText = err instanceof Error ? err.message : String(err);\n            executedApprovals.push({\n              toolCallId: part.toolCallId,\n              output: undefined,\n              error: err instanceof Error ? err.message : String(err),\n            });\n          }\n          await storage.part.set({ ...ap, part });\n        }\n      })\n    );\n  }\n\n  const uiMessages = assembleUIMessages({\n    messages: messagesResult.items,\n    parts: allParts,\n    until: event.createdAt,\n    includeQueued: true,\n    excludeSubToolParts: true,\n  });\n\n  const modelMessages = [\n    ...systemMessages,\n    ...(await convertToModelMessages(uiMessages)),\n  ];\n\n  const promptCaching = applyPromptCachingToModelRequest({\n    model: session.model,\n    sessionId: input.sessionId,\n    messages: modelMessages,\n  });\n\n  const usageSteps: StepUsage[] = [];\n  let internalStepIndex = 0;\n\n  // Inject needsApproval on every tool \u2014 delegates to the agent client via RPC\n  const tools = Object.fromEntries(\n    Object.entries(rawTools).map(([name, t]) => [\n      name,\n      {\n        ...t,\n        needsApproval: async (\n          toolInput: unknown,\n          opts: { toolCallId: string; messages: unknown[] }\n        ) => {\n          const res = await input.rpc({\n            method: \"tools.needsApproval\",\n            params: {\n              toolName: name,\n              input: toolInput,\n              toolCallId: opts.toolCallId,\n              messages: opts.messages,\n            },\n          });\n          if (\"error\" in res) {\n            throw new Error(\n              `tools.needsApproval RPC failed for ${name}: ${res.error.message}`\n            );\n          }\n          return res.result as boolean;\n        },\n      },\n    ])\n  );\n\n  const result = streamText({\n    messages: promptCaching.messages,\n    tools,\n    model: session.model,\n    abortSignal: abortController.signal,\n    activeTools: session.activeTools ?? undefined,\n    providerOptions: promptCaching.providerOptions,\n    stopWhen: stepCountIs(1),\n    temperature: session.generation?.temperature,\n    topK: session.generation?.topK,\n    topP: session.generation?.topP,\n    frequencyPenalty: session.generation?.frequencyPenalty,\n    presencePenalty: session.generation?.presencePenalty,\n    maxOutputTokens: session.generation?.maxOutputTokens,\n    headers: session.generation?.headers,\n    experimental_context: {\n      session,\n      sandbox,\n      storage,\n      context: event.context,\n    },\n    onStepFinish: ({ usage }) => {\n      if (usage) {\n        usageSteps.push({\n          stepIndex: stepIndexOffset + internalStepIndex,\n          model: session.model ?? \"unknown\",\n          inputTokens: usage.inputTokens ?? 0,\n          outputTokens: usage.outputTokens ?? 0,\n          totalTokens: usage.totalTokens ?? 0,\n          cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,\n          cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,\n          reasoningTokens: usage.outputTokenDetails?.reasoningTokens ?? 0,\n        });\n      }\n      internalStepIndex++;\n    },\n  });\n\n  const stepParts: UIMessage[\"parts\"] = [];\n  let wasAborted = false;\n\n  try {\n    const stream = createUIMessageStream({\n      execute: ({ writer }) => {\n        streamWriterRef.current = (event: unknown) =>\n          writer.write(event as Parameters<typeof writer.write>[0]);\n\n        // Stream tool execution results from approved tools\n        for (const ea of executedApprovals) {\n          if (ea.error) {\n            writer.write({\n              type: \"tool-output-error\",\n              toolCallId: ea.toolCallId,\n              errorText: ea.error,\n            });\n          } else {\n            writer.write({\n              type: \"tool-output-available\",\n              toolCallId: ea.toolCallId,\n              output: ea.output,\n            });\n          }\n        }\n\n        // Merge the streamText continuation\n        writer.merge(\n          result.toUIMessageStream({\n            generateMessageId: () => assistantMessageId,\n            onFinish: ({ messages }) => {\n              for (const m of messages) {\n                if (m.role === \"assistant\") {\n                  stepParts.push(...m.parts);\n                }\n              }\n            },\n          })\n        );\n      },\n    });\n\n    await stream.pipeTo(writable, { preventClose: true });\n  } catch (err) {\n    if (abortController.signal.aborted) {\n      wasAborted = true;\n    } else {\n      console.error(\"[streamTextStep] stream error:\", err);\n      throw err;\n    }\n  } finally {\n    pollController.abort();\n  }\n\n  await Promise.all(\n    stepParts.map(async (uiPart) => {\n      const result = await storage.part.set({\n        id: `part_${ulid()}`,\n        index: nextPartIndex++,\n        messageId: assistantMessageId,\n        sessionId: input.sessionId,\n        part: uiPart,\n      });\n      if (result instanceof Error) {\n        throw result;\n      }\n      return result;\n    })\n  );\n\n  if (setStartedPromise) {\n    const setStartedResult = await setStartedPromise;\n    if (setStartedResult instanceof Error) {\n      throw setStartedResult;\n    }\n    for (const m of setStartedResult ?? []) {\n      if (m instanceof Error) {\n        throw m;\n      }\n    }\n  }\n\n  const pendingApprovals = stepParts\n    .filter(\n      (p): p is typeof p & { approval: { id: string } } =>\n        \"state\" in p &&\n        p.state === \"approval-requested\" &&\n        \"approval\" in p &&\n        !!(p as { approval?: { id: string } }).approval?.id\n    )\n    .map((p) => ({\n      approvalId: p.approval.id,\n      toolName: \"type\" in p ? String(p.type).replace(\"tool-\", \"\") : \"unknown\",\n    }));\n\n  const finalFinishReason = wasAborted\n    ? (\"stop\" as FinishReason)\n    : await result.finishReason;\n\n  return {\n    finishReason: finalFinishReason,\n    lastPartIndex: nextPartIndex,\n    usageSteps,\n    pendingApprovals,\n    maxSteps: session.generation?.maxSteps,\n  };\n}\n", "import type { SkillsDir } from \"./types\";\n\n/**\n * Parsed frontmatter from a SKILL.md file.\n */\nexport type SkillFrontmatter = {\n  name: string;\n  description: string;\n};\n\n/**\n * Parses YAML frontmatter from a SKILL.md file content.\n * Frontmatter must be at the start of the file, delimited by `---` markers.\n *\n * @example\n * ```markdown\n * ---\n * name: csv\n * description: Analyze CSV data\n * ---\n * # CSV Skill\n * ...\n * ```\n *\n * @returns Parsed name and description, or null if frontmatter is missing/invalid\n */\nexport function parseSkillFrontmatter(\n  content: string\n): SkillFrontmatter | null {\n  const trimmed = content.trim();\n\n  if (!trimmed.startsWith(\"---\")) {\n    return null;\n  }\n\n  const endMarkerIndex = trimmed.indexOf(\"---\", 3);\n  if (endMarkerIndex === -1) {\n    return null;\n  }\n\n  const frontmatterBlock = trimmed.slice(3, endMarkerIndex).trim();\n  const parsed = parseSimpleYaml(frontmatterBlock);\n\n  if (!(parsed.name && parsed.description)) {\n    return null;\n  }\n\n  return {\n    name: String(parsed.name),\n    description: String(parsed.description),\n  };\n}\n\n/**\n * Parses simple YAML key-value pairs (single-line values only).\n * This avoids adding a full YAML parser dependency for basic frontmatter.\n */\nfunction parseSimpleYaml(yaml: string): Record<string, string> {\n  const result: Record<string, string> = {};\n\n  for (const line of yaml.split(\"\\n\")) {\n    const trimmedLine = line.trim();\n    if (!trimmedLine || trimmedLine.startsWith(\"#\")) {\n      continue;\n    }\n\n    const colonIndex = trimmedLine.indexOf(\":\");\n    if (colonIndex === -1) {\n      continue;\n    }\n\n    const key = trimmedLine.slice(0, colonIndex).trim();\n    let value = trimmedLine.slice(colonIndex + 1).trim();\n\n    // Remove surrounding quotes if present\n    if (\n      (value.startsWith('\"') && value.endsWith('\"')) ||\n      (value.startsWith(\"'\") && value.endsWith(\"'\"))\n    ) {\n      value = value.slice(1, -1);\n    }\n\n    if (key) {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Normalizes skillsDir to an array of strings.\n */\nexport function normalizeSkillsDirs(skillsDir?: SkillsDir): string[] {\n  if (!skillsDir) {\n    return [];\n  }\n  return Array.isArray(skillsDir) ? skillsDir : [skillsDir];\n}\n", "import type { Sandbox } from \"../sandbox\";\nimport { parseSkillFrontmatter } from \"./parser\";\nimport type { SkillSummary } from \"./types\";\n\n/**\n * Discovers skills from directories inside the sandbox by finding and parsing SKILL.md files.\n * Scans each directory for subdirectories containing SKILL.md, extracts frontmatter metadata,\n * and returns summaries for use in the system prompt.\n *\n * @returns Array of skill summaries (deduplicated by name, first occurrence wins)\n */\nexport async function discoverSkillsInSandbox(opts: {\n  sandbox: Sandbox;\n  skillsDirs: string[];\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDirs, debug } = opts;\n\n  const summaries: SkillSummary[] = [];\n  const seenNames = new Set<string>();\n\n  for (const skillsDir of skillsDirs) {\n    const dirSummaries = await discoverSkillsInDirectory({\n      sandbox,\n      skillsDir,\n      debug,\n    });\n\n    for (const summary of dirSummaries) {\n      if (!seenNames.has(summary.name)) {\n        seenNames.add(summary.name);\n        summaries.push(summary);\n      }\n    }\n  }\n\n  return summaries;\n}\n\nasync function discoverSkillsInDirectory(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<SkillSummary[]> {\n  const { sandbox, skillsDir, debug } = opts;\n  const skillPaths = await findSkillFiles({ sandbox, skillsDir, debug });\n\n  if (skillPaths.length === 0) {\n    return [];\n  }\n\n  const summaries: SkillSummary[] = [];\n\n  for (const skillMdPath of skillPaths) {\n    const summary = await parseSkillFile({ sandbox, skillMdPath, debug });\n    if (summary) {\n      summaries.push(summary);\n    }\n  }\n\n  return summaries;\n}\n\nasync function findSkillFiles(opts: {\n  sandbox: Sandbox;\n  skillsDir: string;\n  debug?: boolean;\n}): Promise<string[]> {\n  const { sandbox, skillsDir, debug } = opts;\n\n  const execResult = await sandbox.exec({\n    command: \"find\",\n    args: [skillsDir, \"-name\", \"SKILL.md\", \"-type\", \"f\"],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to scan skills directory \"${skillsDir}\": ${execResult.message}`\n      );\n    }\n    return [];\n  }\n\n  const { stdout, stderr, exitCode } = await execResult.result;\n  if (debug) {\n    console.log(\n      `[discover] find result: exitCode=${exitCode}, stdout=\"${stdout.trim()}\", stderr=\"${stderr.trim()}\"`\n    );\n  }\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(\n        `[discover] Skills directory not found or inaccessible: ${skillsDir}`\n      );\n    }\n    return [];\n  }\n\n  const paths = stdout\n    .trim()\n    .split(\"\\n\")\n    .filter((p) => p.length > 0);\n  if (debug) {\n    console.log(\"[discover] Found skill paths:\", paths);\n  }\n  return paths;\n}\n\nasync function parseSkillFile(opts: {\n  sandbox: Sandbox;\n  skillMdPath: string;\n  debug?: boolean;\n}): Promise<SkillSummary | null> {\n  const { sandbox, skillMdPath, debug } = opts;\n  const execResult = await sandbox.exec({\n    command: \"cat\",\n    args: [skillMdPath],\n  });\n\n  if (execResult instanceof Error) {\n    if (debug) {\n      console.warn(\n        `[discover] Failed to read skill file \"${skillMdPath}\": ${execResult.message}`\n      );\n    }\n    return null;\n  }\n\n  const { stdout, exitCode } = await execResult.result;\n\n  if (exitCode !== 0) {\n    if (debug) {\n      console.warn(`[discover] Could not read skill file: ${skillMdPath}`);\n    }\n    return null;\n  }\n\n  const parsed = parseSkillFrontmatter(stdout);\n\n  if (!parsed) {\n    if (debug) {\n      console.warn(\n        `[discover] Invalid or missing frontmatter in: ${skillMdPath}`\n      );\n    }\n    return null;\n  }\n\n  return {\n    name: parsed.name,\n    description: parsed.description,\n    skillMdPath,\n  };\n}\n", "import { jsonSchema, type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { AgentInput, AgentMessageInput } from \"../agent-workflow\";\nimport type { RpcPayload, RpcResult } from \"../client\";\nimport type { Sandbox } from \"../sandbox\";\nimport { DEFAULT_WAIT_UNTIL } from \"../sandbox/process-manager\";\nimport type { SandboxRecord, Session, Storage } from \"../storage\";\nimport { createJavaScriptTool, type OnSubToolCall } from \"./javascript\";\n\nconst AGENT_PROTOCOL_VERSION = \"v1\";\n\ntype InternalToolContext = {\n  input: AgentInput;\n  event: AgentMessageInput;\n  sandbox: Sandbox;\n  session: Session;\n  sandboxRecord: SandboxRecord;\n  apiToolsMetadata: {\n    name: string;\n    description?: string;\n    inputSchema?: unknown;\n  }[];\n  onSubToolCall?: OnSubToolCall;\n};\n\nexport type ToolContext<TContext = Record<string, unknown>> = {\n  session: Session;\n  sandbox: Sandbox;\n  storage: Storage;\n  context: TContext;\n};\n\nexport const builtInTools = {\n  Read: tool({\n    description:\n      \"Reads a file and returns its contents with metadata. For files over 200 lines, automatically shows first 100 lines unless a specific line range is provided. Use startLine and endLine parameters to read specific portions of large files.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      startLine: z\n        .number()\n        .optional()\n        .describe(\n          \"Starting line number (1-indexed). If provided with endLine, reads exact range regardless of file size.\"\n        ),\n      endLine: z\n        .number()\n        .optional()\n        .describe(\n          \"Ending line number (1-indexed, inclusive). If provided with startLine, reads exact range regardless of file size.\"\n        ),\n    }),\n    outputSchema: z.object({\n      content: z.string().describe(\"File content\"),\n      metadata: z.object({\n        totalLines: z.number().describe(\"Total number of lines in the file\"),\n        linesShown: z\n          .number()\n          .describe(\"Number of lines included in this response\"),\n        startLine: z.number().describe(\"First line number shown (1-indexed)\"),\n        endLine: z.number().describe(\"Last line number shown (1-indexed)\"),\n        isPaginated: z\n          .boolean()\n          .describe(\"Whether this is a partial view of the file\"),\n        fileSize: z\n          .string()\n          .describe(\"Human-readable file size (e.g., '2.5K', '1.2M')\"),\n        path: z\n          .string()\n          .describe(\"Path to the file relative to workspace root\"),\n      }),\n    }),\n  }),\n  Grep: tool({\n    description:\n      \"Search for patterns in files using ripgrep. Use this to find code patterns, function definitions, imports, etc.\",\n    inputSchema: z.object({\n      pattern: z\n        .string()\n        .describe(\"Regex pattern to search for (ripgrep syntax)\"),\n      path: z\n        .string()\n        .optional()\n        .describe(\n          \"Path to search in (defaults to workspace root). Can be a file or directory.\"\n        ),\n      fileType: z\n        .string()\n        .optional()\n        .describe(\n          \"File type to filter by (e.g., 'ts', 'js', 'py', 'md'). Uses ripgrep's built-in type filters.\"\n        ),\n      glob: z\n        .string()\n        .optional()\n        .describe(\n          \"Glob pattern to filter files (e.g., '*.tsx', 'src/**/*.ts')\"\n        ),\n      caseSensitive: z\n        .boolean()\n        .optional()\n        .default(true)\n        .describe(\"Whether search is case-sensitive (default: true)\"),\n      contextLines: z\n        .number()\n        .optional()\n        .describe(\n          \"Number of context lines to show before and after each match\"\n        ),\n      maxCount: z\n        .number()\n        .optional()\n        .describe(\n          \"Maximum number of matches per file (useful for limiting output)\"\n        ),\n      filesWithMatches: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\n          \"Only show file paths that contain matches, not the matching lines themselves\"\n        ),\n    }),\n    outputSchema: z.object({\n      matches: z\n        .string()\n        .describe(\n          \"Search results with file paths, line numbers, and matching content\"\n        ),\n      summary: z.object({\n        matchCount: z.number().describe(\"Number of matches found\"),\n        fileCount: z.number().describe(\"Number of files containing matches\"),\n        searchPath: z.string().describe(\"Path that was searched\"),\n        pattern: z.string().describe(\"Pattern that was searched for\"),\n      }),\n    }),\n  }),\n  List: tool({\n    description:\n      \"Recursively list directory contents. Use this to understand the codebase structure, find files, or explore directories. Control depth to balance detail vs. overview. Depth 1 shows immediate children, depth 2 includes subdirectories, etc.\",\n    inputSchema: z.object({\n      path: z\n        .string()\n        .optional()\n        .describe(\"Path to list (defaults to workspace root)\"),\n      depth: z\n        .number()\n        .optional()\n        .describe(\n          \"Maximum depth to traverse. Choose based on context: 1-2 for quick overview, 3-4 for detailed exploration, 5+ for comprehensive mapping\"\n        ),\n      includeHidden: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\n          \"Include hidden files and directories (those starting with '.')\"\n        ),\n      filesOnly: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\"Only show files, not directories\"),\n      pattern: z\n        .string()\n        .optional()\n        .describe(\"Glob pattern to filter results (e.g., '*.ts', '*test*')\"),\n    }),\n    outputSchema: z.object({\n      listing: z\n        .string()\n        .describe(\n          \"Directory tree listing showing paths relative to search root\"\n        ),\n      summary: z.object({\n        totalItems: z.number().describe(\"Total number of items found\"),\n        totalFiles: z.number().describe(\"Total number of files found\"),\n        totalDirs: z.number().describe(\"Total number of directories found\"),\n        searchPath: z.string().describe(\"Path that was listed\"),\n        depth: z\n          .number()\n          .optional()\n          .describe(\"Maximum depth used (if specified)\"),\n      }),\n    }),\n  }),\n  Write: tool({\n    description:\n      \"Write content to a file. Creates parent directories automatically. Overwrites existing files.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      content: z.string().describe(\"Content to write to the file\"),\n    }),\n    outputSchema: z.object({\n      success: z.boolean().describe(\"Whether the write succeeded\"),\n      path: z.string().describe(\"Path to the written file\"),\n      bytesWritten: z.number().describe(\"Number of bytes written\"),\n      error: z.string().optional().describe(\"Error message if write failed\"),\n    }),\n  }),\n  Edit: tool({\n    description:\n      \"Edit a file by replacing an exact string. Fails if old_string is not found or appears multiple times (not unique). For multiple replacements, call this tool multiple times with unique context.\",\n    inputSchema: z.object({\n      path: z.string().describe(\"Path to the file relative to workspace root\"),\n      old_string: z\n        .string()\n        .describe(\"Exact string to find and replace (must be unique in file)\"),\n      new_string: z.string().describe(\"String to replace old_string with\"),\n    }),\n    outputSchema: z.object({\n      success: z.boolean().describe(\"Whether the edit succeeded\"),\n      path: z.string().describe(\"Path to the edited file\"),\n      error: z.string().optional().describe(\"Error message if edit failed\"),\n    }),\n  }),\n  Bash: tool({\n    description:\n      \"Executes a bash command inside the workspace. CWD persists between commands within a session. Use waitUntil:0 for background processes (dev servers).\",\n    inputSchema: z.object({\n      command: z.string().describe(\"The shell command to execute\"),\n      waitUntil: z\n        .number()\n        .optional()\n        .describe(\n          `Max ms to wait for completion (default: ${DEFAULT_WAIT_UNTIL}). Use 0 to run in background and return immediately.`\n        ),\n    }),\n    outputSchema: z.object({\n      pid: z\n        .number()\n        .describe(\n          \"System PID (0 for foreground, >0 for background - use to kill)\"\n        ),\n      output: z\n        .string()\n        .describe(\"Command stdout+stderr combined (empty for background)\"),\n      exitCode: z.number().describe(\"Exit code (-1 for background/running)\"),\n      status: z\n        .enum([\"running\", \"completed\", \"failed\"])\n        .describe(\"Process status\"),\n      cwd: z.string().describe(\"Current working directory after command\"),\n      outputFile: z\n        .string()\n        .describe(\"Path to output log (for background processes)\"),\n    }),\n  }),\n  JavaScript: tool({\n    inputSchema: z.object({\n      code: z\n        .string()\n        .describe(\n          \"JavaScript async function body. `ctx` is in scope. Must use `return` to produce output.\"\n        ),\n    }),\n  }),\n} satisfies ToolSet;\n\nexport type BuiltInToolName = keyof typeof builtInTools;\nexport const builtinToolNames = Object.fromEntries(\n  Object.entries(builtInTools).map(([name]) => [name, name])\n) as { [K in BuiltInToolName]: K };\n\nexport function getTools(context: InternalToolContext) {\n  const tools: ToolSet = {\n    [builtinToolNames.Read]: tool({\n      ...builtInTools.Read,\n      execute: async ({ path, startLine, endLine }) => {\n        const filePath = path;\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            FILE=\"$1\"\n            START_LINE=\"$2\"\n            END_LINE=\"$3\"\n\n            # Resolve symlinks and check file exists\n            if [ -L \"$FILE\" ]; then\n              RESOLVED=$(readlink -f \"$FILE\" 2>/dev/null || echo \"\")\n              if [ -z \"$RESOLVED\" ] || [ ! -e \"$RESOLVED\" ]; then\n                echo \"Error: Broken symlink - $FILE points to non-existent target\" >&2\n                exit 1\n              fi\n              FILE=\"$RESOLVED\"\n            elif [ ! -e \"$FILE\" ]; then\n              echo \"Error: File not found - $FILE\" >&2\n              exit 1\n            fi\n\n            # Get metadata (count actual lines, not just newlines)\n            TOTAL_LINES=$(awk 'END{print NR}' \"$FILE\")\n            FILE_SIZE=$(ls -lh \"$FILE\" | awk '{print $5}')\n\n            # Determine range\n            PAGE_SIZE=100\n            if [ -n \"$START_LINE\" ] && [ -n \"$END_LINE\" ]; then\n              # Both provided - use exact range\n              ACTUAL_START=$START_LINE\n              ACTUAL_END=$END_LINE\n            elif [ -n \"$START_LINE\" ]; then\n              # Only startLine - read PAGE_SIZE lines from there\n              ACTUAL_START=$START_LINE\n              ACTUAL_END=$((START_LINE + PAGE_SIZE - 1))\n              [ \"$ACTUAL_END\" -gt \"$TOTAL_LINES\" ] && ACTUAL_END=$TOTAL_LINES\n            elif [ -n \"$END_LINE\" ]; then\n              # Only endLine - read from beginning to endLine\n              ACTUAL_START=1\n              ACTUAL_END=$END_LINE\n            elif [ \"$TOTAL_LINES\" -gt 200 ]; then\n              # No range, large file - paginate\n              ACTUAL_START=1\n              ACTUAL_END=$PAGE_SIZE\n            else\n              # No range, small file - show all\n              ACTUAL_START=1\n              ACTUAL_END=$TOTAL_LINES\n            fi\n\n            # Output metadata first (separated by ||| for parsing)\n            echo \"$TOTAL_LINES|$FILE_SIZE|$ACTUAL_START|$ACTUAL_END\"\n            echo \"|||CONTENT|||\"\n\n            # Read content\n            if [ \"$ACTUAL_START\" -eq 1 ] && [ \"$ACTUAL_END\" -eq \"$TOTAL_LINES\" ]; then\n              cat \"$FILE\"\n            else\n              sed -n \"\\${ACTUAL_START},\\${ACTUAL_END}p\" \"$FILE\"\n            fi\n          `,\n            \"--\",\n            filePath,\n            startLine?.toString() || \"\",\n            endLine?.toString() || \"\",\n          ],\n        });\n\n        if (result instanceof Error) {\n          console.error(\"[Read Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          console.error(`[Read Tool] Error: ${stderr}`);\n          return {\n            content: `Error: ${stderr}`,\n            metadata: {\n              totalLines: 0,\n              linesShown: 0,\n              startLine: 0,\n              endLine: 0,\n              isPaginated: false,\n              fileSize: \"0\",\n              path: filePath,\n            },\n          };\n        }\n\n        const [metadataLine, ...rest] = stdout.split(\"|||CONTENT|||\");\n        const content = rest.join(\"|||CONTENT|||\").trimStart();\n        const [totalLinesStr, fileSize, actualStartStr, actualEndStr] =\n          metadataLine.trim().split(\"|\");\n\n        const totalLines = Number.parseInt(totalLinesStr, 10);\n        const actualStart = Number.parseInt(actualStartStr, 10);\n        const actualEnd = Number.parseInt(actualEndStr, 10);\n\n        if (\n          Number.isNaN(totalLines) ||\n          Number.isNaN(actualStart) ||\n          Number.isNaN(actualEnd)\n        ) {\n          console.error(\n            `[Read Tool] Failed to parse metadata: ${metadataLine}`\n          );\n          return {\n            content: `Error: Failed to parse file metadata. Raw output: ${stdout.slice(\n              0,\n              500\n            )}`,\n            metadata: {\n              totalLines: 0,\n              linesShown: 0,\n              startLine: 0,\n              endLine: 0,\n              isPaginated: false,\n              fileSize: \"unknown\",\n              path: filePath,\n            },\n          };\n        }\n\n        return {\n          metadata: {\n            totalLines,\n            linesShown: Math.max(0, actualEnd - actualStart + 1),\n            startLine: actualStart,\n            endLine: actualEnd,\n            isPaginated: actualEnd < totalLines,\n            fileSize: fileSize || \"unknown\",\n            path: filePath,\n          },\n          content,\n        };\n      },\n    }),\n    [builtinToolNames.Grep]: tool({\n      ...builtInTools.Grep,\n      execute: async ({\n        pattern,\n        path,\n        fileType,\n        glob,\n        caseSensitive,\n        contextLines,\n        maxCount,\n        filesWithMatches,\n      }) => {\n        const searchPath = path ?? \".\";\n\n        const args: string[] = [];\n\n        args.push(\"--line-number\");\n        args.push(\"--heading\");\n        args.push(\"--color\", \"never\");\n\n        if (!caseSensitive) {\n          args.push(\"-i\");\n        }\n\n        if (fileType) {\n          args.push(\"--type\", fileType);\n        }\n\n        if (glob) {\n          args.push(\"--glob\", glob);\n        }\n\n        if (contextLines !== undefined) {\n          args.push(\"-C\", String(contextLines));\n        }\n\n        if (maxCount !== undefined) {\n          args.push(\"--max-count\", String(maxCount));\n        }\n\n        if (filesWithMatches) {\n          args.push(\"--files-with-matches\");\n        }\n\n        args.push(\"--\", pattern, searchPath);\n\n        const result = await context.sandbox.exec({ command: \"rg\", args });\n\n        if (result instanceof Error) {\n          console.error(\"[Grep Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr && !stderr.toLowerCase().includes(\"no matches\")) {\n          console.error(`[Grep Tool] Warning: ${stderr}`);\n        }\n\n        // Truncate output to prevent \"input too long\" errors (50k chars \u2248 12.5k tokens)\n        const MAX_GREP_OUTPUT_CHARS = 50_000;\n        let finalOutput = stdout;\n        let wasTruncated = false;\n        if (finalOutput.length > MAX_GREP_OUTPUT_CHARS) {\n          finalOutput =\n            finalOutput.slice(0, MAX_GREP_OUTPUT_CHARS) +\n            \"\\n\\n[Output truncated - use more specific pattern or path]\";\n          wasTruncated = true;\n        }\n\n        const lines = finalOutput\n          .trim()\n          .split(\"\\n\")\n          .filter((l) => l.length > 0);\n        const fileCount = filesWithMatches\n          ? lines.length\n          : new Set(\n              lines\n                .filter((l) => !l.startsWith(\" \") && l.includes(\":\"))\n                .map((l) => l.split(\":\")[0])\n            ).size;\n\n        return {\n          summary: {\n            matchCount: filesWithMatches\n              ? 0\n              : lines.filter((l) => l.includes(\":\")).length,\n            fileCount,\n            searchPath,\n            pattern,\n            wasTruncated,\n          },\n          matches: finalOutput || \"(no matches found)\",\n        };\n      },\n    }),\n    [builtinToolNames.List]: tool({\n      ...builtInTools.List,\n      execute: async ({ path, depth, includeHidden, filesOnly, pattern }) => {\n        const searchPath = path ?? \".\";\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            SEARCH_PATH=\"$1\"\n            DEPTH=\"$2\"\n            INCLUDE_HIDDEN=\"$3\"\n            FILES_ONLY=\"$4\"\n            PATTERN=\"$5\"\n\n            # Build find command arguments\n            FIND_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && FIND_ARGS=\"$FIND_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && FIND_ARGS=\"$FIND_ARGS ! -path '*/.*'\"\n            [ \"$FILES_ONLY\" = \"true\" ] && FIND_ARGS=\"$FIND_ARGS -type f\"\n            [ -n \"$PATTERN\" ] && FIND_ARGS=\"$FIND_ARGS -name '$PATTERN'\"\n\n            # Get listing\n            LISTING=$(eval \"find '$SEARCH_PATH' $FIND_ARGS\" 2>/dev/null | sort)\n\n            # Get counts\n            COUNT_ARGS=\"\"\n            [ -n \"$DEPTH\" ] && COUNT_ARGS=\"$COUNT_ARGS -maxdepth $DEPTH\"\n            [ \"$INCLUDE_HIDDEN\" != \"true\" ] && COUNT_ARGS=\"$COUNT_ARGS ! -path '*/.*'\"\n\n            FILE_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type f\" 2>/dev/null | wc -l)\n            DIR_COUNT=$(eval \"find '$SEARCH_PATH' $COUNT_ARGS -type d\" 2>/dev/null | wc -l)\n\n            # Output: counts first, then listing\n            echo \"$FILE_COUNT|$DIR_COUNT\"\n            echo \"|||LISTING|||\"\n            echo \"$LISTING\" | sed \"s|^$SEARCH_PATH|.|\"\n          `,\n            \"--\",\n            searchPath,\n            depth?.toString() || \"\",\n            includeHidden ? \"true\" : \"false\",\n            filesOnly ? \"true\" : \"false\",\n            pattern || \"\",\n          ],\n        });\n\n        if (result instanceof Error) {\n          console.error(\"[List Tool]\", result);\n          throw result;\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          console.warn(`[List Tool] stderr: ${stderr}`);\n        }\n\n        const [countsLine, ...rest] = stdout.split(\"|||LISTING|||\");\n        const listing = rest.join(\"|||LISTING|||\").trim();\n        const [fileCountStr, dirCountStr] = countsLine.trim().split(\"|\");\n\n        const totalFiles = Number.parseInt(fileCountStr, 10) || 0;\n        const totalDirs = Number.parseInt(dirCountStr, 10) || 0;\n        const lines = listing.split(\"\\n\").filter((l) => l.length > 0);\n\n        return {\n          summary: {\n            totalItems: lines.length,\n            totalFiles,\n            totalDirs,\n            searchPath,\n            depth,\n          },\n          listing,\n        };\n      },\n    }),\n    [builtinToolNames.Write]: tool({\n      ...builtInTools.Write,\n      execute: async ({ path, content }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          if (dir !== \".\") {\n            await context.sandbox.exec({ command: \"mkdir\", args: [\"-p\", dir] });\n          }\n\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content }],\n            destPath: dir,\n          });\n\n          return {\n            success: true,\n            path: filePath,\n            bytesWritten: Buffer.byteLength(content, \"utf8\"),\n          };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return {\n            success: false,\n            path: filePath,\n            bytesWritten: 0,\n            error: errorMsg,\n          };\n        }\n      },\n    }),\n    [builtinToolNames.Edit]: tool({\n      ...builtInTools.Edit,\n      execute: async ({ path, old_string, new_string }) => {\n        const filePath = path.startsWith(\"/\") ? path.slice(1) : path;\n\n        const result = await context.sandbox.exec({\n          command: \"bash\",\n          args: [\n            \"-c\",\n            `\n            set -e\n            FILE=\"$1\"\n            \n            if [ ! -f \"$FILE\" ]; then\n              echo \"FILE_NOT_FOUND\"\n              exit 0\n            fi\n            \n            CONTENT=$(cat \"$FILE\")\n            echo \"$CONTENT\"\n          `,\n            \"--\",\n            filePath,\n          ],\n        });\n\n        if (result instanceof Error) {\n          return { success: false, path: filePath, error: result.message };\n        }\n\n        const { stdout, stderr } = await result.result;\n\n        if (stderr) {\n          return { success: false, path: filePath, error: stderr };\n        }\n\n        if (stdout === \"FILE_NOT_FOUND\") {\n          return {\n            success: false,\n            path: filePath,\n            error: `File not found: ${filePath}`,\n          };\n        }\n\n        const content = stdout;\n        const occurrences = content.split(old_string).length - 1;\n\n        if (occurrences === 0) {\n          return {\n            success: false,\n            path: filePath,\n            error: \"old_string not found in file\",\n          };\n        }\n\n        if (occurrences > 1) {\n          return {\n            success: false,\n            path: filePath,\n            error: `old_string appears ${occurrences} times in file (must be unique). Include more surrounding context to make the match unique.`,\n          };\n        }\n\n        const newContent = content.replace(old_string, new_string);\n        const dir = filePath.includes(\"/\")\n          ? filePath.split(\"/\").slice(0, -1).join(\"/\")\n          : \".\";\n        const fileName = filePath.split(\"/\").pop() || filePath;\n\n        try {\n          await context.sandbox.writeFiles({\n            files: [{ path: fileName, content: newContent }],\n            destPath: dir,\n          });\n\n          return { success: true, path: filePath };\n        } catch (err) {\n          const errorMsg = err instanceof Error ? err.message : String(err);\n          return { success: false, path: filePath, error: errorMsg };\n        }\n      },\n    }),\n    [builtinToolNames.Bash]: tool({\n      ...builtInTools.Bash,\n      execute: async ({ command, waitUntil }) => {\n        const { createProcessManager } = await import(\n          \"../sandbox/process-manager\"\n        );\n\n        const processManager = createProcessManager({\n          sandbox: context.sandbox,\n          sessionId: context.input.sessionId,\n        });\n\n        await processManager.init();\n        return processManager.run({ command, waitUntil });\n      },\n    }),\n  };\n\n  if (context.apiToolsMetadata.length > 0) {\n    const apiTools = buildApiTools({\n      rpc: context.input.rpc,\n      metadata: context.apiToolsMetadata,\n      session: context.session,\n      sandboxRecord: context.sandboxRecord,\n      context: context.event.context,\n    });\n    Object.assign(tools, apiTools);\n  }\n\n  tools[builtinToolNames.JavaScript] = createJavaScriptTool({\n    tools,\n    session: context.session,\n    sandbox: context.sandbox,\n    onSubToolCall: context.onSubToolCall,\n  });\n\n  return tools;\n}\n\ntype ApiToolMetadata = {\n  name: string;\n  description?: string;\n  inputSchema?: unknown;\n};\n\nexport async function fetchApiToolsMetadata(opts: {\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n}): Promise<ApiToolMetadata[]> {\n  const { rpc } = opts;\n\n  const result = await rpc({ method: \"tools.list\", params: {} });\n\n  if (\"error\" in result) {\n    console.error(\"[agent] Failed to fetch tools:\", result.error?.message);\n    return [];\n  }\n\n  return (result.result as ApiToolMetadata[]) ?? [];\n}\n\nexport function buildApiTools(opts: {\n  rpc: (params: RpcPayload) => Promise<RpcResult>;\n  metadata: ApiToolMetadata[];\n  session: Session;\n  sandboxRecord: SandboxRecord;\n  context: Record<string, unknown>;\n}): ToolSet {\n  const { rpc, metadata, session, sandboxRecord, context } = opts;\n  const tools: ToolSet = {};\n\n  for (const meta of metadata) {\n    tools[meta.name] = tool({\n      description: meta.description ?? `Custom tool: ${meta.name}`,\n      inputSchema: meta.inputSchema\n        ? jsonSchema(meta.inputSchema as Parameters<typeof jsonSchema>[0])\n        : z.object({}),\n      execute: async (input) => {\n        const result = await rpc({\n          method: \"tools.execute\",\n          params: {\n            name: meta.name,\n            input,\n            session,\n            sandboxRecord,\n            context,\n          },\n        });\n\n        if (\"error\" in result) {\n          throw new Error(`Tool execution failed: ${result.error?.message}`);\n        }\n\n        return result.result;\n      },\n    });\n  }\n\n  return tools;\n}\n\nexport function resolveApiUrl(opts: { api: string | undefined }): string {\n  let origin = \"\";\n  let path = `/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;\n\n  if (opts.api) {\n    if (opts.api.startsWith(\"/\")) {\n      path = opts.api;\n    } else {\n      // see if it's full\n      try {\n        const url = new URL(opts.api);\n        origin = url.origin;\n        const fullPath = url.pathname + url.search + url.hash;\n        if (fullPath.startsWith(\"/\") && fullPath !== \"/\") {\n          path = fullPath;\n        }\n      } catch {\n        // noop\n      }\n    }\n  }\n\n  if (!origin) {\n    if (process.env.NODE_ENV === \"development\") {\n      origin = `http://localhost:${\n        process.env.PORT ?? process.env.NEXT_PUBLIC_PORT ?? 3000\n      }`;\n    }\n    const vercelUrl =\n      process.env.VERCEL_URL ?? process.env.NEXT_PUBLIC_VERCEL_URL;\n    if (vercelUrl) {\n      origin = `https://${vercelUrl}`;\n    }\n  }\n\n  if (!origin) {\n    throw new Error(\n      \"[agent] Couldn't determine API origin (no origin detected in `api` option and no VERCEL_URL set)\"\n    );\n  }\n\n  return `${origin}${path}`;\n}\n", "import { type ToolSet, tool } from \"ai\";\nimport { z } from \"zod\";\nimport type { Sandbox } from \"../sandbox\";\nimport type { Session } from \"../storage\";\nimport { builtInTools } from \".\";\n\nexport const JAVASCRIPT_TOOL_NAME = \"JavaScript\";\n\nexport type SubToolCallResult = { result?: unknown; error?: string };\nexport type OnSubToolCall = (\n  toolName: string,\n  input: unknown,\n  execute: () => Promise<unknown>\n) => Promise<SubToolCallResult>;\n\nconst REQUEST_MARKER_START = \"__TOOL_REQUEST__\";\nconst REQUEST_MARKER_END = \"__TOOL_REQUEST_END__\";\nconst EXECUTION_TIMEOUT_MS = 5 * 60 * 1000;\n\n/**\n * The runner script is written to the sandbox and executed via Node.js.\n * It reads the model's code from code.js, sets up ctx.tools as RPC proxies\n * (requests sent via stderr markers, responses polled from files), executes\n * the code, and writes the result to stdout as JSON.\n */\nconst RUNNER_SCRIPT = `\nimport { readFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';\nimport { join, dirname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nconst SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));\nconst TOOL_CALL_TIMEOUT_MS = 300_000;\n\nlet reqCounter = 0;\n\nasync function callTool(name, input) {\n  const id = 'req_' + (++reqCounter) + '_' + Date.now();\n  const responseFile = join(SCRIPT_DIR, id + '.response.json');\n\n  const request = JSON.stringify({ id, tool: name, input });\n  process.stderr.write('${REQUEST_MARKER_START}' + request + '${REQUEST_MARKER_END}' + '\\\\n');\n\n  const start = Date.now();\n  while (!existsSync(responseFile)) {\n    if (Date.now() - start > TOOL_CALL_TIMEOUT_MS) {\n      throw new Error('Tool call ' + name + ' timed out waiting for response');\n    }\n    await new Promise(r => setTimeout(r, 30));\n  }\n\n  let raw;\n  try {\n    raw = readFileSync(responseFile, 'utf8');\n  } catch {\n    await new Promise(r => setTimeout(r, 50));\n    raw = readFileSync(responseFile, 'utf8');\n  }\n\n  const response = JSON.parse(raw);\n  try { unlinkSync(responseFile); } catch {}\n\n  if (response.error) {\n    throw new Error(response.error);\n  }\n  return response.result;\n}\n\nconst code = readFileSync(join(SCRIPT_DIR, 'code.js'), 'utf8');\nconst toolNames = JSON.parse(readFileSync(join(SCRIPT_DIR, 'tools.json'), 'utf8'));\n\nconst ctx = { tools: {} };\nfor (const name of toolNames) {\n  ctx.tools[name] = (input) => callTool(name, input);\n}\n\nconst logs = [];\nconst customConsole = {\n  log: (...args) => logs.push(args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n  error: (...args) => logs.push('[error] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n  warn: (...args) => logs.push('[warn] ' + args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')),\n};\n\ntry {\n  const AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;\n  const fn = new AsyncFunction('ctx', 'console', code);\n  const result = await fn(ctx, customConsole);\n\n  const output = { success: true, result: result !== undefined ? result : null };\n  if (logs.length > 0) output.logs = logs;\n  process.stdout.write(JSON.stringify(output));\n} catch (err) {\n  const output = {\n    success: false,\n    error: err instanceof Error ? err.message + '\\\\n' + err.stack : String(err),\n  };\n  if (logs.length > 0) output.logs = logs;\n  process.stdout.write(JSON.stringify(output));\n}\n`;\n\n/**\n * Extracts a plain JSON Schema from whatever format the AI SDK tool uses\n * (Zod schema, AI SDK wrapped schema, or raw JSON Schema).\n */\nexport function extractJsonSchema(\n  schema: unknown\n): Record<string, unknown> | null {\n  if (!schema || typeof schema !== \"object\") {\n    return null;\n  }\n\n  if (\n    \"_def\" in schema &&\n    typeof (schema as { _def: unknown })._def === \"object\"\n  ) {\n    try {\n      return z.toJSONSchema(schema as z.ZodType) as Record<string, unknown>;\n    } catch {\n      return null;\n    }\n  }\n\n  const s = schema as Record<string | symbol, unknown>;\n  if (Symbol.for(\"vercel.ai.schema\") in s && \"jsonSchema\" in s) {\n    return s.jsonSchema as Record<string, unknown>;\n  }\n\n  if (\"type\" in s || \"properties\" in s) {\n    return s as Record<string, unknown>;\n  }\n\n  return null;\n}\n\nexport function jsonSchemaToTs(\n  schema: Record<string, unknown>,\n  indent = 0\n): string {\n  if (!schema) {\n    return \"unknown\";\n  }\n\n  if (schema.enum && Array.isArray(schema.enum)) {\n    return schema.enum.map((v) => JSON.stringify(v)).join(\" | \");\n  }\n\n  if (schema.anyOf && Array.isArray(schema.anyOf)) {\n    return schema.anyOf\n      .map((s: Record<string, unknown>) => jsonSchemaToTs(s, indent))\n      .join(\" | \");\n  }\n  if (schema.oneOf && Array.isArray(schema.oneOf)) {\n    return schema.oneOf\n      .map((s: Record<string, unknown>) => jsonSchemaToTs(s, indent))\n      .join(\" | \");\n  }\n\n  const type = schema.type as string;\n\n  switch (type) {\n    case \"string\":\n      return \"string\";\n    case \"number\":\n    case \"integer\":\n      return \"number\";\n    case \"boolean\":\n      return \"boolean\";\n    case \"null\":\n      return \"null\";\n    case \"array\": {\n      const items = schema.items\n        ? jsonSchemaToTs(schema.items as Record<string, unknown>, indent)\n        : \"unknown\";\n      return `Array<${items}>`;\n    }\n    case \"object\": {\n      const properties = schema.properties as\n        | Record<string, Record<string, unknown>>\n        | undefined;\n      if (!properties) {\n        return \"Record<string, unknown>\";\n      }\n      const required = new Set((schema.required as string[]) || []);\n      const pad = \"  \".repeat(indent + 1);\n      const closePad = \"  \".repeat(indent);\n      const props = Object.entries(properties).map(([key, value]) => {\n        const opt = required.has(key) ? \"\" : \"?\";\n        return `${pad}${key}${opt}: ${jsonSchemaToTs(value, indent + 1)}`;\n      });\n      return `{\\n${props.join(\";\\n\")};\\n${closePad}}`;\n    }\n    default:\n      return \"unknown\";\n  }\n}\n\nexport function generateContextTypeString(tools: ToolSet): string {\n  const sigs: string[] = [];\n\n  for (const [name, t] of Object.entries(tools)) {\n    const raw = t as Record<string, unknown>;\n    const inputSchema = extractJsonSchema(raw.inputSchema ?? raw.parameters);\n    const outputSchema = extractJsonSchema(raw.outputSchema);\n\n    const inputType = inputSchema ? jsonSchemaToTs(inputSchema, 2) : \"{}\";\n    const outputType = outputSchema\n      ? jsonSchemaToTs(outputSchema, 2)\n      : \"unknown\";\n\n    sigs.push(`    ${name}(input: ${inputType}): Promise<${outputType}>`);\n  }\n\n  return `type Context = {\\n  tools: {\\n${sigs.join(\";\\n\")};\\n  }\\n}`;\n}\n\nasync function executeInSandbox({\n  code,\n  rpcDir,\n  abortController,\n  sandbox,\n  availableTools,\n  onSubToolCall,\n}: {\n  code: string;\n  rpcDir: string;\n  abortController: AbortController;\n  sandbox: Sandbox;\n  availableTools: ToolSet;\n  onSubToolCall?: OnSubToolCall;\n}): Promise<Record<string, unknown>> {\n  const mkdirResult = await sandbox.exec({\n    command: \"mkdir\",\n    args: [\"-p\", rpcDir],\n  });\n  if (mkdirResult instanceof Error) {\n    return { success: false, error: mkdirResult.message };\n  }\n  await mkdirResult.result;\n\n  await sandbox.writeFiles({\n    files: [\n      { path: \"runner.mjs\", content: RUNNER_SCRIPT },\n      { path: \"code.js\", content: code },\n      {\n        path: \"tools.json\",\n        content: JSON.stringify(Object.keys(availableTools)),\n      },\n    ],\n    destPath: rpcDir,\n  });\n\n  const nodeMajor = Number.parseInt(process.versions.node.split(\".\")[0], 10);\n  const permissionFlag =\n    nodeMajor >= 22 ? \"--permission\" : \"--experimental-permission\";\n\n  const execResult = await sandbox.exec({\n    command: \"node\",\n    args: [\n      permissionFlag,\n      `--allow-fs-read=${rpcDir}`,\n      `--allow-fs-write=${rpcDir}`,\n      `${rpcDir}/runner.mjs`,\n    ],\n    signal: abortController.signal,\n  });\n\n  if (execResult instanceof Error) {\n    return { success: false, error: execResult.message };\n  }\n\n  const fatal: { error: Error | null } = { error: null };\n\n  const abort = (error: Error) => {\n    if (!fatal.error) {\n      fatal.error = error;\n      abortController.abort();\n    }\n  };\n\n  const handleToolRequest = async (requestJson: string) => {\n    let parsed: { id: string; tool: string; input: unknown };\n    try {\n      parsed = JSON.parse(requestJson);\n    } catch {\n      return;\n    }\n\n    const { id, tool: toolName, input } = parsed;\n\n    let response: { result?: unknown; error?: string };\n    try {\n      const t = availableTools[toolName];\n      if (!t?.execute) {\n        throw new Error(\n          `Tool ${toolName} not found or has no execute function`\n        );\n      }\n      const exec = t.execute.bind(t);\n      if (onSubToolCall) {\n        response = await onSubToolCall(toolName, input, () =>\n          exec(input, {\n            toolCallId: `js_${toolName}_${Date.now()}`,\n            messages: [],\n          })\n        );\n      } else {\n        const result = await exec(input, {\n          toolCallId: `js_${toolName}_${Date.now()}`,\n          messages: [],\n        });\n        response = { result };\n      }\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      response = { error: msg };\n    }\n\n    try {\n      await sandbox.writeFiles({\n        files: [\n          {\n            path: `${id}.response.json`,\n            content: JSON.stringify(response),\n          },\n        ],\n        destPath: rpcDir,\n      });\n    } catch (err) {\n      /**\n       * If writing the response file fails, the runner will poll forever\n       * waiting for it. Abort the runner process so we don't deadlock.\n       */\n      const msg = err instanceof Error ? err.message : String(err);\n      abort(new Error(`Failed to write RPC response for ${toolName}: ${msg}`));\n    }\n  };\n\n  const toolCallPromises: Promise<void>[] = [];\n  let stderrBuffer = \"\";\n  let nonMarkerStderr = \"\";\n\n  const timeout = setTimeout(() => {\n    abort(\n      new Error(\n        `JavaScript execution timed out after ${EXECUTION_TIMEOUT_MS / 1000}s`\n      )\n    );\n  }, EXECUTION_TIMEOUT_MS);\n\n  try {\n    for await (const entry of execResult.logs()) {\n      if (fatal.error) {\n        break;\n      }\n\n      if (entry.stream === \"stderr\") {\n        stderrBuffer += entry.data;\n\n        while (true) {\n          const startIdx = stderrBuffer.indexOf(REQUEST_MARKER_START);\n          if (startIdx === -1) {\n            break;\n          }\n\n          const beforeMarker = stderrBuffer.slice(0, startIdx);\n          if (beforeMarker.trim()) {\n            nonMarkerStderr += beforeMarker;\n          }\n\n          const contentStart = startIdx + REQUEST_MARKER_START.length;\n          const endIdx = stderrBuffer.indexOf(REQUEST_MARKER_END, contentStart);\n          if (endIdx === -1) {\n            break;\n          }\n\n          const requestJson = stderrBuffer.slice(contentStart, endIdx);\n          stderrBuffer = stderrBuffer.slice(endIdx + REQUEST_MARKER_END.length);\n\n          toolCallPromises.push(handleToolRequest(requestJson));\n        }\n      }\n    }\n  } finally {\n    clearTimeout(timeout);\n  }\n\n  if (stderrBuffer.trim()) {\n    nonMarkerStderr += stderrBuffer;\n  }\n\n  await Promise.allSettled(toolCallPromises);\n\n  if (fatal.error) {\n    execResult.result.catch(() => undefined);\n    return {\n      success: false,\n      error: fatal.error.message,\n      ...(nonMarkerStderr ? { stderr: nonMarkerStderr.slice(0, 2000) } : {}),\n    };\n  }\n\n  const { stdout, stderr, exitCode } = await execResult.result;\n\n  try {\n    return JSON.parse(stdout);\n  } catch {\n    return {\n      success: false,\n      error: `Runner failed (exit ${exitCode}).`,\n      stderr: (nonMarkerStderr + stderr).slice(0, 2000),\n      stdout: stdout.slice(0, 1000),\n    };\n  }\n}\n\nexport function createJavaScriptTool(opts: {\n  tools: ToolSet;\n  session: Session;\n  sandbox: Sandbox;\n  onSubToolCall?: OnSubToolCall;\n}) {\n  const { session, sandbox, onSubToolCall } = opts;\n  const activeSet = session.activeTools ? new Set(session.activeTools) : null;\n  const availableTools: ToolSet = {};\n  for (const [name, t] of Object.entries(opts.tools)) {\n    if (!activeSet || activeSet.has(name)) {\n      availableTools[name] = t;\n    }\n  }\n  const contextType = generateContextTypeString(availableTools);\n\n  return tool({\n    ...builtInTools.JavaScript,\n    description: `Execute JavaScript to orchestrate multiple tool calls in a single step. Use this when you need to run several tools in sequence, transform intermediate results, or parallelize independent operations with Promise.all.\n\nThe code runs as an async function body with \\`ctx\\` in scope:\n\n\\`\\`\\`typescript\n${contextType}\n\\`\\`\\`\n\nExamples:\n- Sequential: \\`const file = await ctx.tools.Read({ path: \"package.json\" }); return JSON.parse(file.content);\\`\n- Parallel: \\`const [a, b] = await Promise.all([ctx.tools.Read({ path: \"a.ts\" }), ctx.tools.Read({ path: \"b.ts\" })]); return { a: a.content, b: b.content };\\`\n- Transform: \\`const grep = await ctx.tools.Grep({ pattern: \"TODO\" }); return grep.matches.split(\"\\\\n\").length;\\`\n\nReturn a value to pass results back. Use console.log() for debug output.`,\n    execute: ({ code }) => {\n      const runId = `run_${Date.now()}_${Math.random()\n        .toString(36)\n        .slice(2, 8)}`;\n      const rpcDir = `.agent/js-rpc/${runId}`;\n      const abortController = new AbortController();\n\n      return executeInSandbox({\n        code,\n        rpcDir,\n        abortController,\n        sandbox,\n        availableTools,\n        onSubToolCall,\n      });\n    },\n  });\n}\n", "import type { JSONValue, ModelMessage } from \"ai\";\n\ntype ProviderOptions = Record<string, Record<string, JSONValue>>;\n\nconst ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST = 4;\n\nconst CLAUDE_LIKE_MODEL_MATCHERS = [\"claude\", \"anthropic\"];\n\nconst CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS: ProviderOptions = {\n  anthropic: {\n    cacheControl: { type: \"ephemeral\" },\n  },\n  openrouter: {\n    cacheControl: { type: \"ephemeral\" },\n  },\n  bedrock: {\n    cachePoint: { type: \"default\" },\n  },\n  openaiCompatible: {\n    cache_control: { type: \"ephemeral\" },\n  },\n  copilot: {\n    copilot_cache_control: { type: \"ephemeral\" },\n  },\n};\n\nfunction getGatewayProvider(model: string): string | null {\n  const slashIndex = model.indexOf(\"/\");\n  if (slashIndex === -1) {\n    return null;\n  }\n  return model.slice(0, slashIndex);\n}\n\nfunction countAnthropicCacheBreakpoints(messages: ModelMessage[]): number {\n  let count = 0;\n  for (const message of messages) {\n    const providerOptions = (message as { providerOptions?: ProviderOptions })\n      .providerOptions;\n    if (providerOptions?.anthropic?.cacheControl) {\n      count += 1;\n    }\n    if (Array.isArray(message.content)) {\n      for (const part of message.content) {\n        const partProviderOptions = (\n          part as { providerOptions?: ProviderOptions }\n        ).providerOptions;\n        if (partProviderOptions?.anthropic?.cacheControl) {\n          count += 1;\n        }\n      }\n    }\n  }\n  return count;\n}\n\nfunction isClaudeLikeModel(model: string): boolean {\n  const lower = model.toLowerCase();\n  return CLAUDE_LIKE_MODEL_MATCHERS.some((m) => lower.includes(m));\n}\n\nfunction mergeProviderOptions(opts: {\n  current: ProviderOptions | undefined;\n  patch: ProviderOptions;\n}): ProviderOptions {\n  const next: ProviderOptions = { ...(opts.current ?? {}) };\n  for (const [key, value] of Object.entries(opts.patch)) {\n    next[key] = { ...(next[key] ?? {}), ...value };\n  }\n  return next;\n}\n\nfunction isCacheableClaudePart(part: unknown): boolean {\n  if (!part || typeof part !== \"object\") {\n    return false;\n  }\n\n  if (\"type\" in part && (part as { type?: unknown }).type === \"text\") {\n    const text = (part as { text?: unknown }).text;\n    if (typeof text === \"string\") {\n      return text.trim().length > 0;\n    }\n  }\n\n  if (\"type\" in part) {\n    const type = (part as { type?: unknown }).type;\n    if (type === \"thinking\" || type === \"reasoning\") {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction hasCacheableContent(message: ModelMessage): boolean {\n  if (typeof message.content === \"string\") {\n    return message.content.trim().length > 0;\n  }\n\n  if (Array.isArray(message.content)) {\n    return message.content.some((part) => isCacheableClaudePart(part));\n  }\n\n  return false;\n}\n\nfunction findLastCacheablePartIndex(content: unknown[]): number | null {\n  for (let i = content.length - 1; i >= 0; i -= 1) {\n    if (isCacheableClaudePart(content[i])) {\n      return i;\n    }\n  }\n  return null;\n}\n\nfunction selectClaudeCachingTargets(messages: ModelMessage[]): number[] {\n  const systemIndices: number[] = [];\n  const finalIndices: number[] = [];\n\n  for (let i = 0; i < messages.length && systemIndices.length < 2; i += 1) {\n    const message = messages[i];\n    if (message.role === \"system\" && hasCacheableContent(message)) {\n      systemIndices.push(i);\n    }\n  }\n\n  for (let i = messages.length - 1; i >= 0 && finalIndices.length < 2; i -= 1) {\n    const message = messages[i];\n    if (message.role !== \"system\" && hasCacheableContent(message)) {\n      finalIndices.push(i);\n    }\n  }\n\n  finalIndices.reverse();\n\n  return [...systemIndices, ...finalIndices];\n}\n\nfunction applyClaudePromptCaching(opts: {\n  messages: ModelMessage[];\n  providerId: string | null;\n  maxBreakpointsPerRequest: number;\n}): ModelMessage[] {\n  const existingBreakpoints = countAnthropicCacheBreakpoints(opts.messages);\n  const remainingBudget = Math.max(\n    0,\n    opts.maxBreakpointsPerRequest - existingBreakpoints\n  );\n\n  if (remainingBudget === 0) {\n    return opts.messages;\n  }\n\n  const targetIndices = selectClaudeCachingTargets(opts.messages).slice(\n    0,\n    remainingBudget\n  );\n  if (targetIndices.length === 0) {\n    return opts.messages;\n  }\n\n  const useMessageLevelOptions =\n    opts.providerId === \"anthropic\" ||\n    Boolean(opts.providerId?.includes(\"bedrock\"));\n\n  const nextMessages = opts.messages.slice();\n\n  for (const messageIndex of targetIndices) {\n    const message = nextMessages[messageIndex];\n\n    const shouldUseContentOptions =\n      !useMessageLevelOptions &&\n      Array.isArray(message.content) &&\n      message.content.length > 0;\n\n    if (shouldUseContentOptions && Array.isArray(message.content)) {\n      const partIndex = findLastCacheablePartIndex(message.content);\n      if (partIndex !== null) {\n        const part = message.content[partIndex];\n        if (part && typeof part === \"object\") {\n          const partProviderOptions = (\n            part as { providerOptions?: ProviderOptions }\n          ).providerOptions;\n\n          const nextContent = message.content.slice();\n          nextContent[partIndex] = {\n            ...(part as Record<string, unknown>),\n            providerOptions: mergeProviderOptions({\n              current: partProviderOptions,\n              patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS,\n            }),\n          } as (typeof message.content)[number];\n\n          nextMessages[messageIndex] = {\n            ...message,\n            content: nextContent,\n          } as ModelMessage;\n          continue;\n        }\n      }\n    }\n\n    const messageProviderOptions = (\n      message as { providerOptions?: ProviderOptions }\n    ).providerOptions;\n\n    nextMessages[messageIndex] = {\n      ...message,\n      providerOptions: mergeProviderOptions({\n        current: messageProviderOptions,\n        patch: CLAUDE_PROMPT_CACHING_PROVIDER_OPTIONS,\n      }),\n    };\n  }\n\n  return nextMessages;\n}\n\nexport type PromptCachingResult = {\n  messages: ModelMessage[];\n  providerOptions: ProviderOptions;\n};\n\nexport function applyPromptCachingToModelRequest(opts: {\n  model: string;\n  sessionId: string;\n  messages: ModelMessage[];\n  anthropic?: { maxBreakpointsPerRequest?: number };\n  openai?: { setPromptCacheKey?: boolean };\n}): PromptCachingResult {\n  const provider = getGatewayProvider(opts.model);\n\n  const providerOptions: ProviderOptions = {};\n\n  if (\n    (provider === \"openai\" || provider === \"azure\") &&\n    opts.openai?.setPromptCacheKey !== false\n  ) {\n    providerOptions.openai = { promptCacheKey: opts.sessionId };\n  }\n\n  const maxBreakpointsPerRequest =\n    opts.anthropic?.maxBreakpointsPerRequest ??\n    ANTHROPIC_MAX_CACHE_BREAKPOINTS_PER_REQUEST;\n\n  const cachedMessages = isClaudeLikeModel(opts.model)\n    ? applyClaudePromptCaching({\n        messages: opts.messages,\n        providerId: provider,\n        maxBreakpointsPerRequest,\n      })\n    : opts.messages;\n\n  return {\n    messages: cachedMessages,\n    providerOptions,\n  };\n}\n", "import type { UIMessage } from \"ai\";\nimport type { Message, Part } from \"../storage\";\n\n/** Sub-tool parts (from JavaScript meta-tool) use this toolCallId prefix. */\nfunction isSubToolPart(part: Part): boolean {\n  const p = part.part as { toolCallId?: string };\n  return typeof p?.toolCallId === \"string\" && p.toolCallId.startsWith(\"js_tc_\");\n}\n\nexport function assembleUIMessages(opts: {\n  messages: Message[];\n  parts: Part[];\n  until?: number;\n  includeQueued?: boolean;\n  /** When true, filters out sub-tool parts so the LLM doesn't see them. */\n  excludeSubToolParts?: boolean;\n}): UIMessage[] {\n  let filtered = opts.messages;\n\n  if (opts.until !== undefined) {\n    const until = opts.until;\n    filtered = filtered.filter((m) => m.createdAt <= until);\n  }\n\n  if (!opts.includeQueued) {\n    filtered = filtered.filter((m) => m.startedAt !== null);\n  }\n\n  const parts = opts.excludeSubToolParts\n    ? opts.parts.filter((p) => !isSubToolPart(p))\n    : opts.parts;\n\n  const partsByMessage = new Map<string, Part[]>();\n  for (const part of parts) {\n    const existing = partsByMessage.get(part.messageId) ?? [];\n    existing.push(part);\n    partsByMessage.set(part.messageId, existing);\n  }\n\n  return filtered\n    .map((m) => {\n      const messageParts = partsByMessage.get(m.id) ?? [];\n      messageParts.sort((a, b) => a.index - b.index);\n      return {\n        id: m.id,\n        role: m.role,\n        parts: messageParts.map((p) => p.part),\n      } satisfies UIMessage;\n    })\n    .filter((m) => m.parts.length > 0);\n}\n", "import type { StepUsage, UsageSummary } from \"../storage/rpc\";\n\nexport type { StepUsage, UsageSummary };\n\nfunction sum(items: StepUsage[], key: keyof StepUsage): number {\n  return items.reduce((acc, item) => {\n    const value = item[key];\n    return acc + (typeof value === \"number\" ? value : 0);\n  }, 0);\n}\n\nexport function computeUsageSummary(steps: StepUsage[]): UsageSummary {\n  return {\n    model: steps[0]?.model ?? \"unknown\",\n    inputTokens: sum(steps, \"inputTokens\"),\n    outputTokens: sum(steps, \"outputTokens\"),\n    totalTokens: sum(steps, \"totalTokens\"),\n    cacheReadTokens: sum(steps, \"cacheReadTokens\"),\n    cacheWriteTokens: sum(steps, \"cacheWriteTokens\"),\n    reasoningTokens: sum(steps, \"reasoningTokens\"),\n    stepCount: steps.length,\n  };\n}\n\nexport type SessionUsage = {\n  total: UsageSummary & { messageCount: number };\n  byMessageId: Record<string, UsageSummary | null>;\n};\n\nexport function computeSessionUsage(\n  messages: Array<{\n    id: string;\n    usage: { steps: StepUsage[]; summary: UsageSummary } | null;\n  }>\n): SessionUsage {\n  const byMessageId: Record<string, UsageSummary | null> = {};\n  for (const m of messages) {\n    byMessageId[m.id] = m.usage?.summary ?? null;\n  }\n\n  const summaries = messages\n    .map((m) => m.usage?.summary)\n    .filter((s): s is UsageSummary => s !== undefined);\n\n  const total = {\n    model: summaries[0]?.model ?? \"unknown\",\n    inputTokens: summaries.reduce((acc, s) => acc + s.inputTokens, 0),\n    outputTokens: summaries.reduce((acc, s) => acc + s.outputTokens, 0),\n    totalTokens: summaries.reduce((acc, s) => acc + s.totalTokens, 0),\n    cacheReadTokens: summaries.reduce((acc, s) => acc + s.cacheReadTokens, 0),\n    cacheWriteTokens: summaries.reduce((acc, s) => acc + s.cacheWriteTokens, 0),\n    reasoningTokens: summaries.reduce((acc, s) => acc + s.reasoningTokens, 0),\n    stepCount: summaries.reduce((acc, s) => acc + s.stepCount, 0),\n    messageCount: summaries.length,\n  };\n\n  return { total, byMessageId };\n}\n"],
  "mappings": "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",
  "names": ["opts", "exitCode", "stderr", "errore", "storage", "sandboxRecord", "import_zod", "VercelSandboxSDK", "getStorage", "errore", "import_sandbox", "getTestCredentials", "sandbox", "VercelSandboxSDK", "getSandbox", "sandboxRecord", "init_client", "init_client", "import_workflow", "import_ai", "import_ulid", "import_workflow", "import_ai", "import_zod", "path", "createProcessManager", "getStorage", "getSandbox", "session", "sandboxRecord", "sandbox", "skills", "result", "start", "event"]
}
