experimental-agent 0.2.3 → 0.3.0

package/dist/chunk-DOD4MC5D.mjs

@@ -0,0 +1,196 @@
+// 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/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)
+  };
+}
+
+export {
+  StorageStep,
+  toStorage,
+  localStorage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/adapter.ts", "../src/storage/bindings/local.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: {\n    id: string;\n    value: Setup;\n  }): 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 {\n  Message,\n  Part,\n  Sandbox,\n  Session,\n  Setup,\n} from \"../types\";\nimport type { StorageHandlers } from \"../adapter\";\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"],
  "mappings": "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",
  "names": []
}


package/dist/chunk-ELWIUJUK.mjs

@@ -0,0 +1,96 @@
+// package.json
+var package_default = {
+  name: "experimental-agent",
+  version: "0.2.3",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  sideEffects: true,
+  license: "MIT",
+  files: [
+    "dist/**"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./storage": {
+      types: "./dist/storage.d.ts",
+      import: "./dist/storage.mjs",
+      require: "./dist/storage.js"
+    },
+    "./sandbox": {
+      types: "./dist/sandbox.d.ts",
+      import: "./dist/sandbox.mjs",
+      require: "./dist/sandbox.js"
+    },
+    "./next": {
+      types: "./dist/next.d.ts",
+      import: "./dist/next.mjs",
+      require: "./dist/next.js"
+    },
+    "./next/loader": {
+      types: "./dist/next/loader.d.ts",
+      import: "./dist/next/loader.mjs",
+      require: "./dist/next/loader.js"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.mjs",
+      require: "./dist/client.js"
+    },
+    "./lifecycle-workflow": {
+      types: "./dist/lifecycle-workflow.d.ts",
+      import: "./dist/lifecycle-workflow.mjs",
+      require: "./dist/lifecycle-workflow.js"
+    },
+    "./lifecycle-workflow-steps": {
+      types: "./dist/lifecycle-workflow-steps.d.ts",
+      import: "./dist/lifecycle-workflow-steps.mjs",
+      require: "./dist/lifecycle-workflow-steps.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    release: "pnpm build && npm publish",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@swc/core": "^1.10.0",
+    "@vercel/oidc": "^3.1.0",
+    "@vercel/sandbox": "1.7.1",
+    "@workflow/serde": "4.1.0-beta.2",
+    "better-all": "^0.0.5",
+    errore: "^0.14.0",
+    "fast-deep-equal": "^3.1.3",
+    ulid: "^3.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@agent/tsconfig": "workspace:*",
+    "@types/node": "^20.11.24",
+    dotenv: "^17.2.3",
+    next: "^16.0.0",
+    tsup: "^8.0.2",
+    typescript: "5.5.4",
+    vitest: "^3.0.0",
+    workflow: "4.1.0-beta.60"
+  },
+  peerDependencies: {
+    ai: "^6.0.0"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+export {
+  package_default
+};
+//# sourceMappingURL=data:application/json;base64,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

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-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": []
}
