experimental-agent 0.5.0 → 0.6.0

package/dist/{adapter-Cl735Kp4.d.mts → adapter-DmlMKodR.d.mts}

@@ -18,6 +18,7 @@ type Session = {
     lastMessageId: string | null;
     createdAt: number;
     updatedAt: number;
+    state?: Record<string, unknown>;
 };
 type MessageUsage = {
     steps: {

package/dist/{adapter-Cl735Kp4.d.ts → adapter-DmlMKodR.d.ts}

@@ -18,6 +18,7 @@ type Session = {
     lastMessageId: string | null;
     createdAt: number;
     updatedAt: number;
+    state?: Record<string, unknown>;
 };
 type MessageUsage = {
     steps: {

package/dist/{chunk-AB2JYY6A.mjs → chunk-355UN6NT.mjs}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "experimental-agent",
-  version: "0.5.0",
+  version: "0.6.0",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
   types: "./dist/index.d.ts",
@@ -50,6 +50,11 @@ var package_default = {
       types: "./dist/lifecycle-workflow-steps.d.ts",
       import: "./dist/lifecycle-workflow-steps.mjs",
       require: "./dist/lifecycle-workflow-steps.js"
+    },
+    "./react": {
+      types: "./dist/react.d.ts",
+      import: "./dist/react.mjs",
+      require: "./dist/react.js"
     }
   },
   scripts: {
@@ -63,11 +68,13 @@ var package_default = {
   },
   dependencies: {
     "@swc/core": "^1.10.0",
+    "@tanstack/react-query": "^5.90.21",
     "@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",
+    elysia: "^1.4.25",
     errore: "^0.14.0",
     "fast-deep-equal": "^3.1.3",
     ulid: "^3.0.2",
@@ -77,6 +84,7 @@ var package_default = {
     "@agent/tsconfig": "workspace:*",
     "@ai-sdk/react": "^3.0.88",
     "@types/node": "^20.11.24",
+    "@types/react": "^19.2.14",
     dotenv: "^17.2.3",
     next: "^16.0.0",
     react: "^19.2.4",
@@ -96,4 +104,4 @@ var package_default = {
 export {
   package_default
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/chunk-CS2SEUAA.mjs

@@ -0,0 +1,405 @@
+// 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-optimistic-update.ts
+var DEFAULT_MAX_RETRIES = 3;
+async function mergeWithKVOptimisticUpdate(opts) {
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const { KVVersionConflictError } = await import("@vercel/kv2");
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    const entry = await opts.store.get(opts.id);
+    if (!entry.exists) {
+      throw new Error(opts.notFoundErrorMessage);
+    }
+    const existing = await entry.value;
+    const updated = { ...existing, ...opts.updates };
+    try {
+      await entry.update(updated);
+      return updated;
+    } catch (error) {
+      if (!(error instanceof KVVersionConflictError) && (!(error instanceof Error) || error.name !== "KVVersionConflictError")) {
+        throw error;
+      }
+      if (attempt === maxRetries - 1) {
+        throw new Error(opts.conflictErrorMessage, { cause: error });
+      }
+    }
+  }
+  throw new Error(opts.conflictErrorMessage);
+}
+
+// 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();
+      return mergeWithKVOptimisticUpdate({
+        id,
+        updates,
+        store: sessions,
+        notFoundErrorMessage: `${tag}[session.update] no session found with id "${id}"`,
+        conflictErrorMessage: `${tag}[session.update] optimistic update failed after retries for id "${id}"`
+      });
+    },
+    "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();
+      return mergeWithKVOptimisticUpdate({
+        id,
+        updates,
+        store: messages,
+        notFoundErrorMessage: `${tag}[message.update] no message found with id "${id}"`,
+        conflictErrorMessage: `${tag}[message.update] optimistic update failed after retries for id "${id}"`
+      });
+    },
+    "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();
+      return mergeWithKVOptimisticUpdate({
+        id,
+        updates,
+        store: sandboxes,
+        notFoundErrorMessage: `${tag}[sandbox.update] no sandbox found with id "${id}"`,
+        conflictErrorMessage: `${tag}[sandbox.update] optimistic update failed after retries for id "${id}"`
+      });
+    },
+    "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 createWriteLock() {
+  const locks = /* @__PURE__ */ new Map();
+  return async function withWriteLock(opts) {
+    let state = locks.get(opts.key);
+    if (!state) {
+      state = { locked: false, waiters: [] };
+      locks.set(opts.key, state);
+    }
+    if (state.locked) {
+      await new Promise((resolve) => {
+        state.waiters.push(resolve);
+      });
+    }
+    state.locked = true;
+    try {
+      return await opts.fn();
+    } finally {
+      const next = state.waiters.shift();
+      if (next) {
+        next();
+      } else {
+        state.locked = false;
+        locks.delete(opts.key);
+      }
+    }
+  };
+}
+function createStore(dir) {
+  const filePath = async (key) => (await path()).join(dir, `${key}.json`);
+  const withWriteLock = createWriteLock();
+  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) {
+      await withWriteLock({
+        key,
+        fn: async () => {
+          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));
+        }
+      });
+    },
+    update(key, updates) {
+      return withWriteLock({
+        key,
+        fn: async () => {
+          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;
+}
+async function ensureGitignore(dir) {
+  const { mkdir, writeFile, readFile } = await fs();
+  const { join } = await path();
+  const gitignorePath = join(dir, ".gitignore");
+  try {
+    await readFile(gitignorePath, "utf-8");
+  } catch {
+    await mkdir(dir, { recursive: true });
+    await writeFile(gitignorePath, "*\n");
+  }
+}
+function localStorage(opts) {
+  const dir = opts?.dir ?? ".agent";
+  let gitignorePromise = null;
+  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`;
+  function onWrite(fn) {
+    if (!gitignorePromise) {
+      gitignorePromise = ensureGitignore(dir);
+    }
+    return gitignorePromise.then(fn);
+  }
+  return {
+    "session.get": ({ id }) => sessionStore.get(id),
+    "session.set": ({ id, value }) => onWrite(() => sessionStore.set(id, value)),
+    "session.update": ({ id, updates }) => onWrite(() => sessionStore.update(id, updates)),
+    "message.get": ({ id }) => messageStore.get(id),
+    "message.set": ({ id, value }) => onWrite(() => messageStore.set(id, value)),
+    "message.update": ({ id, updates }) => onWrite(() => 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 }) => onWrite(() => 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 }) => onWrite(() => sandboxStore.set(id, value)),
+    "sandbox.update": ({ id, updates }) => onWrite(() => sandboxStore.update(id, updates)),
+    "setup.get": ({ id }) => setupStore.get(id),
+    "setup.set": ({ id, value }) => onWrite(() => 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-optimistic-update.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", "const DEFAULT_MAX_RETRIES = 3;\n\n/**\n * We intentionally mirror the minimal `get()` return shape we use here\n * instead of importing KV2 types. The workflow bundler analyzes type-only\n * imports and flags `@vercel/kv2` as a Node module in workflow code paths.\n * Keeping this local avoids that false-positive while preserving runtime behavior.\n */\ntype KVOptimisticGetResult<T> =\n  | {\n      exists: false;\n    }\n  | {\n      exists: true;\n      value: Promise<T>;\n      update(value: T): Promise<unknown>;\n    };\n\ntype KVOptimisticStore<T> = {\n  get(keyOrFilter: string): Promise<KVOptimisticGetResult<T>>;\n};\n\nexport async function mergeWithKVOptimisticUpdate<T>(opts: {\n  id: string;\n  updates: Partial<T>;\n  store: KVOptimisticStore<T>;\n  notFoundErrorMessage: string;\n  conflictErrorMessage: string;\n  maxRetries?: number;\n}): Promise<T> {\n  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;\n  const { KVVersionConflictError } = await import(\"@vercel/kv2\");\n\n  for (let attempt = 0; attempt < maxRetries; attempt++) {\n    const entry = await opts.store.get(opts.id);\n    if (!entry.exists) {\n      throw new Error(opts.notFoundErrorMessage);\n    }\n\n    const existing = await entry.value;\n    const updated = { ...existing, ...opts.updates };\n\n    try {\n      await entry.update(updated);\n      return updated;\n    } catch (error) {\n      if (\n        !(error instanceof KVVersionConflictError) &&\n        (!(error instanceof Error) || error.name !== \"KVVersionConflictError\")\n      ) {\n        throw error;\n      }\n\n      if (attempt === maxRetries - 1) {\n        throw new Error(opts.conflictErrorMessage, { cause: error });\n      }\n    }\n  }\n\n  throw new Error(opts.conflictErrorMessage);\n}\n", "import type { StorageHandlers } from \"../adapter\";\nimport type { Message, Part, Sandbox, Session, Setup } from \"../types\";\nimport { mergeWithKVOptimisticUpdate } from \"./kv-optimistic-update\";\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      return mergeWithKVOptimisticUpdate<Session>({\n        id,\n        updates,\n        store: sessions,\n        notFoundErrorMessage: `${tag}[session.update] no session found with id \"${id}\"`,\n        conflictErrorMessage: `${tag}[session.update] optimistic update failed after retries for id \"${id}\"`,\n      });\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      return mergeWithKVOptimisticUpdate<Message>({\n        id,\n        updates,\n        store: messages,\n        notFoundErrorMessage: `${tag}[message.update] no message found with id \"${id}\"`,\n        conflictErrorMessage: `${tag}[message.update] optimistic update failed after retries for id \"${id}\"`,\n      });\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      return mergeWithKVOptimisticUpdate<Sandbox>({\n        id,\n        updates,\n        store: sandboxes,\n        notFoundErrorMessage: `${tag}[sandbox.update] no sandbox found with id \"${id}\"`,\n        conflictErrorMessage: `${tag}[sandbox.update] optimistic update failed after retries for id \"${id}\"`,\n      });\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\ntype WriteLockState = {\n  locked: boolean;\n  waiters: Array<() => void>;\n};\n\nfunction createWriteLock() {\n  const locks = new Map<string, WriteLockState>();\n\n  return async function withWriteLock<T>(opts: {\n    key: string;\n    fn: () => Promise<T>;\n  }): Promise<T> {\n    let state = locks.get(opts.key);\n    if (!state) {\n      state = { locked: false, waiters: [] };\n      locks.set(opts.key, state);\n    }\n\n    if (state.locked) {\n      await new Promise<void>((resolve) => {\n        state.waiters.push(resolve);\n      });\n    }\n\n    state.locked = true;\n\n    try {\n      return await opts.fn();\n    } finally {\n      const next = state.waiters.shift();\n      if (next) {\n        next();\n      } else {\n        state.locked = false;\n        locks.delete(opts.key);\n      }\n    }\n  };\n}\n\nfunction createStore<T>(dir: string) {\n  const filePath = async (key: string) =>\n    (await path()).join(dir, `${key}.json`);\n  const withWriteLock = createWriteLock();\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      await withWriteLock({\n        key,\n        fn: async () => {\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      });\n    },\n    update(key: string, updates: Partial<T>): Promise<T> {\n      return withWriteLock({\n        key,\n        fn: async () => {\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  };\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\nasync function ensureGitignore(dir: string) {\n  const { mkdir, writeFile, readFile } = await fs();\n  const { join } = await path();\n  const gitignorePath = join(dir, \".gitignore\");\n  try {\n    await readFile(gitignorePath, \"utf-8\");\n  } catch {\n    await mkdir(dir, { recursive: true });\n    await writeFile(gitignorePath, \"*\\n\");\n  }\n}\n\nexport function localStorage(opts?: { dir?: string }): StorageHandlers {\n  const dir = opts?.dir ?? \".agent\";\n  let gitignorePromise: Promise<void> | null = null;\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  function onWrite<T>(fn: () => Promise<T>): Promise<T> {\n    if (!gitignorePromise) {\n      gitignorePromise = ensureGitignore(dir);\n    }\n    return gitignorePromise.then(fn);\n  }\n\n  return {\n    \"session.get\": ({ id }) => sessionStore.get(id),\n    \"session.set\": ({ id, value }) =>\n      onWrite(() => sessionStore.set(id, value)),\n    \"session.update\": ({ id, updates }) =>\n      onWrite(() => sessionStore.update(id, updates)),\n\n    \"message.get\": ({ id }) => messageStore.get(id),\n    \"message.set\": ({ id, value }) =>\n      onWrite(() => messageStore.set(id, value)),\n    \"message.update\": ({ id, updates }) =>\n      onWrite(() => 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 }) => onWrite(() => 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 }) =>\n      onWrite(() => sandboxStore.set(id, value)),\n    \"sandbox.update\": ({ id, updates }) =>\n      onWrite(() => sandboxStore.update(id, updates)),\n\n    \"setup.get\": ({ id }) => setupStore.get(id),\n    \"setup.set\": ({ id, value }) => onWrite(() => 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-LZOMFHX3.mjs

@@ -0,0 +1,38 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/chunk-PH2FXKOU.mjs

@@ -0,0 +1,9 @@
+// src/rpc/base-path.ts
+function basePathForAgent(agent) {
+  return `/api/agents/${agent}`;
+}
+
+export {
+  basePathForAgent
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL3JwYy9iYXNlLXBhdGgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCB0eXBlIEJhc2VQYXRoID0gYC9hcGkvYWdlbnRzL1thZ2VudF1gO1xuZXhwb3J0IHR5cGUgU2Vzc2lvblBhdGggPSBgJHtCYXNlUGF0aCB8IChzdHJpbmcgJiB7fSl9L1tzZXNzaW9uSWRdYDtcbmV4cG9ydCB0eXBlIFJlY29ubmVjdFBhdGggPSBgJHtTZXNzaW9uUGF0aCB8IChzdHJpbmcgJiB7fSl9L3JlY29ubmVjdGA7XG5leHBvcnQgdHlwZSBJbnRlcnJ1cHRQYXRoID0gYCR7U2Vzc2lvblBhdGggfCAoc3RyaW5nICYge30pfS9pbnRlcnJ1cHRgO1xuXG5leHBvcnQgdHlwZSBQYXRoID0gU2Vzc2lvblBhdGggfCBSZWNvbm5lY3RQYXRoIHwgSW50ZXJydXB0UGF0aDtcblxuZXhwb3J0IGZ1bmN0aW9uIGJhc2VQYXRoRm9yQWdlbnQoYWdlbnQ6IHN0cmluZykge1xuICByZXR1cm4gYC9hcGkvYWdlbnRzLyR7YWdlbnR9YCBhcyBjb25zdDtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7QUFPTyxTQUFTLGlCQUFpQixPQUFlO0FBQzlDLFNBQU8sZUFBZSxLQUFLO0FBQzdCOyIsCiAgIm5hbWVzIjogW10KfQo=