experimental-agent 0.2.3 → 0.4.0

package/dist/storage.js

@@ -0,0 +1,368 @@
+"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 __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/storage/entry.ts
+var entry_exports = {};
+__export(entry_exports, {
+  StorageStep: () => StorageStep,
+  kvStorageFallback: () => kvStorageFallback,
+  localStorage: () => localStorage,
+  shouldFallbackToKV2: () => shouldFallbackToKV2,
+  toStorage: () => toStorage
+});
+module.exports = __toCommonJS(entry_exports);
+
+// src/storage/adapter.ts
+var import_serde = require("@workflow/serde");
+var StorageStep = class _StorageStep {
+  event;
+  constructor(event) {
+    this.event = event;
+  }
+  static [import_serde.WORKFLOW_SERIALIZE](instance) {
+    return { event: instance.event };
+  }
+  static [import_serde.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StorageStep,
+  kvStorageFallback,
+  localStorage,
+  shouldFallbackToKV2,
+  toStorage
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/entry.ts", "../src/storage/adapter.ts", "../src/storage/bindings/kv.ts", "../src/storage/bindings/local.ts", "../src/storage/should-fallback-kv2.ts"],
  "sourcesContent": ["export type {\n  Storage,\n  StorageCall,\n  StorageHandlers,\n  StorageStepFunction,\n} from \"./adapter\";\nexport { StorageStep, toStorage } from \"./adapter\";\nexport { kvStorageFallback } from \"./bindings/kv\";\nexport { localStorage } from \"./bindings/local\";\nexport { shouldFallbackToKV2 } from \"./should-fallback-kv2\";\nexport type {\n  GenerationOptions,\n  Message,\n  MessageUsage,\n  Part,\n  Sandbox,\n  Session,\n  Setup,\n  SetupSnapshot,\n} from \"./types\";\n", "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/storage.mjs

@@ -0,0 +1,16 @@
+import {
+  StorageStep,
+  kvStorageFallback,
+  localStorage,
+  shouldFallbackToKV2,
+  toStorage
+} from "./chunk-IV75IMEW.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  StorageStep,
+  kvStorageFallback,
+  localStorage,
+  shouldFallbackToKV2,
+  toStorage
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/vercel-QZ6INPMV.mjs

@@ -0,0 +1,11 @@
+import {
+  vercelSandbox
+} from "./chunk-RT72C52I.mjs";
+import "./chunk-GKASMIBR.mjs";
+import "./chunk-JO3JDCH5.mjs";
+import "./chunk-MSWINCCM.mjs";
+import "./chunk-BJTO5JO5.mjs";
+export {
+  vercelSandbox
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-agent",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -15,6 +15,16 @@
       "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",
@@ -29,30 +39,44 @@
       "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"
     }
   },
   "dependencies": {
     "@swc/core": "^1.10.0",
+    "@vercel/kv2": "^0.0.18",
     "@vercel/oidc": "^3.1.0",
+    "@vercel/sandbox": "1.7.1",
+    "@workflow/serde": "4.1.0-beta.2",
     "better-all": "^0.0.5",
-    "errore": "^0.8.2",
+    "errore": "^0.14.0",
     "fast-deep-equal": "^3.1.3",
-    "@vercel/sandbox": "1.7.1",
     "ulid": "^3.0.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@ai-sdk/react": "^3.0.88",
     "@types/node": "^20.11.24",
     "dotenv": "^17.2.3",
     "next": "^16.0.0",
+    "react": "^19.2.4",
     "tsup": "^8.0.2",
     "typescript": "5.5.4",
     "vitest": "^3.0.0",
+    "workflow": "4.1.0-beta.60",
     "@agent/tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "ai": "^6.0.0",
-    "workflow": "*"
+    "ai": "^6.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/agent-workflow.d.mts

@@ -1,30 +0,0 @@
-import * as workflow from 'workflow';
-import { w as StorageConfig, h as RpcPayload, i as RpcResult } from './client-CEeSFGva.mjs';
-import 'errore';
-import 'ai';
-import 'zod';
-import '@vercel/sandbox';
-
-type AgentInput = {
-    sessionId: string;
-    storageConfig: StorageConfig;
-    rpc: (params: RpcPayload) => Promise<RpcResult>;
-};
-type AgentMessageInput = {
-    assistantMessageId: string;
-    hookToken: string;
-    createdAt: number;
-    context: Record<string, unknown>;
-};
-type ApprovalResponse = {
-    approved: boolean;
-    reason?: string;
-};
-declare const agentMessageHook: workflow.TypedHook<AgentMessageInput, AgentMessageInput>;
-declare const approvalHook: workflow.TypedHook<ApprovalResponse, ApprovalResponse>;
-declare function agentWorkflow({ input, event, }: {
-    input: AgentInput;
-    event: AgentMessageInput;
-}): Promise<void>;
-
-export { type AgentInput, type AgentMessageInput, type ApprovalResponse, agentMessageHook, agentWorkflow, approvalHook };

package/dist/agent-workflow.d.ts

@@ -1,30 +0,0 @@
-import * as workflow from 'workflow';
-import { w as StorageConfig, h as RpcPayload, i as RpcResult } from './client-CEeSFGva.js';
-import 'errore';
-import 'ai';
-import 'zod';
-import '@vercel/sandbox';
-
-type AgentInput = {
-    sessionId: string;
-    storageConfig: StorageConfig;
-    rpc: (params: RpcPayload) => Promise<RpcResult>;
-};
-type AgentMessageInput = {
-    assistantMessageId: string;
-    hookToken: string;
-    createdAt: number;
-    context: Record<string, unknown>;
-};
-type ApprovalResponse = {
-    approved: boolean;
-    reason?: string;
-};
-declare const agentMessageHook: workflow.TypedHook<AgentMessageInput, AgentMessageInput>;
-declare const approvalHook: workflow.TypedHook<ApprovalResponse, ApprovalResponse>;
-declare function agentWorkflow({ input, event, }: {
-    input: AgentInput;
-    event: AgentMessageInput;
-}): Promise<void>;
-
-export { type AgentInput, type AgentMessageInput, type ApprovalResponse, agentMessageHook, agentWorkflow, approvalHook };