experimental-agent 0.2.3 → 0.4.0

package/dist/chunk-GKASMIBR.mjs

@@ -0,0 +1,50 @@
+import {
+  checkAndSnapshotStep
+} from "./chunk-JO3JDCH5.mjs";
+import {
+  createLogger
+} from "./chunk-MSWINCCM.mjs";
+
+// src/sandbox/bindings/vercel-lifecycle/workflow.ts
+import { sleep } from "workflow";
+var DEFAULT_POLL_MS = 2 * 60 * 1e3;
+async function sandboxLifecycleWorkflow({
+  input
+}) {
+  "use workflow";
+  let nextPollMs = input.config?.pollIntervalMs ?? DEFAULT_POLL_MS;
+  const log = createLogger({
+    config: { ...input.agent.options.logging, name: input.agent.name },
+    subsystem: "sandbox:lifecycle",
+    context: { sandboxId: input.sandboxId }
+  });
+  log.info("lifecycle workflow started", {
+    sandboxId: input.sandboxId,
+    vercelSandboxId: input.vercelSandboxId,
+    pollMs: nextPollMs
+  });
+  while (true) {
+    await sleep(nextPollMs);
+    const result = await checkAndSnapshotStep(input);
+    if (result instanceof Error) {
+      log.error("lifecycle step failed", {
+        sandboxId: input.sandboxId,
+        error: result.message
+      });
+      break;
+    }
+    if (result.action === "exit") {
+      log.info("lifecycle workflow exiting", {
+        sandboxId: input.sandboxId,
+        reason: result.reason
+      });
+      break;
+    }
+    nextPollMs = result.nextPollMs;
+  }
+}
+
+export {
+  sandboxLifecycleWorkflow
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-IV75IMEW.mjs

@@ -0,0 +1,328 @@
+// src/storage/adapter.ts
+import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@workflow/serde";
+var StorageStep = class _StorageStep {
+  event;
+  constructor(event) {
+    this.event = event;
+  }
+  static [WORKFLOW_SERIALIZE](instance) {
+    return { event: instance.event };
+  }
+  static [WORKFLOW_DESERIALIZE](data) {
+    return new _StorageStep(data.event);
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: safe dispatch — event.method selects the matching handler
+  on(handlers) {
+    return handlers[this.event.method](this.event);
+  }
+};
+function isStepFunction(h) {
+  return typeof h === "function";
+}
+function fromStepFunction(fn) {
+  return {
+    session: {
+      get: (id) => fn(new StorageStep({ method: "session.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "session.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "session.update", id, updates }))
+    },
+    message: {
+      get: (id) => fn(new StorageStep({ method: "message.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "message.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "message.update", id, updates })),
+      listBySession: (sessionId) => fn(new StorageStep({ method: "message.listBySession", sessionId }))
+    },
+    part: {
+      get: (id) => fn(new StorageStep({ method: "part.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "part.set", id, value })),
+      listBySession: (sessionId) => fn(new StorageStep({ method: "part.listBySession", sessionId }))
+    },
+    sandbox: {
+      get: (id) => fn(new StorageStep({ method: "sandbox.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "sandbox.set", id, value })),
+      update: (id, updates) => fn(new StorageStep({ method: "sandbox.update", id, updates }))
+    },
+    setup: {
+      get: (id) => fn(new StorageStep({ method: "setup.get", id })),
+      set: (id, value) => fn(new StorageStep({ method: "setup.set", id, value }))
+    }
+  };
+}
+function fromHandlers(h) {
+  return {
+    session: {
+      get: (id) => h["session.get"]({ id }),
+      set: (id, value) => h["session.set"]({ id, value }),
+      update: (id, updates) => h["session.update"]({ id, updates })
+    },
+    message: {
+      get: (id) => h["message.get"]({ id }),
+      set: (id, value) => h["message.set"]({ id, value }),
+      update: (id, updates) => h["message.update"]({ id, updates }),
+      listBySession: (sessionId) => h["message.listBySession"]({ sessionId })
+    },
+    part: {
+      get: (id) => h["part.get"]({ id }),
+      set: (id, value) => h["part.set"]({ id, value }),
+      listBySession: (sessionId) => h["part.listBySession"]({ sessionId })
+    },
+    sandbox: {
+      get: (id) => h["sandbox.get"]({ id }),
+      set: (id, value) => h["sandbox.set"]({ id, value }),
+      update: (id, updates) => h["sandbox.update"]({ id, updates })
+    },
+    setup: {
+      get: (id) => h["setup.get"]({ id }),
+      set: (id, value) => h["setup.set"]({ id, value })
+    }
+  };
+}
+function toStorage(h) {
+  return isStepFunction(h) ? fromStepFunction(h) : fromHandlers(h);
+}
+
+// src/storage/bindings/kv.ts
+async function initKvStores(prefix) {
+  const { createKV } = await import("@vercel/kv2");
+  const kv = createKV({ prefix }).getStore("agent/");
+  return {
+    sessions: kv.getStore("session/"),
+    messages: kv.getStore("message/").withIndexes({
+      bySessionId: { key: (m) => m.sessionId }
+    }),
+    parts: kv.getStore("part/").withIndexes({
+      bySessionId: { key: (p) => p.sessionId }
+    }),
+    sandboxes: kv.getStore("sandbox/"),
+    setups: kv.getStore("setup/")
+  };
+}
+function kvStorageFallback(opts) {
+  let storesPromise;
+  function getStores() {
+    if (!storesPromise) {
+      storesPromise = initKvStores(opts.prefix);
+    }
+    return storesPromise;
+  }
+  const tag = `[agent.${opts.prefix}][kv2]`;
+  return {
+    "session.get": async ({ id }) => {
+      const { sessions } = await getStores();
+      return await sessions.getValue(id) ?? null;
+    },
+    "session.set": async ({ id, value }) => {
+      const { sessions } = await getStores();
+      await sessions.set(id, value);
+    },
+    "session.update": async ({ id, updates }) => {
+      const { sessions } = await getStores();
+      const existing = await sessions.getValue(id);
+      if (!existing) {
+        throw new Error(
+          `${tag}[session.update] no session found with id "${id}"`
+        );
+      }
+      const updated = { ...existing, ...updates };
+      await sessions.set(id, updated);
+      return updated;
+    },
+    "message.get": async ({ id }) => {
+      const { messages } = await getStores();
+      return await messages.getValue(id) ?? null;
+    },
+    "message.set": async ({ id, value }) => {
+      const { messages } = await getStores();
+      await messages.set(id, value);
+    },
+    "message.update": async ({ id, updates }) => {
+      const { messages } = await getStores();
+      const existing = await messages.getValue(id);
+      if (!existing) {
+        throw new Error(
+          `${tag}[message.update] no message found with id "${id}"`
+        );
+      }
+      const updated = { ...existing, ...updates };
+      await messages.set(id, updated);
+      return updated;
+    },
+    "message.listBySession": async ({ sessionId }) => {
+      const { messages } = await getStores();
+      const result = [];
+      for await (const [, entry] of messages.entries({
+        bySessionId: sessionId
+      })) {
+        result.push(await entry.value);
+      }
+      return result;
+    },
+    "part.get": async ({ id }) => {
+      const { parts } = await getStores();
+      return await parts.getValue(id) ?? null;
+    },
+    "part.set": async ({ id, value }) => {
+      const { parts } = await getStores();
+      await parts.set(id, value);
+    },
+    "part.listBySession": async ({ sessionId }) => {
+      const { parts } = await getStores();
+      const result = [];
+      for await (const [, entry] of parts.entries({
+        bySessionId: sessionId
+      })) {
+        result.push(await entry.value);
+      }
+      return result;
+    },
+    "sandbox.get": async ({ id }) => {
+      const { sandboxes } = await getStores();
+      return await sandboxes.getValue(id) ?? null;
+    },
+    "sandbox.set": async ({ id, value }) => {
+      const { sandboxes } = await getStores();
+      await sandboxes.set(id, value);
+    },
+    "sandbox.update": async ({ id, updates }) => {
+      const { sandboxes } = await getStores();
+      const existing = await sandboxes.getValue(id);
+      if (!existing) {
+        throw new Error(
+          `${tag}[sandbox.update] no sandbox found with id "${id}"`
+        );
+      }
+      const updated = { ...existing, ...updates };
+      await sandboxes.set(id, updated);
+      return updated;
+    },
+    "setup.get": async ({ id }) => {
+      const { setups } = await getStores();
+      return await setups.getValue(id) ?? null;
+    },
+    "setup.set": async ({ id, value }) => {
+      const { setups } = await getStores();
+      await setups.set(id, value);
+    }
+  };
+}
+
+// src/storage/bindings/local.ts
+var _fs;
+var _path;
+async function fs() {
+  if (!_fs) {
+    _fs = await import("fs/promises");
+  }
+  return _fs;
+}
+async function path() {
+  if (!_path) {
+    _path = await import("path");
+  }
+  return _path;
+}
+function createStore(dir) {
+  const filePath = async (key) => (await path()).join(dir, `${key}.json`);
+  return {
+    async get(key) {
+      try {
+        const data = await (await fs()).readFile(await filePath(key), "utf-8");
+        return JSON.parse(data);
+      } catch {
+        return null;
+      }
+    },
+    async set(key, value) {
+      const p = await filePath(key);
+      const { mkdir, writeFile } = await fs();
+      const { dirname } = await path();
+      await mkdir(dirname(p), { recursive: true });
+      await writeFile(p, JSON.stringify(value, null, 2));
+    },
+    async update(key, updates) {
+      const p = await filePath(key);
+      const { readFile, mkdir, writeFile } = await fs();
+      const { dirname } = await path();
+      let existing;
+      try {
+        const data = await readFile(p, "utf-8");
+        existing = JSON.parse(data);
+      } catch {
+        throw new Error(`Not found: ${key}`);
+      }
+      const updated = { ...existing, ...updates };
+      await mkdir(dirname(p), { recursive: true });
+      await writeFile(p, JSON.stringify(updated, null, 2));
+      return updated;
+    }
+  };
+}
+async function readAllFromDir(dir) {
+  const { readdir, readFile } = await fs();
+  const { join } = await path();
+  let files;
+  try {
+    files = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const data = await readFile(join(dir, file), "utf-8");
+      result.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  return result;
+}
+function localStorage(opts) {
+  const dir = opts?.dir ?? ".agent";
+  const sessionStore = createStore(`${dir}/session`);
+  const messageStore = createStore(`${dir}/message`);
+  const partStore = createStore(`${dir}/part`);
+  const sandboxStore = createStore(`${dir}/sandbox`);
+  const setupStore = createStore(`${dir}/setup`);
+  const messageDir = `${dir}/message`;
+  const partDir = `${dir}/part`;
+  return {
+    "session.get": ({ id }) => sessionStore.get(id),
+    "session.set": ({ id, value }) => sessionStore.set(id, value),
+    "session.update": ({ id, updates }) => sessionStore.update(id, updates),
+    "message.get": ({ id }) => messageStore.get(id),
+    "message.set": ({ id, value }) => messageStore.set(id, value),
+    "message.update": ({ id, updates }) => messageStore.update(id, updates),
+    "message.listBySession": async ({ sessionId }) => {
+      const all = await readAllFromDir(messageDir);
+      return all.filter((m) => m.sessionId === sessionId);
+    },
+    "part.get": ({ id }) => partStore.get(id),
+    "part.set": ({ id, value }) => partStore.set(id, value),
+    "part.listBySession": async ({ sessionId }) => {
+      const all = await readAllFromDir(partDir);
+      return all.filter((p) => p.sessionId === sessionId);
+    },
+    "sandbox.get": ({ id }) => sandboxStore.get(id),
+    "sandbox.set": ({ id, value }) => sandboxStore.set(id, value),
+    "sandbox.update": ({ id, updates }) => sandboxStore.update(id, updates),
+    "setup.get": ({ id }) => setupStore.get(id),
+    "setup.set": ({ id, value }) => setupStore.set(id, value)
+  };
+}
+
+// src/storage/should-fallback-kv2.ts
+function shouldFallbackToKV2() {
+  return !!process.env.BLOB_READ_WRITE_TOKEN;
+}
+
+export {
+  StorageStep,
+  toStorage,
+  kvStorageFallback,
+  localStorage,
+  shouldFallbackToKV2
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/adapter.ts", "../src/storage/bindings/kv.ts", "../src/storage/bindings/local.ts", "../src/storage/should-fallback-kv2.ts"],
  "sourcesContent": ["import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from \"@workflow/serde\";\nimport type { Message, Part, Sandbox, Session, Setup } from \"./types\";\n\n// \u2500\u2500\u2500 StorageHandlers (public, flat) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type StorageHandlers = {\n  \"session.get\"(p: { id: string }): Promise<Session | null>;\n  \"session.set\"(p: { id: string; value: Session }): Promise<void>;\n  \"session.update\"(p: {\n    id: string;\n    updates: Partial<Session>;\n  }): Promise<Session>;\n\n  \"message.get\"(p: { id: string }): Promise<Message | null>;\n  \"message.set\"(p: { id: string; value: Message }): Promise<void>;\n  \"message.update\"(p: {\n    id: string;\n    updates: Partial<Message>;\n  }): Promise<Message>;\n  \"message.listBySession\"(p: { sessionId: string }): Promise<Message[]>;\n\n  \"part.get\"(p: { id: string }): Promise<Part | null>;\n  \"part.set\"(p: { id: string; value: Part }): Promise<void>;\n  \"part.listBySession\"(p: { sessionId: string }): Promise<Part[]>;\n\n  \"sandbox.get\"(p: { id: string }): Promise<Sandbox | null>;\n  \"sandbox.set\"(p: { id: string; value: Sandbox }): Promise<void>;\n  \"sandbox.update\"(p: {\n    id: string;\n    updates: Partial<Sandbox>;\n  }): Promise<Sandbox>;\n\n  \"setup.get\"(p: { id: string }): Promise<Setup | null>;\n  \"setup.set\"(p: { id: string; value: Setup }): Promise<void>;\n};\n\n// \u2500\u2500\u2500 StorageCall (derived from StorageHandlers) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport type StorageCall = {\n  [K in keyof StorageHandlers]: { method: K } & Parameters<\n    StorageHandlers[K]\n  >[0];\n}[keyof StorageHandlers];\n\n// \u2500\u2500\u2500 StorageStep (serializable across workflow boundary) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport class StorageStep {\n  event: StorageCall;\n\n  constructor(event: StorageCall) {\n    this.event = event;\n  }\n\n  static [WORKFLOW_SERIALIZE](instance: StorageStep) {\n    return { event: instance.event };\n  }\n\n  static [WORKFLOW_DESERIALIZE](data: { event: StorageCall }) {\n    return new StorageStep(data.event);\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: safe dispatch \u2014 event.method selects the matching handler\n  on(handlers: StorageHandlers): Promise<any> {\n    // biome-ignore lint/suspicious/noExplicitAny: see above\n    return (handlers[this.event.method] as any)(this.event);\n  }\n}\n\n/**\n * A single function that handles all storage operations. Intended to be\n * marked with `\"use step\"` so that its body (and Node.js-dependent\n * imports like database clients) is extracted by the workflow bundler\n * and runs server-side.\n *\n * The step receives a `StorageStep` instance (serializable via\n * `@workflow/serde`) and should call `step.handle({ ... })` with a\n * `StorageHandlers` map.\n */\n// biome-ignore lint/suspicious/noExplicitAny: step function is a dispatcher; type safety is at the handlers level\nexport type StorageStepFunction = (store: StorageStep) => Promise<any>;\n\n// \u2500\u2500\u2500 Storage (internal, nested) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface Storage {\n  session: {\n    get(key: string): Promise<Session | null>;\n    set(key: string, value: Session): Promise<void>;\n    update(key: string, updates: Partial<Session>): Promise<Session>;\n  };\n  message: {\n    get(key: string): Promise<Message | null>;\n    set(key: string, value: Message): Promise<void>;\n    update(key: string, updates: Partial<Message>): Promise<Message>;\n    listBySession(sessionId: string): Promise<Message[]>;\n  };\n  part: {\n    get(key: string): Promise<Part | null>;\n    set(key: string, value: Part): Promise<void>;\n    listBySession(sessionId: string): Promise<Part[]>;\n  };\n  sandbox: {\n    get(key: string): Promise<Sandbox | null>;\n    set(key: string, value: Sandbox): Promise<void>;\n    update(key: string, updates: Partial<Sandbox>): Promise<Sandbox>;\n  };\n  setup: {\n    get(key: string): Promise<Setup | null>;\n    set(key: string, value: Setup): Promise<void>;\n  };\n}\n\nexport type StorageInput = StorageHandlers | StorageStepFunction;\n\nfunction isStepFunction(h: StorageInput): h is StorageStepFunction {\n  return typeof h === \"function\";\n}\n\nfunction fromStepFunction(fn: StorageStepFunction): Storage {\n  return {\n    session: {\n      get: (id) => fn(new StorageStep({ method: \"session.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"session.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"session.update\", id, updates })),\n    },\n    message: {\n      get: (id) => fn(new StorageStep({ method: \"message.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"message.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"message.update\", id, updates })),\n      listBySession: (sessionId) =>\n        fn(new StorageStep({ method: \"message.listBySession\", sessionId })),\n    },\n    part: {\n      get: (id) => fn(new StorageStep({ method: \"part.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"part.set\", id, value })),\n      listBySession: (sessionId) =>\n        fn(new StorageStep({ method: \"part.listBySession\", sessionId })),\n    },\n    sandbox: {\n      get: (id) => fn(new StorageStep({ method: \"sandbox.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"sandbox.set\", id, value })),\n      update: (id, updates) =>\n        fn(new StorageStep({ method: \"sandbox.update\", id, updates })),\n    },\n    setup: {\n      get: (id) => fn(new StorageStep({ method: \"setup.get\", id })),\n      set: (id, value) =>\n        fn(new StorageStep({ method: \"setup.set\", id, value })),\n    },\n  };\n}\n\nfunction fromHandlers(h: StorageHandlers): Storage {\n  return {\n    session: {\n      get: (id) => h[\"session.get\"]({ id }),\n      set: (id, value) => h[\"session.set\"]({ id, value }),\n      update: (id, updates) => h[\"session.update\"]({ id, updates }),\n    },\n    message: {\n      get: (id) => h[\"message.get\"]({ id }),\n      set: (id, value) => h[\"message.set\"]({ id, value }),\n      update: (id, updates) => h[\"message.update\"]({ id, updates }),\n      listBySession: (sessionId) => h[\"message.listBySession\"]({ sessionId }),\n    },\n    part: {\n      get: (id) => h[\"part.get\"]({ id }),\n      set: (id, value) => h[\"part.set\"]({ id, value }),\n      listBySession: (sessionId) => h[\"part.listBySession\"]({ sessionId }),\n    },\n    sandbox: {\n      get: (id) => h[\"sandbox.get\"]({ id }),\n      set: (id, value) => h[\"sandbox.set\"]({ id, value }),\n      update: (id, updates) => h[\"sandbox.update\"]({ id, updates }),\n    },\n    setup: {\n      get: (id) => h[\"setup.get\"]({ id }),\n      set: (id, value) => h[\"setup.set\"]({ id, value }),\n    },\n  };\n}\n\nexport function toStorage(h: StorageInput): Storage {\n  return isStepFunction(h) ? fromStepFunction(h) : fromHandlers(h);\n}\n", "import type { StorageHandlers } from \"../adapter\";\nimport type { Message, Part, Sandbox, Session, Setup } from \"../types\";\n\ntype KvStores = Awaited<ReturnType<typeof initKvStores>>;\n\nasync function initKvStores(prefix: string) {\n  const { createKV } = await import(\"@vercel/kv2\");\n  const kv = createKV({ prefix }).getStore(\"agent/\");\n\n  return {\n    sessions: kv.getStore<Session>(\"session/\"),\n    messages: kv.getStore<Message>(\"message/\").withIndexes({\n      bySessionId: { key: (m: Message) => m.sessionId },\n    }),\n    parts: kv.getStore<Part>(\"part/\").withIndexes({\n      bySessionId: { key: (p: Part) => p.sessionId },\n    }),\n    sandboxes: kv.getStore<Sandbox>(\"sandbox/\"),\n    setups: kv.getStore<Setup>(\"setup/\"),\n  };\n}\n\nexport function kvStorageFallback(opts: { prefix: string }): StorageHandlers {\n  let storesPromise: Promise<KvStores> | undefined;\n\n  function getStores() {\n    if (!storesPromise) {\n      storesPromise = initKvStores(opts.prefix);\n    }\n    return storesPromise;\n  }\n\n  const tag = `[agent.${opts.prefix}][kv2]`;\n\n  return {\n    \"session.get\": async ({ id }) => {\n      const { sessions } = await getStores();\n      return (await sessions.getValue(id)) ?? null;\n    },\n\n    \"session.set\": async ({ id, value }) => {\n      const { sessions } = await getStores();\n      await sessions.set(id, value);\n    },\n\n    \"session.update\": async ({ id, updates }) => {\n      const { sessions } = await getStores();\n      const existing = await sessions.getValue(id);\n      if (!existing) {\n        throw new Error(\n          `${tag}[session.update] no session found with id \"${id}\"`\n        );\n      }\n      const updated = { ...existing, ...updates };\n      await sessions.set(id, updated);\n      return updated;\n    },\n\n    \"message.get\": async ({ id }) => {\n      const { messages } = await getStores();\n      return (await messages.getValue(id)) ?? null;\n    },\n\n    \"message.set\": async ({ id, value }) => {\n      const { messages } = await getStores();\n      await messages.set(id, value);\n    },\n\n    \"message.update\": async ({ id, updates }) => {\n      const { messages } = await getStores();\n      const existing = await messages.getValue(id);\n      if (!existing) {\n        throw new Error(\n          `${tag}[message.update] no message found with id \"${id}\"`\n        );\n      }\n      const updated = { ...existing, ...updates };\n      await messages.set(id, updated);\n      return updated;\n    },\n\n    \"message.listBySession\": async ({ sessionId }) => {\n      const { messages } = await getStores();\n      const result: Message[] = [];\n      for await (const [, entry] of messages.entries({\n        bySessionId: sessionId,\n      })) {\n        result.push(await entry.value);\n      }\n      return result;\n    },\n\n    \"part.get\": async ({ id }) => {\n      const { parts } = await getStores();\n      return (await parts.getValue(id)) ?? null;\n    },\n\n    \"part.set\": async ({ id, value }) => {\n      const { parts } = await getStores();\n      await parts.set(id, value);\n    },\n\n    \"part.listBySession\": async ({ sessionId }) => {\n      const { parts } = await getStores();\n      const result: Part[] = [];\n      for await (const [, entry] of parts.entries({\n        bySessionId: sessionId,\n      })) {\n        result.push(await entry.value);\n      }\n      return result;\n    },\n\n    \"sandbox.get\": async ({ id }) => {\n      const { sandboxes } = await getStores();\n      return (await sandboxes.getValue(id)) ?? null;\n    },\n\n    \"sandbox.set\": async ({ id, value }) => {\n      const { sandboxes } = await getStores();\n      await sandboxes.set(id, value);\n    },\n\n    \"sandbox.update\": async ({ id, updates }) => {\n      const { sandboxes } = await getStores();\n      const existing = await sandboxes.getValue(id);\n      if (!existing) {\n        throw new Error(\n          `${tag}[sandbox.update] no sandbox found with id \"${id}\"`\n        );\n      }\n      const updated = { ...existing, ...updates };\n      await sandboxes.set(id, updated);\n      return updated;\n    },\n\n    \"setup.get\": async ({ id }) => {\n      const { setups } = await getStores();\n      return (await setups.getValue(id)) ?? null;\n    },\n\n    \"setup.set\": async ({ id, value }) => {\n      const { setups } = await getStores();\n      await setups.set(id, value);\n    },\n  };\n}\n", "import type { StorageHandlers } from \"../adapter\";\nimport type { Message, Part, Sandbox, Session, Setup } from \"../types\";\n\nlet _fs: typeof import(\"node:fs/promises\") | undefined;\nlet _path: typeof import(\"node:path\") | undefined;\n\nasync function fs() {\n  if (!_fs) {\n    _fs = await import(\"node:fs/promises\");\n  }\n  return _fs;\n}\nasync function path() {\n  if (!_path) {\n    _path = await import(\"node:path\");\n  }\n  return _path;\n}\n\nfunction createStore<T>(dir: string) {\n  const filePath = async (key: string) =>\n    (await path()).join(dir, `${key}.json`);\n\n  return {\n    async get(key: string): Promise<T | null> {\n      try {\n        const data = await (await fs()).readFile(await filePath(key), \"utf-8\");\n        return JSON.parse(data) as T;\n      } catch {\n        return null;\n      }\n    },\n    async set(key: string, value: T): Promise<void> {\n      const p = await filePath(key);\n      const { mkdir, writeFile } = await fs();\n      const { dirname } = await path();\n      await mkdir(dirname(p), { recursive: true });\n      await writeFile(p, JSON.stringify(value, null, 2));\n    },\n    async update(key: string, updates: Partial<T>): Promise<T> {\n      const p = await filePath(key);\n      const { readFile, mkdir, writeFile } = await fs();\n      const { dirname } = await path();\n      let existing: T;\n      try {\n        const data = await readFile(p, \"utf-8\");\n        existing = JSON.parse(data) as T;\n      } catch {\n        throw new Error(`Not found: ${key}`);\n      }\n      const updated = { ...existing, ...updates };\n      await mkdir(dirname(p), { recursive: true });\n      await writeFile(p, JSON.stringify(updated, null, 2));\n      return updated;\n    },\n  };\n}\n\nasync function readAllFromDir<T>(dir: string): Promise<T[]> {\n  const { readdir, readFile } = await fs();\n  const { join } = await path();\n  let files: string[];\n  try {\n    files = await readdir(dir);\n  } catch {\n    return [];\n  }\n  const result: T[] = [];\n  for (const file of files) {\n    if (!file.endsWith(\".json\")) {\n      continue;\n    }\n    try {\n      const data = await readFile(join(dir, file), \"utf-8\");\n      result.push(JSON.parse(data) as T);\n    } catch {\n      // skip corrupt files\n    }\n  }\n  return result;\n}\n\nexport function localStorage(opts?: { dir?: string }): StorageHandlers {\n  const dir = opts?.dir ?? \".agent\";\n\n  const sessionStore = createStore<Session>(`${dir}/session`);\n  const messageStore = createStore<Message>(`${dir}/message`);\n  const partStore = createStore<Part>(`${dir}/part`);\n  const sandboxStore = createStore<Sandbox>(`${dir}/sandbox`);\n  const setupStore = createStore<Setup>(`${dir}/setup`);\n  const messageDir = `${dir}/message`;\n  const partDir = `${dir}/part`;\n\n  return {\n    \"session.get\": ({ id }) => sessionStore.get(id),\n    \"session.set\": ({ id, value }) => sessionStore.set(id, value),\n    \"session.update\": ({ id, updates }) => sessionStore.update(id, updates),\n\n    \"message.get\": ({ id }) => messageStore.get(id),\n    \"message.set\": ({ id, value }) => messageStore.set(id, value),\n    \"message.update\": ({ id, updates }) => messageStore.update(id, updates),\n    \"message.listBySession\": async ({ sessionId }) => {\n      const all = await readAllFromDir<Message>(messageDir);\n      return all.filter((m) => m.sessionId === sessionId);\n    },\n\n    \"part.get\": ({ id }) => partStore.get(id),\n    \"part.set\": ({ id, value }) => partStore.set(id, value),\n    \"part.listBySession\": async ({ sessionId }) => {\n      const all = await readAllFromDir<Part>(partDir);\n      return all.filter((p) => p.sessionId === sessionId);\n    },\n\n    \"sandbox.get\": ({ id }) => sandboxStore.get(id),\n    \"sandbox.set\": ({ id, value }) => sandboxStore.set(id, value),\n    \"sandbox.update\": ({ id, updates }) => sandboxStore.update(id, updates),\n\n    \"setup.get\": ({ id }) => setupStore.get(id),\n    \"setup.set\": ({ id, value }) => setupStore.set(id, value),\n  };\n}\n", "export function shouldFallbackToKV2(): boolean {\n  return !!process.env.BLOB_READ_WRITE_TOKEN;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/chunk-JO3JDCH5.mjs

@@ -0,0 +1,107 @@
+import {
+  createLogger
+} from "./chunk-MSWINCCM.mjs";
+
+// src/sandbox/bindings/vercel-lifecycle/steps.ts
+async function loadSandboxSDK() {
+  return (await import("@vercel/sandbox")).Sandbox;
+}
+var DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1e3;
+var DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
+var SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1e3;
+var 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
+} : {};
+async function checkAndSnapshotStep(input) {
+  "use step";
+  const storage = input.agent.storage;
+  const log = createLogger({
+    config: { ...input.agent.options.logging, name: input.agent.name },
+    subsystem: "sandbox:lifecycle",
+    context: { sandboxId: input.sandboxId }
+  });
+  log.info("lifecycle check started", {
+    vercelSandboxId: input.vercelSandboxId
+  });
+  const record = await storage.sandbox.get(input.sandboxId);
+  if (!record) {
+    log.warn("sandbox record not found, exiting lifecycle");
+    return { action: "exit", reason: "not_found" };
+  }
+  const metadata = record.setup?.metadata;
+  const currentSandboxId = metadata?.sandboxId ?? null;
+  if (currentSandboxId !== input.vercelSandboxId) {
+    log.info("sandbox ID changed, exiting lifecycle", {
+      expected: input.vercelSandboxId,
+      actual: currentSandboxId
+    });
+    return { action: "exit", reason: "sandboxId_changed" };
+  }
+  if (!currentSandboxId) {
+    log.warn("no current sandbox ID in metadata, exiting lifecycle");
+    return { action: "exit", reason: "not_found" };
+  }
+  const pollIntervalMs = input.config?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const idleTimeoutMs = input.config?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+  const snapshotBeforeTimeoutMs = input.config?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;
+  const now = Date.now();
+  const lastActivity = record.lastActiveAt ?? record.createdAt ?? now;
+  const idleDuration = now - lastActivity;
+  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;
+  let shouldSnapshotDueToTimeout = false;
+  try {
+    const SandboxSDK = await loadSandboxSDK();
+    const sandbox = await SandboxSDK.get({
+      sandboxId: currentSandboxId,
+      ...getTestCredentials()
+    });
+    if (sandbox.timeout < snapshotBeforeTimeoutMs) {
+      shouldSnapshotDueToTimeout = true;
+    }
+  } catch {
+    log.warn("failed to get sandbox from SDK, exiting lifecycle", {
+      vercelSandboxId: currentSandboxId
+    });
+    return { action: "exit", reason: "not_found" };
+  }
+  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {
+    const reason = shouldSnapshotDueToIdle ? "idle" : "timeout";
+    log.info("snapshotting sandbox before exit", {
+      reason,
+      idleDurationMs: idleDuration,
+      vercelSandboxId: currentSandboxId
+    });
+    try {
+      const SandboxSDK = await loadSandboxSDK();
+      const sandbox = await SandboxSDK.get({
+        sandboxId: currentSandboxId,
+        ...getTestCredentials()
+      });
+      const snapshot = await sandbox.snapshot();
+      log.info("snapshot created", { snapshotId: snapshot.snapshotId });
+      await storage.sandbox.update(input.sandboxId, {
+        setup: {
+          ...record.setup,
+          metadata: { sandboxId: null, snapshotId: snapshot.snapshotId }
+        }
+      });
+      log.info("sandbox record updated with snapshot");
+    } catch (e) {
+      log.error("failed to snapshot sandbox", { cause: e });
+      return e instanceof Error ? e : new Error(String(e));
+    }
+    return { action: "exit", reason };
+  }
+  log.info("sandbox still active, continuing lifecycle", {
+    idleDurationMs: idleDuration,
+    nextPollMs: pollIntervalMs
+  });
+  return { action: "continue", nextPollMs: pollIntervalMs };
+}
+
+export {
+  checkAndSnapshotStep
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/bindings/vercel-lifecycle/steps.ts"],
  "sourcesContent": ["import type { Sandbox as VercelSandboxSDK } from \"@vercel/sandbox\";\nimport { createLogger } from \"../../../utils/logger\";\nimport type { SandboxAgentRef } from \"../../adapter\";\nimport type { VercelBindingMetadata } from \"../vercel\";\n\nasync function loadSandboxSDK(): Promise<typeof VercelSandboxSDK> {\n  return (await import(\"@vercel/sandbox\")).Sandbox;\n}\n\nconst DEFAULT_POLL_INTERVAL_MS = 2 * 60 * 1000;\nconst DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1000;\nconst SNAPSHOT_BEFORE_TIMEOUT_MS = 10 * 60 * 1000;\n\nconst getTestCredentials = () =>\n  process.env.NODE_ENV === \"test\"\n    ? {\n        token: process.env.TEST_VERCEL_TOKEN,\n        teamId: process.env.TEST_VERCEL_TEAM_ID,\n        projectId: process.env.TEST_VERCEL_PROJECT_ID,\n      }\n    : {};\n\nexport type LifecycleStepResult =\n  | { action: \"continue\"; nextPollMs: number }\n  | {\n      action: \"exit\";\n      reason: \"sandboxId_changed\" | \"idle\" | \"timeout\" | \"not_found\";\n    };\n\nexport type LifecycleConfig = {\n  pollIntervalMs?: number;\n  stopAfterInactiveMs?: number;\n  snapshotBeforeTimeoutMs?: number;\n};\n\nexport type LifecycleInput = {\n  agent: SandboxAgentRef;\n  sandboxId: string;\n  vercelSandboxId: string;\n  config?: LifecycleConfig;\n};\n\nexport async function checkAndSnapshotStep(\n  input: LifecycleInput\n): Promise<Error | LifecycleStepResult> {\n  \"use step\";\n\n  const storage = input.agent.storage;\n  const log = createLogger({\n    config: { ...input.agent.options.logging, name: input.agent.name },\n    subsystem: \"sandbox:lifecycle\",\n    context: { sandboxId: input.sandboxId },\n  });\n\n  log.info(\"lifecycle check started\", {\n    vercelSandboxId: input.vercelSandboxId,\n  });\n\n  const record = await storage.sandbox.get(input.sandboxId);\n  if (!record) {\n    log.warn(\"sandbox record not found, exiting lifecycle\");\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const metadata = record.setup?.metadata as VercelBindingMetadata | null;\n  const currentSandboxId = metadata?.sandboxId ?? null;\n\n  if (currentSandboxId !== input.vercelSandboxId) {\n    log.info(\"sandbox ID changed, exiting lifecycle\", {\n      expected: input.vercelSandboxId,\n      actual: currentSandboxId,\n    });\n    return { action: \"exit\", reason: \"sandboxId_changed\" };\n  }\n\n  if (!currentSandboxId) {\n    log.warn(\"no current sandbox ID in metadata, exiting lifecycle\");\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  const pollIntervalMs =\n    input.config?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;\n  const idleTimeoutMs =\n    input.config?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;\n  const snapshotBeforeTimeoutMs =\n    input.config?.snapshotBeforeTimeoutMs ?? SNAPSHOT_BEFORE_TIMEOUT_MS;\n\n  const now = Date.now();\n  const lastActivity = record.lastActiveAt ?? record.createdAt ?? now;\n  const idleDuration = now - lastActivity;\n  const shouldSnapshotDueToIdle = idleDuration > idleTimeoutMs;\n\n  let shouldSnapshotDueToTimeout = false;\n  try {\n    const SandboxSDK = await loadSandboxSDK();\n    const sandbox = await SandboxSDK.get({\n      sandboxId: currentSandboxId,\n      ...getTestCredentials(),\n    });\n    if (sandbox.timeout < snapshotBeforeTimeoutMs) {\n      shouldSnapshotDueToTimeout = true;\n    }\n  } catch {\n    log.warn(\"failed to get sandbox from SDK, exiting lifecycle\", {\n      vercelSandboxId: currentSandboxId,\n    });\n    return { action: \"exit\", reason: \"not_found\" };\n  }\n\n  if (shouldSnapshotDueToIdle || shouldSnapshotDueToTimeout) {\n    const reason = shouldSnapshotDueToIdle ? \"idle\" : \"timeout\";\n    log.info(\"snapshotting sandbox before exit\", {\n      reason,\n      idleDurationMs: idleDuration,\n      vercelSandboxId: currentSandboxId,\n    });\n\n    try {\n      const SandboxSDK = await loadSandboxSDK();\n      const sandbox = await SandboxSDK.get({\n        sandboxId: currentSandboxId,\n        ...getTestCredentials(),\n      });\n      const snapshot = await sandbox.snapshot();\n      log.info(\"snapshot created\", { snapshotId: snapshot.snapshotId });\n\n      await storage.sandbox.update(input.sandboxId, {\n        setup: {\n          ...record.setup,\n          metadata: { sandboxId: null, snapshotId: snapshot.snapshotId },\n        },\n      });\n      log.info(\"sandbox record updated with snapshot\");\n    } catch (e) {\n      log.error(\"failed to snapshot sandbox\", { cause: e });\n      return e instanceof Error ? e : new Error(String(e));\n    }\n    return { action: \"exit\", reason };\n  }\n\n  log.info(\"sandbox still active, continuing lifecycle\", {\n    idleDurationMs: idleDuration,\n    nextPollMs: pollIntervalMs,\n  });\n  return { action: \"continue\", nextPollMs: pollIntervalMs };\n}\n"],
  "mappings": "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",
  "names": []
}
