experimental-agent 0.0.0

package/dist/agent-workflow.js

@@ -0,0 +1,2659 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sandbox/process-manager.ts
+var process_manager_exports = {};
+__export(process_manager_exports, {
+  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;
+    RUN_SCRIPT = `#!/bin/sh
+# Process runner for Agent SDK
+# All parameters passed via environment variables to avoid escaping issues
+# Output is base64 encoded to avoid JSON escaping issues
+
+AGENT_DIR="$HOME/.agent"
+CWD_FILE="$AGENT_DIR/cwd/$SESSION_ID"
+
+# Get current working directory (per-session)
+if [ -f "$CWD_FILE" ]; then
+  CWD=$(cat "$CWD_FILE")
+else
+  CWD="$HOME"
+fi
+
+# Decode command
+CMD=$(echo "$CMD_BASE64" | base64 -d)
+
+# Background mode (waitUntil = 0)
+if [ "$WAIT_UNTIL" = "0" ]; then
+  cd "$CWD" || cd "$HOME"
+
+  # Generate a simple numeric ID for output file
+  OUTPUT_ID="$(date +%s)$$"
+  OUTPUT_FILE="$AGENT_DIR/outputs/$OUTPUT_ID.log"
+
+  # Double-fork to fully detach the process
+  (
+    (
+      eval "$CMD"
+      pwd > "$CWD_FILE" 2>/dev/null
+    ) > "$OUTPUT_FILE" 2>&1 < /dev/null &
+    echo $! > "$AGENT_DIR/pids/$OUTPUT_ID.pid"
+  )
+
+  # Small delay to ensure PID file is written
+  sleep 0.05
+
+  # Read PID
+  if [ -f "$AGENT_DIR/pids/$OUTPUT_ID.pid" ]; then
+    PID=$(cat "$AGENT_DIR/pids/$OUTPUT_ID.pid")
+  else
+    PID=0
+  fi
+
+  # Output JSON result (no output for background, so no encoding needed)
+  printf '{"pid":%d,"outputBase64":"","exitCode":-1,"status":"running","outputFile":"%s","cwd":"%s"}\\n' \\
+    "$PID" "$OUTPUT_FILE" "$CWD"
+  exit 0
+fi
+
+# Foreground mode (waitUntil > 0) - run directly and capture output
+cd "$CWD" || cd "$HOME"
+
+# Run command, capture output and exit code
+OUTPUT=$(eval "$CMD" 2>&1)
+EXIT_CODE=$?
+
+# Update CWD after command
+NEW_CWD=$(pwd)
+echo "$NEW_CWD" > "$CWD_FILE"
+
+# Determine status
+if [ $EXIT_CODE -eq 0 ]; then
+  STATUS="completed"
+else
+  STATUS="failed"
+fi
+
+# Base64 encode output to avoid ALL escaping issues
+OUTPUT_BASE64=$(printf '%s' "$OUTPUT" | base64 | tr -d '\\n')
+
+# Output JSON result with base64-encoded output
+printf '{"pid":0,"outputBase64":"%s","exitCode":%d,"status":"%s","outputFile":"","cwd":"%s"}\\n' \\
+  "$OUTPUT_BASE64" "$EXIT_CODE" "$STATUS" "$NEW_CWD"
+`;
+    createProcessManager = (opts) => {
+      const { sandbox, sessionId } = opts;
+      let initialized = false;
+      const init = async () => {
+        if (initialized) {
+          return;
+        }
+        const result = await sandbox.exec({
+          command: "sh",
+          args: [
+            "-c",
+            `mkdir -p $HOME/.agent/bin $HOME/.agent/pids $HOME/.agent/outputs $HOME/.agent/cwd
+cat > $HOME/.agent/bin/run.sh << 'SCRIPT_EOF'
+${RUN_SCRIPT}
+SCRIPT_EOF
+chmod +x $HOME/.agent/bin/run.sh`
+          ]
+        });
+        if (result instanceof Error) {
+          throw result;
+        }
+        await result.result;
+        initialized = true;
+      };
+      const run = async (opts2) => {
+        await init();
+        const { command, waitUntil = DEFAULT_WAIT_UNTIL } = opts2;
+        const cmdBase64 = Buffer.from(command, "utf-8").toString("base64");
+        const result = await sandbox.exec({
+          command: "sh",
+          args: [
+            "-c",
+            `CMD_BASE64="${cmdBase64}" WAIT_UNTIL="${waitUntil}" SESSION_ID="${sessionId}" $HOME/.agent/bin/run.sh`
+          ]
+        });
+        if (result instanceof Error) {
+          throw result;
+        }
+        const { stdout } = await result.result;
+        const parsed = JSON.parse(stdout.trim());
+        const output = parsed.outputBase64 ? Buffer.from(parsed.outputBase64, "base64").toString("utf-8") : "";
+        return {
+          pid: parsed.pid,
+          output,
+          exitCode: parsed.exitCode,
+          status: parsed.status,
+          cwd: parsed.cwd,
+          outputFile: parsed.outputFile
+        };
+      };
+      const getCwd = async () => {
+        await init();
+        const result = await sandbox.exec({
+          command: "sh",
+          args: [
+            "-c",
+            `cat $HOME/.agent/cwd/${sessionId} 2>/dev/null || echo "$HOME"`
+          ]
+        });
+        if (result instanceof Error) {
+          return process.cwd();
+        }
+        const { stdout } = await result.result;
+        return stdout.trim() || process.cwd();
+      };
+      return {
+        init,
+        run,
+        getCwd
+      };
+    };
+  }
+});
+
+// src/errors.ts
+var errore, SessionNotFoundError, SessionError, SandboxNotFoundError, StorageError, SandboxError, MessageNotFoundError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    errore = __toESM(require("errore"));
+    SessionNotFoundError = class extends errore.createTaggedError({
+      name: "SessionNotFoundError",
+      message: "Session $id not found"
+    }) {
+    };
+    SessionError = class extends errore.createTaggedError({
+      name: "SessionError",
+      message: "Session $id failed: $reason"
+    }) {
+    };
+    SandboxNotFoundError = class extends errore.createTaggedError({
+      name: "SandboxNotFoundError",
+      message: "Sandbox $id not found"
+    }) {
+    };
+    StorageError = class extends errore.createTaggedError({
+      name: "StorageError",
+      message: "$reason"
+    }) {
+    };
+    SandboxError = class extends errore.createTaggedError({
+      name: "SandboxError",
+      message: "$reason"
+    }) {
+    };
+    MessageNotFoundError = class extends errore.createTaggedError({
+      name: "MessageNotFoundError",
+      message: "Message $id not found"
+    }) {
+    };
+  }
+});
+
+// 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`);
+      await writeJsonFile(sandboxPath, record);
+    },
+    "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, {
+  getStorage: () => getStorage,
+  getStorageClient: () => getStorageClient
+});
+function getStorageClient({ url, headers }) {
+  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 json = await res.json();
+    if ("error" in json) {
+      throw new StorageError({ reason: json.error.message });
+    }
+    return json.result;
+  }
+  return {
+    session: {
+      get: async (id) => {
+        try {
+          const result = await rpc("session.get", { id });
+          if (result === null) {
+            return new SessionNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (session) => {
+        try {
+          return await rpc("session.set", session);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (opts) => {
+        try {
+          return await rpc("session.list", {
+            tags: opts?.tags,
+            order: opts?.order,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      tag: {
+        set: async ({ sessionId, tags }) => {
+          try {
+            return await rpc("session.tag.set", { sessionId, tags });
+          } catch (e) {
+            if (e instanceof StorageError) {
+              return e;
+            }
+            return new StorageError({ reason: String(e), cause: e });
+          }
+        }
+      }
+    },
+    message: {
+      list: async (sessionId, opts) => {
+        try {
+          return await rpc("message.list", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      get: async (id) => {
+        try {
+          const result = await rpc("message.get", { id });
+          if (result === null) {
+            return new MessageNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (message) => {
+        try {
+          return await rpc("message.set", message);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    part: {
+      listByMessage: async (messageId, opts) => {
+        try {
+          const result = await rpc("part.listByMessage", {
+            messageId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      listBySession: async (sessionId, opts) => {
+        try {
+          const result = await rpc("part.listBySession", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (part) => {
+        try {
+          return await rpc("part.set", part);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    sandbox: {
+      get: async (key) => {
+        try {
+          const result = await rpc("sandbox.get", { key });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: key });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      getBySession: async (sessionId) => {
+        try {
+          const result = await rpc("sandbox.getBySession", { sessionId });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: sessionId });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (record) => {
+        try {
+          await rpc("sandbox.set", record);
+          return record;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    command: {
+      get: async (id) => {
+        try {
+          return await rpc("command.get", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (command) => {
+        try {
+          return await rpc("command.set", command);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (sessionId, opts) => {
+        try {
+          const result = await rpc("command.list", {
+            sessionId,
+            includeFinished: opts?.includeFinished,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    }
+  };
+}
+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)
+    },
+    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)
+    }
+  };
+}
+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(),
+      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,
+      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()
+      },
+      "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();
+  }
+});
+
+// src/sandbox/write-files.ts
+async function writeFiles(opts) {
+  const { sandbox, files, destPath } = opts;
+  if (files.length === 0) {
+    return;
+  }
+  const filePaths = files.map((file) => path.posix.join(destPath, file.path));
+  const parentDirs = [...new Set(filePaths.map((p) => path.posix.dirname(p)))];
+  const shellScripts = filePaths.filter((p) => p.endsWith(".sh"));
+  const mkdirResult = await sandbox.exec({
+    command: "mkdir",
+    args: ["-p", ...parentDirs]
+  });
+  if (mkdirResult instanceof Error) {
+    throw mkdirResult;
+  }
+  await mkdirResult.result;
+  const CHUNK_SIZE = 5e4;
+  for (let i = 0; i < files.length; i++) {
+    const file = files[i];
+    const fullPath = filePaths[i];
+    const base64Content = toBase64(file.content);
+    if (base64Content.length < CHUNK_SIZE) {
+      const marker = `EOF_${i}`;
+      const execResult = await sandbox.exec({
+        command: "bash",
+        args: [
+          "-c",
+          `base64 -d > ${quote(fullPath)} << '${marker}'
+${base64Content}
+${marker}`
+        ]
+      });
+      if (execResult instanceof Error) {
+        throw execResult;
+      }
+      const { exitCode, stderr } = await execResult.result;
+      if (exitCode !== 0) {
+        throw new Error(
+          `writeFiles failed with exit code ${exitCode}: ${stderr}`
+        );
+      }
+    } else {
+      const tempB64 = `/tmp/chunk-${Date.now()}-${i}.b64`;
+      const clearResult = await sandbox.exec({
+        command: "bash",
+        args: ["-c", `> ${quote(tempB64)}`]
+      });
+      if (clearResult instanceof Error) {
+        throw clearResult;
+      }
+      await clearResult.result;
+      for (let offset = 0; offset < base64Content.length; offset += CHUNK_SIZE) {
+        const chunk = base64Content.slice(offset, offset + CHUNK_SIZE);
+        const marker = `CHUNK_${offset}`;
+        const appendResult = await sandbox.exec({
+          command: "bash",
+          args: [
+            "-c",
+            `cat >> ${quote(tempB64)} << '${marker}'
+${chunk}
+${marker}`
+          ]
+        });
+        if (appendResult instanceof Error) {
+          throw appendResult;
+        }
+        const { exitCode: exitCode2, stderr: stderr2 } = await appendResult.result;
+        if (exitCode2 !== 0) {
+          throw new Error(
+            `writeFiles chunk failed with exit code ${exitCode2}: ${stderr2}`
+          );
+        }
+      }
+      const decodeResult = await sandbox.exec({
+        command: "bash",
+        args: [
+          "-c",
+          `base64 -d < ${quote(tempB64)} > ${quote(fullPath)} && rm -f ${quote(tempB64)}`
+        ]
+      });
+      if (decodeResult instanceof Error) {
+        throw decodeResult;
+      }
+      const { exitCode, stderr } = await decodeResult.result;
+      if (exitCode !== 0) {
+        throw new Error(
+          `writeFiles decode failed with exit code ${exitCode}: ${stderr}`
+        );
+      }
+    }
+  }
+  if (shellScripts.length > 0) {
+    const chmodResult = await sandbox.exec({
+      command: "chmod",
+      args: ["+x", ...shellScripts]
+    });
+    if (chmodResult instanceof Error) {
+      throw chmodResult;
+    }
+    await chmodResult.result;
+  }
+}
+function toBase64(content) {
+  if (typeof content === "string") {
+    return Buffer.from(content).toString("base64");
+  }
+  return content.toString("base64");
+}
+function quote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var path;
+var init_write_files = __esm({
+  "src/sandbox/write-files.ts"() {
+    "use strict";
+    path = __toESM(require("path"));
+  }
+});
+
+// src/sandbox/bindings/local.ts
+var import_node_child_process, errore2, import_ulid, localSandbox;
+var init_local2 = __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_write_files();
+    localSandbox = ({
+      sandboxRecord
+    }) => {
+      const config = sandboxRecord.config;
+      const basePath = config.path ?? process.cwd();
+      const processes = /* @__PURE__ */ new Map();
+      const sandbox = {
+        id: sandboxRecord.id,
+        config: sandboxRecord.config,
+        exec: ({ command, args, signal }) => {
+          return errore2.tryAsync({
+            try: () => {
+              const commandId = `command_${(0, import_ulid.ulid)()}`;
+              const child = (0, import_node_child_process.spawn)(command, args, {
+                cwd: basePath,
+                signal
+              });
+              processes.set(commandId, child);
+              let stdout = "";
+              let stderr = "";
+              const logQueue = [];
+              let logResolve = null;
+              let closed = false;
+              child.stdout.on("data", (data) => {
+                const str = String(data);
+                stdout += str;
+                logQueue.push({ stream: "stdout", data: str });
+                logResolve?.();
+              });
+              child.stderr.on("data", (data) => {
+                const str = String(data);
+                stderr += str;
+                logQueue.push({ stream: "stderr", data: str });
+                logResolve?.();
+              });
+              const result = new Promise((resolve, reject) => {
+                child.on("error", (err) => {
+                  processes.delete(commandId);
+                  closed = true;
+                  logResolve?.();
+                  reject(err);
+                });
+                child.on("close", (code) => {
+                  processes.delete(commandId);
+                  closed = true;
+                  logResolve?.();
+                  resolve({ stdout, stderr, exitCode: code ?? 0 });
+                });
+              });
+              async function* logs() {
+                while (!closed || logQueue.length > 0) {
+                  const entry = logQueue.shift();
+                  if (entry) {
+                    yield entry;
+                  } else if (!closed) {
+                    await new Promise((resolve) => {
+                      logResolve = resolve;
+                    });
+                    logResolve = null;
+                  }
+                }
+              }
+              return Promise.resolve({ commandId, logs, result });
+            },
+            catch: (e) => new SandboxError({ reason: String(e), cause: e })
+          });
+        },
+        getDomain: (port) => {
+          return Promise.resolve(`http://localhost:${port}`);
+        },
+        kill: async ({ commandId, storage }) => {
+          const child = processes.get(commandId);
+          if (!child) {
+            return new SandboxError({
+              reason: `Command ${commandId} not found or already finished`
+            });
+          }
+          child.kill("SIGTERM");
+          const cmd = await storage.command.get(commandId);
+          if (cmd instanceof Error) {
+            return new SandboxError({ reason: cmd.message, cause: cmd });
+          }
+          if (cmd && cmd.status === "running") {
+            const result = await storage.command.set({
+              ...cmd,
+              status: "killed"
+            });
+            if (result instanceof Error) {
+              return new SandboxError({ reason: result.message, cause: result });
+            }
+          }
+        },
+        writeFiles: (opts) => writeFiles({ sandbox, ...opts })
+      };
+      return sandbox;
+    };
+  }
+});
+
+// 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({
+  "src/sandbox/bindings/vercel.ts"() {
+    "use strict";
+    errore3 = __toESM(require("errore"));
+    import_sandbox = require("sandbox");
+    init_errors();
+    init_storage();
+    init_write_files();
+    VERCEL_MAX_TIMEOUT_MS = 5 * 60 * 60 * 1e3;
+    LOCK_TIMEOUT_MS = 3e4;
+    LOCK_POLL_INTERVAL_MS = 200;
+    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
+    } : {};
+    createPromises = /* @__PURE__ */ new Map();
+    ACTIVITY_THROTTLE_MS = 1e4;
+    lastActivitySent = /* @__PURE__ */ new Map();
+    DEFAULT_VCPUS = 2;
+    vercelSandbox = ({
+      sandboxRecord,
+      storageConfig,
+      enableLifecycleWorkflow = true,
+      storage: storageOverride
+    }) => {
+      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;
+      async function pollForSandboxId() {
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+          await new Promise((r) => setTimeout(r, LOCK_POLL_INTERVAL_MS));
+          const record = await storage.sandbox.get(id);
+          if (record instanceof Error) {
+            return new SandboxError({ reason: record.message, cause: record });
+          }
+          const vercelSandboxId = record?.providerMetadata?.provider === "vercel" ? record.providerMetadata.sandboxId : null;
+          if (vercelSandboxId) {
+            return vercelSandboxId;
+          }
+          if (!record?.acquiringLockAt) {
+            break;
+          }
+        }
+        return new SandboxError({
+          reason: "Timed out waiting for sandbox creation by another process"
+        });
+      }
+      async function createSandboxFromSnapshot(snapshotId) {
+        return await errore3.tryAsync({
+          try: async () => {
+            const sandbox2 = await import_sandbox.Sandbox.create({
+              source: { type: "snapshot", snapshotId },
+              resources: { vcpus },
+              timeout: VERCEL_MAX_TIMEOUT_MS,
+              ports,
+              ...getTestCredentials()
+            });
+            const now = Date.now();
+            await storage.sandbox.set({
+              id,
+              config,
+              createdAt: now,
+              lastActivityAt: now,
+              acquiringLockId: null,
+              acquiringLockAt: null,
+              providerMetadata: {
+                provider: "vercel",
+                sandboxId: sandbox2.sandboxId,
+                snapshotId
+              }
+            });
+            return sandbox2.sandboxId;
+          },
+          catch: (e) => new SandboxError({ reason: String(e), cause: e })
+        });
+      }
+      async function createFreshSandbox() {
+        return await errore3.tryAsync({
+          try: async () => {
+            const sandbox2 = await import_sandbox.Sandbox.create({
+              resources: { vcpus },
+              timeout: VERCEL_MAX_TIMEOUT_MS,
+              ports,
+              ...getTestCredentials()
+            });
+            const now = Date.now();
+            await storage.sandbox.set({
+              id,
+              config,
+              createdAt: now,
+              lastActivityAt: now,
+              acquiringLockId: null,
+              acquiringLockAt: null,
+              providerMetadata: {
+                provider: "vercel",
+                sandboxId: sandbox2.sandboxId,
+                snapshotId: null
+              }
+            });
+            return sandbox2.sandboxId;
+          },
+          catch: (e) => new SandboxError({ reason: String(e), cause: e })
+        });
+      }
+      async function doGetOrCreateSandboxId() {
+        if (initialVercel?.sandboxId) {
+          return initialVercel.sandboxId;
+        }
+        const existing = await storage.sandbox.get(id);
+        if (existing instanceof Error) {
+          return new SandboxError({ reason: existing.message, cause: existing });
+        }
+        const existingVercel = existing?.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
+        if (existingVercel?.sandboxId) {
+          return existingVercel.sandboxId;
+        }
+        const hasActiveLock = existing?.acquiringLockId && existing.acquiringLockAt && Date.now() - existing.acquiringLockAt < LOCK_TIMEOUT_MS;
+        if (hasActiveLock) {
+          return pollForSandboxId();
+        }
+        const lockId = crypto.randomUUID();
+        const now = Date.now();
+        await storage.sandbox.set({
+          id,
+          config,
+          createdAt: existing?.createdAt ?? sandboxRecord.createdAt,
+          lastActivityAt: existing?.lastActivityAt ?? sandboxRecord.lastActivityAt,
+          acquiringLockId: lockId,
+          acquiringLockAt: now,
+          providerMetadata: {
+            provider: "vercel",
+            sandboxId: null,
+            snapshotId: existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? null
+          }
+        });
+        const afterLock = await storage.sandbox.get(id);
+        if (afterLock instanceof Error) {
+          return new SandboxError({ reason: afterLock.message, cause: afterLock });
+        }
+        if (afterLock?.acquiringLockId !== lockId) {
+          return pollForSandboxId();
+        }
+        const snapshotId = existingVercel?.snapshotId ?? initialVercel?.snapshotId ?? config.lifecycle?.snapshotId;
+        if (snapshotId) {
+          const result = await createSandboxFromSnapshot(snapshotId);
+          if (!(result instanceof Error)) {
+            return result;
+          }
+        }
+        return createFreshSandbox();
+      }
+      function getOrCreateSandboxId() {
+        const cached = createPromises.get(id);
+        if (cached) {
+          return cached;
+        }
+        const promise = doGetOrCreateSandboxId().finally(() => {
+          createPromises.delete(id);
+        });
+        createPromises.set(id, promise);
+        return promise;
+      }
+      async function doGetSandbox() {
+        const vercelSandboxId = await getOrCreateSandboxId();
+        if (vercelSandboxId instanceof Error) {
+          return vercelSandboxId;
+        }
+        return errore3.tryAsync({
+          try: () => import_sandbox.Sandbox.get({
+            sandboxId: vercelSandboxId,
+            ...getTestCredentials()
+          }),
+          catch: (e) => new SandboxError({ reason: String(e), cause: e })
+        });
+      }
+      function getSandbox2() {
+        if (!sandboxPromise) {
+          sandboxPromise = doGetSandbox();
+        }
+        return sandboxPromise;
+      }
+      async function updateLastActivity() {
+        const now = Date.now();
+        const lastSent = lastActivitySent.get(id);
+        if (lastSent && now - lastSent < ACTIVITY_THROTTLE_MS) {
+          return;
+        }
+        lastActivitySent.set(id, now);
+        const existing = await storage.sandbox.get(id);
+        if (existing instanceof Error || !existing) {
+          return;
+        }
+        const existingVercel = existing.providerMetadata?.provider === "vercel" ? existing.providerMetadata : null;
+        await storage.sandbox.set({
+          id: existing.id,
+          config: existing.config,
+          createdAt: existing.createdAt,
+          lastActivityAt: now,
+          acquiringLockId: null,
+          acquiringLockAt: null,
+          providerMetadata: existingVercel ?? {
+            provider: "vercel",
+            sandboxId: null,
+            snapshotId: null
+          }
+        });
+        if (enableLifecycleWorkflow) {
+        }
+      }
+      const lifecycle = {
+        start: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          await updateLastActivity();
+          return sandbox2.status;
+        },
+        snapshot: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          return errore3.tryAsync({
+            try: async () => {
+              const existing = await storage.sandbox.get(id);
+              const snapshot = await sandbox2.snapshot();
+              await storage.sandbox.set({
+                id,
+                config,
+                createdAt: existing instanceof Error ? null : existing?.createdAt ?? null,
+                lastActivityAt: existing instanceof Error ? null : existing?.lastActivityAt ?? null,
+                acquiringLockId: null,
+                acquiringLockAt: null,
+                providerMetadata: {
+                  provider: "vercel",
+                  sandboxId: null,
+                  snapshotId: snapshot.snapshotId
+                }
+              });
+              return { snapshotId: snapshot.snapshotId };
+            },
+            catch: (e) => new SandboxError({ reason: String(e), cause: e })
+          });
+        },
+        stop: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          return errore3.tryAsync({
+            try: async () => {
+              await sandbox2.stop();
+              const existing = await storage.sandbox.get(id);
+              if (existing instanceof Error || !existing) {
+                return void 0;
+              }
+              await storage.sandbox.set({
+                id: existing.id,
+                config: existing.config,
+                createdAt: existing.createdAt,
+                lastActivityAt: existing.lastActivityAt,
+                acquiringLockId: null,
+                acquiringLockAt: null,
+                providerMetadata: {
+                  provider: "vercel",
+                  sandboxId: null,
+                  snapshotId: null
+                }
+              });
+              return void 0;
+            },
+            catch: (e) => new SandboxError({ reason: String(e), cause: e })
+          });
+        },
+        getStatus: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          return sandbox2.status;
+        },
+        getCreatedAt: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          return sandbox2.createdAt;
+        },
+        getRemainingTimeout: async () => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          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(command, args, { signal });
+              let stdout = "";
+              let stderr = "";
+              const logBuffer = [];
+              const state = {
+                resolve: null,
+                consumed: false
+              };
+              const consumeLogs = (async () => {
+                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") {
+                    stdout += log.data;
+                  } else {
+                    stderr += log.data;
+                  }
+                  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;
+                  }
+                }
+              }
+              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;
+        },
+        getDomain: async (port) => {
+          const sandbox2 = await getSandbox2();
+          if (sandbox2 instanceof Error) {
+            return sandbox2;
+          }
+          try {
+            return sandbox2.domain(port);
+          } catch (e) {
+            return new SandboxError({ reason: String(e), cause: e });
+          }
+        },
+        kill: async ({ commandId, storage: cmdStorage }) => {
+          const instance = await getSandbox2();
+          if (instance instanceof Error) {
+            return instance;
+          }
+          const cmd = await cmdStorage.command.get(commandId);
+          if (cmd instanceof Error) {
+            return new SandboxError({ reason: cmd.message, cause: cmd });
+          }
+          if (cmd && cmd.status === "running") {
+            const result = await cmdStorage.command.set({
+              ...cmd,
+              status: "killed"
+            });
+            if (result instanceof Error) {
+              return new SandboxError({ reason: result.message, cause: result });
+            }
+          }
+          return void 0;
+        },
+        writeFiles: (opts) => writeFiles({ sandbox, ...opts }),
+        lifecycle
+      };
+      if (config.lifecycle?.autoStart !== false) {
+        sandboxPromise = doGetSandbox();
+      }
+      return sandbox;
+    };
+  }
+});
+
+// src/sandbox/client.ts
+function getSandbox({
+  sandboxRecord,
+  storageConfig
+}) {
+  const { config } = sandboxRecord;
+  switch (config.type) {
+    case "local":
+      return localSandbox({
+        sandboxRecord,
+        storageConfig
+      });
+    case "vercel":
+      return vercelSandbox({
+        sandboxRecord,
+        storageConfig
+      });
+    case "custom":
+      throw new Error("Custom sandboxes are not supported");
+    default:
+      config;
+      throw new Error(
+        `Unknown sandbox type: ${// biome-ignore lint/suspicious/noExplicitAny: .
+        config.type}`
+      );
+  }
+}
+var init_client2 = __esm({
+  "src/sandbox/client.ts"() {
+    "use strict";
+    init_local2();
+    init_vercel2();
+  }
+});
+
+// src/sandbox/index.ts
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  getSandbox: () => getSandbox
+});
+var init_sandbox = __esm({
+  "src/sandbox/index.ts"() {
+    "use strict";
+    init_client2();
+  }
+});
+
+// src/agent-workflow.ts
+var agent_workflow_exports = {};
+__export(agent_workflow_exports, {
+  agentMessageHook: () => agentMessageHook,
+  agentWorkflow: () => agentWorkflow
+});
+module.exports = __toCommonJS(agent_workflow_exports);
+var import_workflow2 = require("workflow");
+
+// src/agent-workflow-steps.ts
+var import_ai2 = require("ai");
+var import_ulid2 = require("ulid");
+var import_workflow = require("workflow");
+
+// src/skills/parser.ts
+function parseSkillFrontmatter(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMarkerIndex = trimmed.indexOf("---", 3);
+  if (endMarkerIndex === -1) {
+    return null;
+  }
+  const frontmatterBlock = trimmed.slice(3, endMarkerIndex).trim();
+  const parsed = parseSimpleYaml(frontmatterBlock);
+  if (!(parsed.name && parsed.description)) {
+    return null;
+  }
+  return {
+    name: String(parsed.name),
+    description: String(parsed.description)
+  };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  for (const line of yaml.split("\n")) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = trimmedLine.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmedLine.slice(0, colonIndex).trim();
+    let value = trimmedLine.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/skills/discover.ts
+async function discoverSkillsInSandbox(opts) {
+  const { sandbox, skillsDirs, debug } = opts;
+  const summaries = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const skillsDir of skillsDirs) {
+    const dirSummaries = await discoverSkillsInDirectory({
+      sandbox,
+      skillsDir,
+      debug
+    });
+    for (const summary of dirSummaries) {
+      if (!seenNames.has(summary.name)) {
+        seenNames.add(summary.name);
+        summaries.push(summary);
+      }
+    }
+  }
+  return summaries;
+}
+async function discoverSkillsInDirectory(opts) {
+  const { sandbox, skillsDir, debug } = opts;
+  const skillPaths = await findSkillFiles({ sandbox, skillsDir, debug });
+  if (skillPaths.length === 0) {
+    return [];
+  }
+  const summaries = [];
+  for (const skillMdPath of skillPaths) {
+    const summary = await parseSkillFile({ sandbox, skillMdPath, debug });
+    if (summary) {
+      summaries.push(summary);
+    }
+  }
+  return summaries;
+}
+async function findSkillFiles(opts) {
+  const { sandbox, skillsDir, debug } = opts;
+  if (debug) {
+    console.log(`[discover] Finding skills in: ${skillsDir}`);
+  }
+  const execResult = await sandbox.exec({
+    command: "find",
+    args: [skillsDir, "-name", "SKILL.md", "-type", "f"]
+  });
+  if (execResult instanceof Error) {
+    if (debug) {
+      console.warn(
+        `[discover] Failed to scan skills directory "${skillsDir}": ${execResult.message}`
+      );
+    }
+    return [];
+  }
+  const { stdout, stderr, exitCode } = await execResult.result;
+  if (debug) {
+    console.log(
+      `[discover] find result: exitCode=${exitCode}, stdout="${stdout.trim()}", stderr="${stderr.trim()}"`
+    );
+  }
+  if (exitCode !== 0) {
+    if (debug) {
+      console.warn(
+        `[discover] Skills directory not found or inaccessible: ${skillsDir}`
+      );
+    }
+    return [];
+  }
+  const paths = stdout.trim().split("\n").filter((p) => p.length > 0);
+  if (debug) {
+    console.log("[discover] Found skill paths:", paths);
+  }
+  return paths;
+}
+async function parseSkillFile(opts) {
+  const { sandbox, skillMdPath, debug } = opts;
+  const execResult = await sandbox.exec({
+    command: "cat",
+    args: [skillMdPath]
+  });
+  if (execResult instanceof Error) {
+    if (debug) {
+      console.warn(
+        `[discover] Failed to read skill file "${skillMdPath}": ${execResult.message}`
+      );
+    }
+    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_ai = require("ai");
+var import_zod = require("zod");
+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")
+        })
+      }),
+      execute: async ({ path: path2, startLine, endLine }) => {
+        const filePath = path2.startsWith("/") ? path2.slice(1) : path2;
+        const result = await context.sandbox.exec({
+          command: "bash",
+          args: [
+            "-c",
+            `
+            set -e
+            FILE="$1"
+            START_LINE="$2"
+            END_LINE="$3"
+
+            # Resolve symlinks and check file exists
+            if [ -L "$FILE" ]; then
+              RESOLVED=$(readlink -f "$FILE" 2>/dev/null || echo "")
+              if [ -z "$RESOLVED" ] || [ ! -e "$RESOLVED" ]; then
+                echo "Error: Broken symlink - $FILE points to non-existent target" >&2
+                exit 1
+              fi
+              FILE="$RESOLVED"
+            elif [ ! -e "$FILE" ]; then
+              echo "Error: File not found - $FILE" >&2
+              exit 1
+            fi
+
+            # Get metadata (count actual lines, not just newlines)
+            TOTAL_LINES=$(awk 'END{print NR}' "$FILE")
+            FILE_SIZE=$(ls -lh "$FILE" | awk '{print $5}')
+
+            # Determine range
+            PAGE_SIZE=100
+            if [ -n "$START_LINE" ] && [ -n "$END_LINE" ]; then
+              # Both provided - use exact range
+              ACTUAL_START=$START_LINE
+              ACTUAL_END=$END_LINE
+            elif [ -n "$START_LINE" ]; then
+              # Only startLine - read PAGE_SIZE lines from there
+              ACTUAL_START=$START_LINE
+              ACTUAL_END=$((START_LINE + PAGE_SIZE - 1))
+              [ "$ACTUAL_END" -gt "$TOTAL_LINES" ] && ACTUAL_END=$TOTAL_LINES
+            elif [ -n "$END_LINE" ]; then
+              # Only endLine - read from beginning to endLine
+              ACTUAL_START=1
+              ACTUAL_END=$END_LINE
+            elif [ "$TOTAL_LINES" -gt 200 ]; then
+              # No range, large file - paginate
+              ACTUAL_START=1
+              ACTUAL_END=$PAGE_SIZE
+            else
+              # No range, small file - show all
+              ACTUAL_START=1
+              ACTUAL_END=$TOTAL_LINES
+            fi
+
+            # Output metadata first (separated by ||| for parsing)
+            echo "$TOTAL_LINES|$FILE_SIZE|$ACTUAL_START|$ACTUAL_END"
+            echo "|||CONTENT|||"
+
+            # Read content
+            if [ "$ACTUAL_START" -eq 1 ] && [ "$ACTUAL_END" -eq "$TOTAL_LINES" ]; then
+              cat "$FILE"
+            else
+              sed -n "\${ACTUAL_START},\${ACTUAL_END}p" "$FILE"
+            fi
+          `,
+            "--",
+            filePath,
+            startLine?.toString() || "",
+            endLine?.toString() || ""
+          ]
+        });
+        if (result instanceof Error) {
+          console.error("[Read Tool]", result);
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr) {
+          console.error(`[Read Tool] Error: ${stderr}`);
+          return {
+            content: `Error: ${stderr}`,
+            metadata: {
+              totalLines: 0,
+              linesShown: 0,
+              startLine: 0,
+              endLine: 0,
+              isPaginated: false,
+              fileSize: "0",
+              path: filePath
+            }
+          };
+        }
+        const [metadataLine, ...rest] = stdout.split("|||CONTENT|||");
+        const content = rest.join("|||CONTENT|||").trimStart();
+        const [totalLinesStr, fileSize, actualStartStr, actualEndStr] = metadataLine.trim().split("|");
+        const totalLines = Number.parseInt(totalLinesStr, 10);
+        const actualStart = Number.parseInt(actualStartStr, 10);
+        const actualEnd = Number.parseInt(actualEndStr, 10);
+        if (Number.isNaN(totalLines) || Number.isNaN(actualStart) || Number.isNaN(actualEnd)) {
+          console.error(
+            `[Read Tool] Failed to parse metadata: ${metadataLine}`
+          );
+          return {
+            content: `Error: Failed to parse file metadata. Raw output: ${stdout.slice(
+              0,
+              500
+            )}`,
+            metadata: {
+              totalLines: 0,
+              linesShown: 0,
+              startLine: 0,
+              endLine: 0,
+              isPaginated: false,
+              fileSize: "unknown",
+              path: filePath
+            }
+          };
+        }
+        return {
+          content,
+          metadata: {
+            totalLines,
+            linesShown: Math.max(0, actualEnd - actualStart + 1),
+            startLine: actualStart,
+            endLine: actualEnd,
+            isPaginated: actualEnd < totalLines,
+            fileSize: fileSize || "unknown",
+            path: filePath
+          }
+        };
+      }
+    }),
+    Grep: (0, import_ai.tool)({
+      description: "Search for patterns in files using ripgrep. Supports regex patterns, file type filtering, and context lines. Returns matching lines with file paths and line numbers. 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")
+        })
+      }),
+      execute: async ({
+        pattern,
+        path: path2,
+        fileType,
+        glob,
+        caseSensitive,
+        contextLines,
+        maxCount,
+        filesWithMatches
+      }) => {
+        let searchPath = path2 ?? ".";
+        if (searchPath.startsWith("/")) {
+          searchPath = searchPath.slice(1);
+        }
+        const args = [];
+        args.push("--line-number");
+        args.push("--heading");
+        args.push("--color", "never");
+        if (!caseSensitive) {
+          args.push("-i");
+        }
+        if (fileType) {
+          args.push("--type", fileType);
+        }
+        if (glob) {
+          args.push("--glob", glob);
+        }
+        if (contextLines !== void 0) {
+          args.push("-C", String(contextLines));
+        }
+        if (maxCount !== void 0) {
+          args.push("--max-count", String(maxCount));
+        }
+        if (filesWithMatches) {
+          args.push("--files-with-matches");
+        }
+        args.push("--", pattern, searchPath);
+        const result = await context.sandbox.exec({ command: "rg", args });
+        if (result instanceof Error) {
+          console.error("[Grep Tool]", result);
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr && !stderr.toLowerCase().includes("no matches")) {
+          console.error(`[Grep Tool] Warning: ${stderr}`);
+        }
+        const MAX_GREP_OUTPUT_CHARS = 5e4;
+        let finalOutput = stdout;
+        let wasTruncated = false;
+        if (finalOutput.length > MAX_GREP_OUTPUT_CHARS) {
+          finalOutput = finalOutput.slice(0, MAX_GREP_OUTPUT_CHARS) + "\n\n[Output truncated - use more specific pattern or path]";
+          wasTruncated = true;
+        }
+        const lines = finalOutput.trim().split("\n").filter((l) => l.length > 0);
+        const fileCount = filesWithMatches ? lines.length : new Set(
+          lines.filter((l) => !l.startsWith(" ") && l.includes(":")).map((l) => l.split(":")[0])
+        ).size;
+        return {
+          matches: finalOutput || "(no matches found)",
+          summary: {
+            matchCount: filesWithMatches ? 0 : lines.filter((l) => l.includes(":")).length,
+            fileCount,
+            searchPath,
+            pattern,
+            wasTruncated
+          }
+        };
+      }
+    }),
+    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)")
+        })
+      }),
+      execute: async ({ path: path2, depth, includeHidden, filesOnly, pattern }) => {
+        const searchPath = path2 ?? ".";
+        const result = await context.sandbox.exec({
+          command: "bash",
+          args: [
+            "-c",
+            `
+            set -e
+            SEARCH_PATH="$1"
+            DEPTH="$2"
+            INCLUDE_HIDDEN="$3"
+            FILES_ONLY="$4"
+            PATTERN="$5"
+
+            # Build find command arguments
+            FIND_ARGS=""
+            [ -n "$DEPTH" ] && FIND_ARGS="$FIND_ARGS -maxdepth $DEPTH"
+            [ "$INCLUDE_HIDDEN" != "true" ] && FIND_ARGS="$FIND_ARGS ! -path '*/.*'"
+            [ "$FILES_ONLY" = "true" ] && FIND_ARGS="$FIND_ARGS -type f"
+            [ -n "$PATTERN" ] && FIND_ARGS="$FIND_ARGS -name '$PATTERN'"
+
+            # Get listing
+            LISTING=$(eval "find '$SEARCH_PATH' $FIND_ARGS" 2>/dev/null | sort)
+
+            # Get counts
+            COUNT_ARGS=""
+            [ -n "$DEPTH" ] && COUNT_ARGS="$COUNT_ARGS -maxdepth $DEPTH"
+            [ "$INCLUDE_HIDDEN" != "true" ] && COUNT_ARGS="$COUNT_ARGS ! -path '*/.*'"
+
+            FILE_COUNT=$(eval "find '$SEARCH_PATH' $COUNT_ARGS -type f" 2>/dev/null | wc -l)
+            DIR_COUNT=$(eval "find '$SEARCH_PATH' $COUNT_ARGS -type d" 2>/dev/null | wc -l)
+
+            # Output: counts first, then listing
+            echo "$FILE_COUNT|$DIR_COUNT"
+            echo "|||LISTING|||"
+            echo "$LISTING" | sed "s|^$SEARCH_PATH|.|"
+          `,
+            "--",
+            searchPath,
+            depth?.toString() || "",
+            includeHidden ? "true" : "false",
+            filesOnly ? "true" : "false",
+            pattern || ""
+          ]
+        });
+        if (result instanceof Error) {
+          console.error("[List Tool]", result);
+          throw result;
+        }
+        const { stdout, stderr } = await result.result;
+        if (stderr) {
+          console.warn(`[List Tool] stderr: ${stderr}`);
+        }
+        const [countsLine, ...rest] = stdout.split("|||LISTING|||");
+        const listing = rest.join("|||LISTING|||").trim();
+        const [fileCountStr, dirCountStr] = countsLine.trim().split("|");
+        const totalFiles = Number.parseInt(fileCountStr, 10) || 0;
+        const totalDirs = Number.parseInt(dirCountStr, 10) || 0;
+        const lines = listing.split("\n").filter((l) => l.length > 0);
+        return {
+          listing,
+          summary: {
+            totalItems: lines.length,
+            totalFiles,
+            totalDirs,
+            searchPath,
+            depth
+          }
+        };
+      }
+    }),
+    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)")
+      }),
+      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()
+        });
+        await processManager.init();
+        return processManager.run({ command, waitUntil });
+      }
+    }),
+    ExecuteMCPTool: (0, import_ai.tool)({
+      description: "Execute a tool from an MCP server. Use this to call custom tools provided by the application.",
+      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().describe("Tool execution result"),
+        truncated: import_zod.z.boolean().optional().describe("Whether the result was truncated due to size"),
+        totalChars: import_zod.z.number().optional().describe("Total characters in full output (only if truncated)"),
+        returnedChars: import_zod.z.number().optional().describe("Characters returned in this response (only if truncated)"),
+        fullOutputPath: import_zod.z.string().optional().describe("Path to full output file if truncated")
+      }),
+      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 MAX_OUTPUT_CHARS = 24e3;
+        const resultStr = JSON.stringify(result, null, 2);
+        if (resultStr.length <= MAX_OUTPUT_CHARS) {
+          return { result };
+        }
+        await context.sandbox.writeFiles({
+          files: [{ path: `${timestamp}-${toolName}.txt`, content: resultStr }],
+          destPath: outputDir
+        });
+        const truncatedResult = resultStr.slice(0, MAX_OUTPUT_CHARS) + `
+
+[Output truncated at ~6k tokens. Full output saved to: ${outputFile}]`;
+        return {
+          result: truncatedResult,
+          truncated: true,
+          totalChars: resultStr.length,
+          returnedChars: MAX_OUTPUT_CHARS,
+          fullOutputPath: outputFile
+        };
+      }
+    })
+  };
+}
+
+// src/utils/ui.ts
+function assembleUIMessages(opts) {
+  const partsByMessage = /* @__PURE__ */ new Map();
+  for (const part of opts.parts) {
+    const existing = partsByMessage.get(part.messageId) ?? [];
+    existing.push(part);
+    partsByMessage.set(part.messageId, existing);
+  }
+  return opts.messages.map((m) => {
+    const messageParts = partsByMessage.get(m.id) ?? [];
+    messageParts.sort((a, b) => a.index - b.index);
+    return {
+      id: m.id,
+      role: m.role,
+      parts: messageParts.map((p) => p.part)
+    };
+  });
+}
+
+// src/agent-workflow-steps.ts
+var BASE_SYSTEM_PROMPT = "You are an AI assistant with basic tools to interact with your environment. Explore and work freely.";
+function joinPromptSections(...sections) {
+  return sections.filter((s) => s?.trim()).join("\n\n");
+}
+function buildSkillsContext(skills) {
+  if (skills.length === 0) {
+    return "";
+  }
+  const skillLines = skills.map((s) => `- ${s.name}: ${s.description}
+  Path: ${s.skillMdPath}`).join("\n");
+  return `## Available Skills
+${skillLines}
+
+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
+}) {
+  "use step";
+  const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+  const storage = getStorage2(input.storageConfig);
+  const message = await storage.message.get(assistantMessageId);
+  if (message instanceof Error) {
+    throw message;
+  }
+  if (!message) {
+    throw new Error(`Message ${assistantMessageId} not found`);
+  }
+  const result = await storage.message.set({
+    ...message,
+    completedAt: Date.now()
+  });
+  if (result instanceof Error) {
+    throw result;
+  }
+  await writable.close();
+}
+async function streamTextStep({
+  assistantMessageId,
+  input,
+  event,
+  writable,
+  lastPartIndex
+}) {
+  "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 [messagesResult, partsResult, skills] = await Promise.all([
+    storage.message.list(input.sessionId),
+    storage.part.listBySession(input.sessionId),
+    session.skillsDir && session.skillsDir.length > 0 ? discoverSkillsInSandbox({ sandbox, skillsDirs: session.skillsDir }) : Promise.resolve([])
+  ]);
+  if (messagesResult instanceof Error) {
+    throw messagesResult;
+  }
+  if (partsResult instanceof Error) {
+    throw partsResult;
+  }
+  const uiMessages = assembleUIMessages({
+    messages: messagesResult.items,
+    parts: partsResult.items
+  });
+  const mcp = session.mcp;
+  const systemPrompt = joinPromptSections(
+    BASE_SYSTEM_PROMPT,
+    session.instructions,
+    buildSkillsContext(skills),
+    buildMcpToolsContext(mcp)
+  );
+  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,
+    model: session.model
+  });
+  const stepParts = [];
+  await result.toUIMessageStream({
+    generateMessageId: () => assistantMessageId,
+    onFinish: ({ messages }) => {
+      for (const m of messages) {
+        if (m.role === "assistant") {
+          stepParts.push(...m.parts);
+        }
+      }
+    }
+  }).pipeTo(writable, { preventClose: true });
+  await Promise.all(
+    stepParts.map(async (uiPart, index) => {
+      const result2 = await storage.part.set({
+        id: `part_${(0, import_ulid2.ulid)()}`,
+        index: lastPartIndex + index,
+        messageId: assistantMessageId,
+        sessionId: input.sessionId,
+        part: uiPart
+      });
+      if (result2 instanceof Error) {
+        throw result2;
+      }
+      return result2;
+    })
+  );
+  return {
+    finishReason: await result.finishReason,
+    lastPartIndex: lastPartIndex + stepParts.length
+  };
+}
+
+// src/agent-workflow.ts
+var agentMessageHook = (0, import_workflow2.defineHook)();
+async function agentWorkflow({
+  input,
+  event
+}) {
+  "use workflow";
+  const messageHook = agentMessageHook.create({ token: input.sessionId });
+  const iterator = messageHook[Symbol.asyncIterator]();
+  let pendingNext = iterator.next();
+  await onMessage({ event, input }).catch((e) => {
+    if (import_workflow2.FatalError.is(e)) {
+      console.error("Message processing failed permanently:", e.message);
+      return;
+    }
+    throw e;
+  });
+  while (true) {
+    const result = await pendingNext;
+    if (result.done) {
+      console.error("Unexpected: message hook iterator done");
+      break;
+    }
+    await onMessage({ event: result.value, input }).catch((e) => {
+      if (import_workflow2.FatalError.is(e)) {
+        console.error("Message processing failed permanently:", e.message);
+        return;
+      }
+      throw e;
+    });
+    pendingNext = iterator.next();
+  }
+}
+async function onMessage({
+  event,
+  input
+}) {
+  const writable = (0, import_workflow2.getWritable)({ namespace: event.assistantMessageId });
+  let finishReason;
+  let lastPartIndex = 0;
+  while (finishReason !== "stop") {
+    try {
+      const result = await streamTextStep({
+        assistantMessageId: event.assistantMessageId,
+        writable,
+        input,
+        event,
+        lastPartIndex
+      });
+      finishReason = result.finishReason;
+      lastPartIndex = result.lastPartIndex;
+    } catch (err) {
+      console.error(err);
+      throw err;
+    }
+  }
+  await completeMessageStep({
+    assistantMessageId: event.assistantMessageId,
+    input,
+    writable
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentMessageHook,
+  agentWorkflow
+});
+//# 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      await writeJsonFile(sandboxPath, record);\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    },\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    },\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  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  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  \"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) => path.posix.join(destPath, file.path));\n  const parentDirs = [...new Set(filePaths.map((p) => path.posix.dirname(p)))];\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 (let offset = 0; offset < base64Content.length; offset += CHUNK_SIZE) {\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 { SandboxRecord, StorageConfig } from \"../../storage/types\";\nimport type { LogEntry, Sandbox } from \"../types\";\nimport { writeFiles } from \"../write-files\";\n\nexport const localSandbox = ({\n  sandboxRecord,\n}: {\n  sandboxRecord: SandboxRecord & { config: { type: \"local\" } };\n  storageConfig: StorageConfig;\n}): Sandbox => {\n  const config = sandboxRecord.config;\n  const basePath = config.path ?? process.cwd();\n  const processes = new Map<string, ChildProcess>();\n\n  const sandbox: Sandbox = {\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\n  return sandbox;\n};\n", "import * as errore from \"errore\";\nimport { Sandbox as VercelSandboxSDK } from \"sandbox\";\nimport { SandboxError } from \"../../errors\";\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 = 30_000; // 30 seconds - 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 = ({\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 => {\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\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        break;\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          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          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      return new SandboxError({ reason: existing.message, cause: existing });\n    }\n\n    const existingVercel =\n      existing?.providerMetadata?.provider === \"vercel\"\n        ? existing.providerMetadata\n        : null;\n\n    if (existingVercel?.sandboxId) {\n      return existingVercel.sandboxId;\n    }\n\n    const hasActiveLock =\n      existing?.acquiringLockId &&\n      existing.acquiringLockAt &&\n      Date.now() - existing.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      createdAt: existing?.createdAt ?? sandboxRecord.createdAt,\n      lastActivityAt: existing?.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      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            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            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 = {\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(command, args, { signal });\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\n  if (config.lifecycle?.autoStart !== false) {\n    sandboxPromise = doGetSandbox();\n  }\n\n  return sandbox;\n};\n", "import type { SandboxRecord, StorageConfig } from \"../storage\";\nimport { localSandbox } from \"./bindings/local\";\nimport { vercelSandbox } from \"./bindings/vercel\";\nimport type { Sandbox } from \"./types\";\n\nexport function getSandbox({\n  sandboxRecord,\n  storageConfig,\n}: {\n  storageConfig: StorageConfig;\n  sandboxRecord: SandboxRecord;\n}): Sandbox {\n  const { config } = sandboxRecord;\n  switch (config.type) {\n    case \"local\":\n      return localSandbox({\n        sandboxRecord: sandboxRecord as SandboxRecord & {\n          config: { type: \"local\" };\n        },\n        storageConfig,\n      });\n    case \"vercel\":\n      return vercelSandbox({\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 { 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\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\nYou can use the Read tool to read any skill's SKILL.md file to learn more about it.`;\n}\n\nfunction buildMcpToolsContext(mcp: McpServerSchema[] | null | undefined): 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\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 [messagesResult, partsResult, skills] = await Promise.all([\n    storage.message.list(input.sessionId),\n    storage.part.listBySession(input.sessionId),\n    session.skillsDir && session.skillsDir.length > 0\n      ? discoverSkillsInSandbox({ sandbox, skillsDirs: session.skillsDir })\n      : Promise.resolve([]),\n  ]);\n\n  if (messagesResult instanceof Error) {\n    throw messagesResult;\n  }\n  if (partsResult instanceof Error) {\n    throw partsResult;\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 systemPrompt = joinPromptSections(\n    BASE_SYSTEM_PROMPT,\n    session.instructions,\n    buildSkillsContext(skills),\n    buildMcpToolsContext(mcp)\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  });\n\n  const stepParts: UIMessage[\"parts\"] = [];\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\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  return {\n    finishReason: await result.finishReason,\n    lastPartIndex: lastPartIndex + stepParts.length,\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  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  if (debug) {\n    console.log(`[discover] Finding skills in: ${skillsDir}`);\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.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            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          content,\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        };\n      },\n    }),\n    Grep: tool({\n      description:\n        \"Search for patterns in files using ripgrep. Supports regex patterns, file type filtering, and context lines. Returns matching lines with file paths and line numbers. 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        let searchPath = path ?? \".\";\n        if (searchPath.startsWith(\"/\")) {\n          searchPath = searchPath.slice(1);\n        }\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          matches: finalOutput || \"(no matches found)\",\n          summary: {\n            matchCount: filesWithMatches\n              ? 0\n              : lines.filter((l) => l.includes(\":\")).length,\n            fileCount,\n            searchPath,\n            pattern,\n            wasTruncated,\n          },\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          listing,\n          summary: {\n            totalItems: lines.length,\n            totalFiles,\n            totalDirs,\n            searchPath,\n            depth,\n          },\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:\n        \"Execute a tool from an MCP server. Use this to call custom tools provided by the application.\",\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.unknown().describe(\"Tool execution result\"),\n        truncated: z\n          .boolean()\n          .optional()\n          .describe(\"Whether the result was truncated due to size\"),\n        totalChars: z\n          .number()\n          .optional()\n          .describe(\"Total characters in full output (only if truncated)\"),\n        returnedChars: z\n          .number()\n          .optional()\n          .describe(\"Characters returned in this response (only if truncated)\"),\n        fullOutputPath: z\n          .string()\n          .optional()\n          .describe(\"Path to full output file if truncated\"),\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 MAX_OUTPUT_CHARS = 24_000;\n        const resultStr = JSON.stringify(result, null, 2);\n\n        if (resultStr.length <= MAX_OUTPUT_CHARS) {\n          return { result };\n        }\n\n        await context.sandbox.writeFiles({\n          files: [{ path: `${timestamp}-${toolName}.txt`, content: resultStr }],\n          destPath: outputDir,\n        });\n\n        const truncatedResult =\n          resultStr.slice(0, MAX_OUTPUT_CHARS) +\n          `\\n\\n[Output truncated at ~6k tokens. Full output saved to: ${outputFile}]`;\n\n        return {\n          result: truncatedResult,\n          truncated: true,\n          totalChars: resultStr.length,\n          returnedChars: MAX_OUTPUT_CHARS,\n          fullOutputPath: outputFile,\n        };\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", "errore", "init_vercel", "sandbox", "VercelSandboxSDK", "getSandbox", "init_client", "init_local", "init_vercel", "init_client", "import_workflow", "import_ai", "import_ulid", "path", "createProcessManager", "getStorage", "getSandbox", "result"]
}
