experimental-agent 0.1.2 → 0.1.3

package/dist/local-fs-handlers-ESZBRAWK.mjs

@@ -0,0 +1,439 @@
+import {
+  StorageConflictError
+} from "./chunk-YRYXN7W4.mjs";
+import "./chunk-BJTO5JO5.mjs";
+
+// src/storage/bindings/local-fs-handlers.ts
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rm,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { dirname, join, resolve } from "path";
+import equal from "fast-deep-equal";
+
+// src/utils/paginate.ts
+function paginate(opts) {
+  const { items, cursor, limit } = opts;
+  const startIndex = cursor ? items.findIndex((m) => m.id === cursor) + 1 : 0;
+  const sliced = limit !== void 0 ? items.slice(startIndex, startIndex + limit) : items.slice(startIndex);
+  const nextCursor = limit !== void 0 && startIndex + limit < items.length ? sliced.at(-1)?.id ?? null : null;
+  return { items: sliced, nextCursor };
+}
+
+// src/storage/bindings/local-fs-handlers.ts
+function createFilesystemHandlers(basePath) {
+  const resolvedBase = resolve(basePath);
+  const sessionDir = join(resolvedBase, "session");
+  const messageDir = join(resolvedBase, "message");
+  const partDir = join(resolvedBase, "part");
+  const sandboxDir = join(resolvedBase, "sandbox");
+  const commandDir = join(resolvedBase, "command");
+  const setupDir = join(resolvedBase, "setup");
+  const lockDir = join(resolvedBase, ".locks");
+  const LOCK_STALE_MS = 3e4;
+  async function ensureDir(dir) {
+    await mkdir(dir, { recursive: true });
+  }
+  async function readJson(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async function writeJsonFile(filePath, data) {
+    await ensureDir(dirname(filePath));
+    await writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+  async function withRecordLock(key, fn) {
+    const lockName = Buffer.from(key).toString("base64url");
+    const lockPath = join(lockDir, `${lockName}.lock`);
+    const metadataPath = join(lockPath, "metadata.json");
+    await ensureDir(lockDir);
+    while (true) {
+      try {
+        await mkdir(lockPath);
+        await writeJsonFile(metadataPath, {
+          pid: process.pid,
+          createdAt: Date.now()
+        });
+        break;
+      } catch (e) {
+        if (!(e instanceof Error) || e.code !== "EEXIST") {
+          throw e;
+        }
+        const metadata = await readJson(metadataPath);
+        if (metadata?.createdAt && Date.now() - metadata.createdAt > LOCK_STALE_MS) {
+          await rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+        await new Promise((r) => setTimeout(r, 10));
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      await rm(lockPath, { recursive: true, force: true });
+    }
+  }
+  function removeUndefined(input) {
+    const result = {};
+    for (const [key, value] of Object.entries(input)) {
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  async function readAllFromDir(dir) {
+    try {
+      const files = await readdir(dir);
+      const results = await Promise.all(
+        files.filter((f) => f.endsWith(".json")).map((f) => readJson(join(dir, f)))
+      );
+      return results.filter((r) => r !== null);
+    } catch {
+      return [];
+    }
+  }
+  return {
+    "session.get": async ({ id }) => {
+      const sessionPath = join(sessionDir, `${id}.json`);
+      return await readJson(sessionPath) ?? null;
+    },
+    "session.set": async (session) => {
+      return await withRecordLock(`session:${session.id}`, async () => {
+        const now = Date.now();
+        const sessionPath = join(sessionDir, `${session.id}.json`);
+        const existing = await readJson(sessionPath);
+        const newSession = {
+          ...session,
+          tags: session.tags ?? existing?.tags ?? {},
+          createdAt: existing?.createdAt ?? session.createdAt ?? now,
+          updatedAt: now
+        };
+        await writeJsonFile(sessionPath, newSession);
+        return newSession;
+      });
+    },
+    "session.update": async (opts) => {
+      return await withRecordLock(`session:${opts.id}`, async () => {
+        const sessionPath = join(sessionDir, `${opts.id}.json`);
+        const existing = await readJson(sessionPath);
+        if (!existing) {
+          throw new Error(`Session ${opts.id} not found`);
+        }
+        const rawPatch = removeUndefined({
+          ...opts,
+          id: void 0
+        });
+        if (Object.keys(rawPatch).length === 0) {
+          return existing;
+        }
+        if (Object.hasOwn(rawPatch, "runId")) {
+          const nextRunId = rawPatch.runId;
+          if (existing.runId !== null && nextRunId === null) {
+            throw new StorageConflictError({
+              reason: "runId cannot be cleared once set"
+            });
+          }
+          if (existing.runId !== null && nextRunId !== existing.runId) {
+            throw new StorageConflictError({
+              reason: `runId is already set to ${existing.runId}`
+            });
+          }
+        }
+        const patch = rawPatch;
+        const updatedAt = patch.updatedAt !== void 0 ? patch.updatedAt : Date.now();
+        const updatedSession = {
+          ...existing,
+          ...patch,
+          updatedAt
+        };
+        await writeJsonFile(sessionPath, updatedSession);
+        return updatedSession;
+      });
+    },
+    "session.delete": async ({ id }) => {
+      try {
+        await unlink(join(sessionDir, `${id}.json`));
+      } catch {
+      }
+      const allMessages = await readAllFromDir(messageDir);
+      const sessionMessages = allMessages.filter((m) => m.sessionId === id);
+      const allParts = await readAllFromDir(partDir);
+      const sessionParts = allParts.filter((p) => p.sessionId === id);
+      const allCommands = await readAllFromDir(commandDir);
+      const sessionCommands = allCommands.filter((c) => c.sessionId === id);
+      const noop = () => void 0;
+      await Promise.all([
+        ...sessionMessages.map(
+          (m) => unlink(join(messageDir, `${m.id}.json`)).catch(noop)
+        ),
+        ...sessionParts.map(
+          (p) => unlink(join(partDir, `${p.id}.json`)).catch(noop)
+        ),
+        ...sessionCommands.map(
+          (c) => unlink(join(commandDir, `${c.id}.json`)).catch(noop)
+        )
+      ]);
+    },
+    "session.list": async ({ tags, order, cursor, limit }) => {
+      const allSessions = await readAllFromDir(sessionDir);
+      let filtered = allSessions;
+      if (tags && Object.keys(tags).length > 0) {
+        filtered = filtered.filter((s) => {
+          const sessionTags = s.tags ?? {};
+          return Object.entries(tags).every(
+            ([key, value]) => equal(sessionTags[key], value)
+          );
+        });
+      }
+      const resolvedOrder = order ?? "updatedAt_desc";
+      const sortField = resolvedOrder.startsWith("updatedAt") ? "updatedAt" : "createdAt";
+      const sortDir = resolvedOrder.endsWith("_desc") ? -1 : 1;
+      filtered.sort((a, b) => sortDir * (a[sortField] - b[sortField]));
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "session.listBySandbox": async ({
+      sandboxId,
+      tags,
+      order,
+      cursor,
+      limit
+    }) => {
+      const allSessions = await readAllFromDir(sessionDir);
+      let filtered = allSessions.filter((s) => s.sandboxId === sandboxId);
+      if (tags && Object.keys(tags).length > 0) {
+        filtered = filtered.filter((s) => {
+          const sessionTags = s.tags ?? {};
+          return Object.entries(tags).every(
+            ([key, value]) => equal(sessionTags[key], value)
+          );
+        });
+      }
+      const resolvedOrder = order ?? "updatedAt_desc";
+      const sortField = resolvedOrder.startsWith("updatedAt") ? "updatedAt" : "createdAt";
+      const sortDir = resolvedOrder.endsWith("_desc") ? -1 : 1;
+      filtered.sort((a, b) => sortDir * (a[sortField] - b[sortField]));
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "session.tag.set": async ({ sessionId, tags }) => {
+      return await withRecordLock(`session:${sessionId}`, async () => {
+        const sessionPath = join(sessionDir, `${sessionId}.json`);
+        const existing = await readJson(sessionPath);
+        if (!existing) {
+          throw new Error(`Session ${sessionId} not found`);
+        }
+        const mergedTags = { ...existing.tags, ...tags };
+        const now = Date.now();
+        const updatedSession = {
+          ...existing,
+          tags: mergedTags,
+          updatedAt: now
+        };
+        await writeJsonFile(sessionPath, updatedSession);
+        return updatedSession;
+      });
+    },
+    "message.get": async ({ id }) => {
+      return await readJson(join(messageDir, `${id}.json`));
+    },
+    "message.set": async (message) => {
+      await writeJsonFile(join(messageDir, `${message.id}.json`), message);
+      return message;
+    },
+    "message.list": async ({ sessionId, cursor, limit }) => {
+      const allMessages = await readAllFromDir(messageDir);
+      const filtered = allMessages.filter((m) => m.sessionId === sessionId).sort((a, b) => a.createdAt - b.createdAt);
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "part.listByMessage": async ({ messageId, cursor, limit }) => {
+      const allParts = await readAllFromDir(partDir);
+      const filtered = allParts.filter((p) => p.messageId === messageId).sort((a, b) => a.index - b.index);
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "part.listBySession": async ({ sessionId, cursor, limit }) => {
+      const allParts = await readAllFromDir(partDir);
+      const filtered = allParts.filter((p) => p.sessionId === sessionId).sort((a, b) => {
+        if (a.messageId !== b.messageId) {
+          return a.messageId.localeCompare(b.messageId);
+        }
+        return a.index - b.index;
+      });
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "part.set": async (part) => {
+      await writeJsonFile(join(partDir, `${part.id}.json`), part);
+      return part;
+    },
+    "part.delete": async ({ id }) => {
+      try {
+        await unlink(join(partDir, `${id}.json`));
+      } catch {
+      }
+    },
+    "sandbox.get": async ({ key }) => {
+      const safeName = Buffer.from(key).toString("base64url");
+      const sandboxPath = join(sandboxDir, `${safeName}.json`);
+      const data = await readJson(sandboxPath);
+      if (!data) {
+        return null;
+      }
+      return data;
+    },
+    "sandbox.set": async (record) => {
+      await withRecordLock(`sandbox:${record.id}`, async () => {
+        const safeName = Buffer.from(record.id).toString("base64url");
+        const sandboxPath = join(sandboxDir, `${safeName}.json`);
+        const existing = await readJson(sandboxPath);
+        const newRecord = {
+          ...record,
+          tags: record.tags ?? existing?.tags ?? null
+        };
+        await writeJsonFile(sandboxPath, newRecord);
+      });
+    },
+    "sandbox.update": async (opts) => {
+      return await withRecordLock(`sandbox:${opts.id}`, async () => {
+        const safeName = Buffer.from(opts.id).toString("base64url");
+        const sandboxPath = join(sandboxDir, `${safeName}.json`);
+        const existing = await readJson(sandboxPath);
+        if (!existing) {
+          throw new Error(`Sandbox ${opts.id} not found`);
+        }
+        const patch = removeUndefined({
+          ...opts,
+          id: void 0
+        });
+        if (Object.keys(patch).length === 0) {
+          return existing;
+        }
+        const updatedSandbox = {
+          ...existing,
+          ...patch
+        };
+        await writeJsonFile(sandboxPath, updatedSandbox);
+        return updatedSandbox;
+      });
+    },
+    "sandbox.list": async ({ tags, order, cursor, limit }) => {
+      const allSandboxes = await readAllFromDir(sandboxDir);
+      let filtered = allSandboxes;
+      if (tags && Object.keys(tags).length > 0) {
+        filtered = filtered.filter((s) => {
+          const sandboxTags = s.tags ?? {};
+          return Object.entries(tags).every(
+            ([key, value]) => equal(sandboxTags[key], value)
+          );
+        });
+      }
+      const sortField = order?.startsWith("lastActivityAt") ? "lastActivityAt" : "createdAt";
+      const sortDir = order?.endsWith("_desc") ? -1 : 1;
+      filtered.sort(
+        (a, b) => sortDir * ((a[sortField] ?? 0) - (b[sortField] ?? 0))
+      );
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "sandbox.tag.set": async ({ sandboxId, tags }) => {
+      return await withRecordLock(`sandbox:${sandboxId}`, async () => {
+        const safeName = Buffer.from(sandboxId).toString("base64url");
+        const sandboxPath = join(sandboxDir, `${safeName}.json`);
+        const existing = await readJson(sandboxPath);
+        if (!existing) {
+          throw new Error(`Sandbox ${sandboxId} not found`);
+        }
+        const mergedTags = { ...existing.tags, ...tags };
+        const updatedSandbox = {
+          ...existing,
+          tags: mergedTags
+        };
+        await writeJsonFile(sandboxPath, updatedSandbox);
+        return updatedSandbox;
+      });
+    },
+    "sandbox.getBySession": async ({ sessionId }) => {
+      const sessionPath = join(sessionDir, `${sessionId}.json`);
+      const session = await readJson(sessionPath);
+      if (!session?.sandboxId) {
+        return null;
+      }
+      const safeName = Buffer.from(session.sandboxId).toString("base64url");
+      return await readJson(
+        join(sandboxDir, `${safeName}.json`)
+      );
+    },
+    "command.get": async ({ id }) => {
+      return await readJson(join(commandDir, `${id}.json`));
+    },
+    "command.set": async (command) => {
+      await writeJsonFile(join(commandDir, `${command.id}.json`), command);
+      return command;
+    },
+    "setup.get": async ({ key }) => {
+      const safeName = Buffer.from(key).toString("base64url");
+      return await readJson(join(setupDir, `${safeName}.json`));
+    },
+    "setup.set": async (snapshot) => {
+      await withRecordLock(`setup:${snapshot.key}`, async () => {
+        const safeName = Buffer.from(snapshot.key).toString("base64url");
+        await writeJsonFile(join(setupDir, `${safeName}.json`), snapshot);
+      });
+    },
+    "setup.acquireLock": async ({ key, lockId, lockTimeoutMs }) => {
+      return await withRecordLock(`setup:${key}`, async () => {
+        const safeName = Buffer.from(key).toString("base64url");
+        const filePath = join(setupDir, `${safeName}.json`);
+        const existing = await readJson(filePath);
+        if (existing?.acquiringLockId && existing.acquiringLockAt && Date.now() - existing.acquiringLockAt < lockTimeoutMs) {
+          return null;
+        }
+        const now = Date.now();
+        const snapshot = {
+          key,
+          snapshotId: existing?.snapshotId ?? null,
+          createdAt: existing?.createdAt ?? now,
+          lastUsedAt: existing?.lastUsedAt ?? null,
+          acquiringLockId: lockId,
+          acquiringLockAt: now
+        };
+        await writeJsonFile(filePath, snapshot);
+        return snapshot;
+      });
+    },
+    "sandbox.acquireLock": async ({ record, lockTimeoutMs }) => {
+      return await withRecordLock(`sandbox:${record.id}`, async () => {
+        const safeName = Buffer.from(record.id).toString("base64url");
+        const filePath = join(sandboxDir, `${safeName}.json`);
+        const existing = await readJson(filePath);
+        if (existing?.acquiringLockId && existing.acquiringLockAt && Date.now() - existing.acquiringLockAt < lockTimeoutMs) {
+          return null;
+        }
+        const newRecord = {
+          ...record,
+          tags: record.tags ?? existing?.tags ?? null
+        };
+        await writeJsonFile(filePath, newRecord);
+        return newRecord;
+      });
+    },
+    "command.list": async ({ sessionId, includeFinished, cursor, limit }) => {
+      const allCommands = await readAllFromDir(commandDir);
+      let filtered = allCommands.filter((c) => c.sessionId === sessionId);
+      if (!includeFinished) {
+        filtered = filtered.filter((c) => c.status === "running");
+      }
+      filtered.sort((a, b) => a.startedAt - b.startedAt);
+      return paginate({ items: filtered, cursor, limit });
+    }
+  };
+}
+export {
+  createFilesystemHandlers
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/bindings/local-fs-handlers.ts", "../src/utils/paginate.ts"],
  "sourcesContent": ["import {\n  mkdir,\n  readdir,\n  readFile,\n  rm,\n  unlink,\n  writeFile,\n} from \"node:fs/promises\";\nimport { dirname, join, resolve } from \"node:path\";\nimport equal from \"fast-deep-equal\";\nimport { StorageConflictError } from \"../../errors\";\nimport { paginate } from \"../../utils/paginate\";\nimport type {\n  Command,\n  Handlers,\n  Message,\n  Part,\n  SandboxRecord,\n  Session,\n  SetupSnapshot,\n} from \"..\";\n\nexport function createFilesystemHandlers(basePath: string): Handlers {\n  const resolvedBase = resolve(basePath);\n  const sessionDir = join(resolvedBase, \"session\");\n  const messageDir = join(resolvedBase, \"message\");\n  const partDir = join(resolvedBase, \"part\");\n  const sandboxDir = join(resolvedBase, \"sandbox\");\n  const commandDir = join(resolvedBase, \"command\");\n  const setupDir = join(resolvedBase, \"setup\");\n  const lockDir = join(resolvedBase, \".locks\");\n  const LOCK_STALE_MS = 30_000;\n\n  async function ensureDir(dir: string) {\n    await mkdir(dir, { recursive: true });\n  }\n\n  async function readJson<T>(filePath: string): Promise<T | null> {\n    try {\n      const content = await readFile(filePath, \"utf-8\");\n      return JSON.parse(content) as T;\n    } catch {\n      return null;\n    }\n  }\n\n  async function writeJsonFile(filePath: string, data: unknown) {\n    await ensureDir(dirname(filePath));\n    await writeFile(filePath, JSON.stringify(data, null, 2));\n  }\n\n  async function withRecordLock<T>(\n    key: string,\n    fn: () => Promise<T>\n  ): Promise<T> {\n    const lockName = Buffer.from(key).toString(\"base64url\");\n    const lockPath = join(lockDir, `${lockName}.lock`);\n    const metadataPath = join(lockPath, \"metadata.json\");\n    await ensureDir(lockDir);\n\n    while (true) {\n      try {\n        await mkdir(lockPath);\n        await writeJsonFile(metadataPath, {\n          pid: process.pid,\n          createdAt: Date.now(),\n        });\n        break;\n      } catch (e) {\n        if (\n          !(e instanceof Error) ||\n          (e as NodeJS.ErrnoException).code !== \"EEXIST\"\n        ) {\n          throw e;\n        }\n        const metadata = await readJson<{ createdAt?: number }>(metadataPath);\n        if (\n          metadata?.createdAt &&\n          Date.now() - metadata.createdAt > LOCK_STALE_MS\n        ) {\n          await rm(lockPath, { recursive: true, force: true });\n          continue;\n        }\n        await new Promise((r) => setTimeout(r, 10));\n      }\n    }\n\n    try {\n      return await fn();\n    } finally {\n      await rm(lockPath, { recursive: true, force: true });\n    }\n  }\n\n  function removeUndefined<T extends Record<string, unknown>>(\n    input: T\n  ): Partial<T> {\n    const result: Partial<T> = {};\n    for (const [key, value] of Object.entries(input)) {\n      if (value !== undefined) {\n        result[key as keyof T] = value as T[keyof T];\n      }\n    }\n    return result;\n  }\n\n  async function readAllFromDir<T>(dir: string): Promise<T[]> {\n    try {\n      const files = await readdir(dir);\n      const results = await Promise.all(\n        files\n          .filter((f) => f.endsWith(\".json\"))\n          .map((f) => readJson<T>(join(dir, f)))\n      );\n      return results.filter((r): r is NonNullable<typeof r> => r !== null);\n    } catch {\n      return [];\n    }\n  }\n\n  return {\n    \"session.get\": async ({ id }) => {\n      const sessionPath = join(sessionDir, `${id}.json`);\n      return (await readJson<Session>(sessionPath)) ?? null;\n    },\n\n    \"session.set\": async (session) => {\n      return await withRecordLock(`session:${session.id}`, async () => {\n        const now = Date.now();\n        const sessionPath = join(sessionDir, `${session.id}.json`);\n        const existing = await readJson<Session>(sessionPath);\n        const newSession: Session = {\n          ...session,\n          tags: session.tags ?? existing?.tags ?? {},\n          createdAt: existing?.createdAt ?? session.createdAt ?? now,\n          updatedAt: now,\n        };\n        await writeJsonFile(sessionPath, newSession);\n        return newSession;\n      });\n    },\n\n    \"session.update\": async (opts) => {\n      return await withRecordLock(`session:${opts.id}`, async () => {\n        const sessionPath = join(sessionDir, `${opts.id}.json`);\n        const existing = await readJson<Session>(sessionPath);\n        if (!existing) {\n          throw new Error(`Session ${opts.id} not found`);\n        }\n\n        const rawPatch = removeUndefined({\n          ...opts,\n          id: undefined,\n        });\n        if (Object.keys(rawPatch).length === 0) {\n          return existing;\n        }\n\n        if (Object.hasOwn(rawPatch, \"runId\")) {\n          const nextRunId = rawPatch.runId as Session[\"runId\"] | undefined;\n          if (existing.runId !== null && nextRunId === null) {\n            throw new StorageConflictError({\n              reason: \"runId cannot be cleared once set\",\n            });\n          }\n          if (existing.runId !== null && nextRunId !== existing.runId) {\n            throw new StorageConflictError({\n              reason: `runId is already set to ${existing.runId}`,\n            });\n          }\n        }\n\n        const patch = rawPatch as Partial<Omit<Session, \"id\">>;\n        const updatedAt =\n          patch.updatedAt !== undefined ? patch.updatedAt : Date.now();\n        const updatedSession: Session = {\n          ...existing,\n          ...patch,\n          updatedAt,\n        };\n        await writeJsonFile(sessionPath, updatedSession);\n        return updatedSession;\n      });\n    },\n\n    \"session.delete\": async ({ id }) => {\n      try {\n        await unlink(join(sessionDir, `${id}.json`));\n      } catch {\n        // ignore if file doesn't exist\n      }\n      const allMessages = await readAllFromDir<Message>(messageDir);\n      const sessionMessages = allMessages.filter((m) => m.sessionId === id);\n      const allParts = await readAllFromDir<Part>(partDir);\n      const sessionParts = allParts.filter((p) => p.sessionId === id);\n      const allCommands = await readAllFromDir<Command>(commandDir);\n      const sessionCommands = allCommands.filter((c) => c.sessionId === id);\n      const noop = () => undefined;\n      await Promise.all([\n        ...sessionMessages.map((m) =>\n          unlink(join(messageDir, `${m.id}.json`)).catch(noop)\n        ),\n        ...sessionParts.map((p) =>\n          unlink(join(partDir, `${p.id}.json`)).catch(noop)\n        ),\n        ...sessionCommands.map((c) =>\n          unlink(join(commandDir, `${c.id}.json`)).catch(noop)\n        ),\n      ]);\n    },\n\n    \"session.list\": async ({ tags, order, cursor, limit }) => {\n      const allSessions = await readAllFromDir<Session>(sessionDir);\n      let filtered = allSessions;\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sessionTags = s.tags ?? {};\n          return Object.entries(tags).every(([key, value]) =>\n            equal(sessionTags[key], value)\n          );\n        });\n      }\n      const resolvedOrder = order ?? \"updatedAt_desc\";\n      const sortField = resolvedOrder.startsWith(\"updatedAt\")\n        ? \"updatedAt\"\n        : \"createdAt\";\n      const sortDir = resolvedOrder.endsWith(\"_desc\") ? -1 : 1;\n      filtered.sort((a, b) => sortDir * (a[sortField] - b[sortField]));\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"session.listBySandbox\": async ({\n      sandboxId,\n      tags,\n      order,\n      cursor,\n      limit,\n    }) => {\n      const allSessions = await readAllFromDir<Session>(sessionDir);\n      let filtered = allSessions.filter((s) => s.sandboxId === sandboxId);\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sessionTags = s.tags ?? {};\n          return Object.entries(tags).every(([key, value]) =>\n            equal(sessionTags[key], value)\n          );\n        });\n      }\n      const resolvedOrder = order ?? \"updatedAt_desc\";\n      const sortField = resolvedOrder.startsWith(\"updatedAt\")\n        ? \"updatedAt\"\n        : \"createdAt\";\n      const sortDir = resolvedOrder.endsWith(\"_desc\") ? -1 : 1;\n      filtered.sort((a, b) => sortDir * (a[sortField] - b[sortField]));\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"session.tag.set\": async ({ sessionId, tags }) => {\n      return await withRecordLock(`session:${sessionId}`, async () => {\n        const sessionPath = join(sessionDir, `${sessionId}.json`);\n        const existing = await readJson<Session>(sessionPath);\n        if (!existing) {\n          throw new Error(`Session ${sessionId} not found`);\n        }\n        const mergedTags = { ...existing.tags, ...tags };\n        const now = Date.now();\n        const updatedSession: Session = {\n          ...existing,\n          tags: mergedTags,\n          updatedAt: now,\n        };\n        await writeJsonFile(sessionPath, updatedSession);\n        return updatedSession;\n      });\n    },\n\n    \"message.get\": async ({ id }) => {\n      return await readJson<Message>(join(messageDir, `${id}.json`));\n    },\n\n    \"message.set\": async (message) => {\n      await writeJsonFile(join(messageDir, `${message.id}.json`), message);\n      return message;\n    },\n\n    \"message.list\": async ({ sessionId, cursor, limit }) => {\n      const allMessages = await readAllFromDir<Message>(messageDir);\n      const filtered = allMessages\n        .filter((m) => m.sessionId === sessionId)\n        .sort((a, b) => a.createdAt - b.createdAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.listByMessage\": async ({ messageId, cursor, limit }) => {\n      const allParts = await readAllFromDir<Part>(partDir);\n      const filtered = allParts\n        .filter((p) => p.messageId === messageId)\n        .sort((a, b) => a.index - b.index);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.listBySession\": async ({ sessionId, cursor, limit }) => {\n      const allParts = await readAllFromDir<Part>(partDir);\n      const filtered = allParts\n        .filter((p) => p.sessionId === sessionId)\n        .sort((a, b) => {\n          if (a.messageId !== b.messageId) {\n            return a.messageId.localeCompare(b.messageId);\n          }\n          return a.index - b.index;\n        });\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"part.set\": async (part) => {\n      await writeJsonFile(join(partDir, `${part.id}.json`), part);\n      return part;\n    },\n\n    \"part.delete\": async ({ id }) => {\n      try {\n        await unlink(join(partDir, `${id}.json`));\n      } catch {\n        // Ignore if file doesn't exist\n      }\n    },\n\n    \"sandbox.get\": async ({ key }) => {\n      const safeName = Buffer.from(key).toString(\"base64url\");\n      const sandboxPath = join(sandboxDir, `${safeName}.json`);\n      const data = await readJson<SandboxRecord>(sandboxPath);\n      if (!data) {\n        return null;\n      }\n      return data;\n    },\n\n    \"sandbox.set\": async (record) => {\n      await withRecordLock(`sandbox:${record.id}`, async () => {\n        const safeName = Buffer.from(record.id).toString(\"base64url\");\n        const sandboxPath = join(sandboxDir, `${safeName}.json`);\n        const existing = await readJson<SandboxRecord>(sandboxPath);\n        const newRecord: SandboxRecord = {\n          ...record,\n          tags: record.tags ?? existing?.tags ?? null,\n        };\n        await writeJsonFile(sandboxPath, newRecord);\n      });\n    },\n\n    \"sandbox.update\": async (opts) => {\n      return await withRecordLock(`sandbox:${opts.id}`, async () => {\n        const safeName = Buffer.from(opts.id).toString(\"base64url\");\n        const sandboxPath = join(sandboxDir, `${safeName}.json`);\n        const existing = await readJson<SandboxRecord>(sandboxPath);\n        if (!existing) {\n          throw new Error(`Sandbox ${opts.id} not found`);\n        }\n        const patch = removeUndefined({\n          ...opts,\n          id: undefined,\n        }) as Partial<Omit<SandboxRecord, \"id\">>;\n        if (Object.keys(patch).length === 0) {\n          return existing;\n        }\n        const updatedSandbox: SandboxRecord = {\n          ...existing,\n          ...patch,\n        };\n        await writeJsonFile(sandboxPath, updatedSandbox);\n        return updatedSandbox;\n      });\n    },\n\n    \"sandbox.list\": async ({ tags, order, cursor, limit }) => {\n      const allSandboxes = await readAllFromDir<SandboxRecord>(sandboxDir);\n      let filtered = allSandboxes;\n      if (tags && Object.keys(tags).length > 0) {\n        filtered = filtered.filter((s) => {\n          const sandboxTags = s.tags ?? {};\n          return Object.entries(tags).every(([key, value]) =>\n            equal(sandboxTags[key], value)\n          );\n        });\n      }\n      const sortField = order?.startsWith(\"lastActivityAt\")\n        ? \"lastActivityAt\"\n        : \"createdAt\";\n      const sortDir = order?.endsWith(\"_desc\") ? -1 : 1;\n      filtered.sort(\n        (a, b) => sortDir * ((a[sortField] ?? 0) - (b[sortField] ?? 0))\n      );\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"sandbox.tag.set\": async ({ sandboxId, tags }) => {\n      return await withRecordLock(`sandbox:${sandboxId}`, async () => {\n        const safeName = Buffer.from(sandboxId).toString(\"base64url\");\n        const sandboxPath = join(sandboxDir, `${safeName}.json`);\n        const existing = await readJson<SandboxRecord>(sandboxPath);\n        if (!existing) {\n          throw new Error(`Sandbox ${sandboxId} not found`);\n        }\n        const mergedTags = { ...existing.tags, ...tags };\n        const updatedSandbox: SandboxRecord = {\n          ...existing,\n          tags: mergedTags,\n        };\n        await writeJsonFile(sandboxPath, updatedSandbox);\n        return updatedSandbox;\n      });\n    },\n\n    \"sandbox.getBySession\": async ({ sessionId }) => {\n      const sessionPath = join(sessionDir, `${sessionId}.json`);\n      const session = await readJson<Session>(sessionPath);\n      if (!session?.sandboxId) {\n        return null;\n      }\n\n      const safeName = Buffer.from(session.sandboxId).toString(\"base64url\");\n      return await readJson<SandboxRecord>(\n        join(sandboxDir, `${safeName}.json`)\n      );\n    },\n\n    \"command.get\": async ({ id }) => {\n      return await readJson<Command>(join(commandDir, `${id}.json`));\n    },\n\n    \"command.set\": async (command) => {\n      await writeJsonFile(join(commandDir, `${command.id}.json`), command);\n      return command;\n    },\n\n    \"setup.get\": async ({ key }) => {\n      const safeName = Buffer.from(key).toString(\"base64url\");\n      return await readJson<SetupSnapshot>(join(setupDir, `${safeName}.json`));\n    },\n\n    \"setup.set\": async (snapshot) => {\n      await withRecordLock(`setup:${snapshot.key}`, async () => {\n        const safeName = Buffer.from(snapshot.key).toString(\"base64url\");\n        await writeJsonFile(join(setupDir, `${safeName}.json`), snapshot);\n      });\n    },\n\n    \"setup.acquireLock\": async ({ key, lockId, lockTimeoutMs }) => {\n      return await withRecordLock(`setup:${key}`, async () => {\n        const safeName = Buffer.from(key).toString(\"base64url\");\n        const filePath = join(setupDir, `${safeName}.json`);\n        const existing = await readJson<SetupSnapshot>(filePath);\n        if (\n          existing?.acquiringLockId &&\n          existing.acquiringLockAt &&\n          Date.now() - existing.acquiringLockAt < lockTimeoutMs\n        ) {\n          return null;\n        }\n        const now = Date.now();\n        const snapshot: SetupSnapshot = {\n          key,\n          snapshotId: existing?.snapshotId ?? null,\n          createdAt: existing?.createdAt ?? now,\n          lastUsedAt: existing?.lastUsedAt ?? null,\n          acquiringLockId: lockId,\n          acquiringLockAt: now,\n        };\n        await writeJsonFile(filePath, snapshot);\n        return snapshot;\n      });\n    },\n\n    \"sandbox.acquireLock\": async ({ record, lockTimeoutMs }) => {\n      return await withRecordLock(`sandbox:${record.id}`, async () => {\n        const safeName = Buffer.from(record.id).toString(\"base64url\");\n        const filePath = join(sandboxDir, `${safeName}.json`);\n        const existing = await readJson<SandboxRecord>(filePath);\n        if (\n          existing?.acquiringLockId &&\n          existing.acquiringLockAt &&\n          Date.now() - existing.acquiringLockAt < lockTimeoutMs\n        ) {\n          return null;\n        }\n        const newRecord: SandboxRecord = {\n          ...record,\n          tags: record.tags ?? existing?.tags ?? null,\n        };\n        await writeJsonFile(filePath, newRecord);\n        return newRecord;\n      });\n    },\n\n    \"command.list\": async ({ sessionId, includeFinished, cursor, limit }) => {\n      const allCommands = await readAllFromDir<Command>(commandDir);\n      let filtered = allCommands.filter((c) => c.sessionId === sessionId);\n      if (!includeFinished) {\n        filtered = filtered.filter((c) => c.status === \"running\");\n      }\n      filtered.sort((a, b) => a.startedAt - b.startedAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n  };\n}\n", "import type { ListResult } from \"../storage\";\n\nexport function paginate<T extends { id: string }>(opts: {\n  items: T[];\n  cursor?: string;\n  limit?: number;\n}): ListResult<T> {\n  const { items, cursor, limit } = opts;\n  const startIndex = cursor ? items.findIndex((m) => m.id === cursor) + 1 : 0;\n  const sliced =\n    limit !== undefined\n      ? items.slice(startIndex, startIndex + limit)\n      : items.slice(startIndex);\n  const nextCursor =\n    limit !== undefined && startIndex + limit < items.length\n      ? (sliced.at(-1)?.id ?? null)\n      : null;\n  return { items: sliced, nextCursor };\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/next/loader.js

@@ -39,7 +39,7 @@ var import_core = require("@swc/core");
 // package.json
 var package_default = {
   name: "experimental-agent",
-  version: "0.1.2",
+  version: "0.1.3",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
   types: "./dist/index.d.ts",
@@ -104,7 +104,7 @@ var package_default = {
   },
   peerDependencies: {
     ai: "^6.0.0",
-    workflow: "https://workflow-docs-6sokmamy6.vercel.sh/workflow.tgz"
+    workflow: "*"
   },
   publishConfig: {
     access: "public"
@@ -203,4 +203,4 @@ function findAgentExports(ast) {
   }
   return exports2;
 }
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/next/loader.ts", "../../package.json"],
  "sourcesContent": ["import * as path from \"node:path\";\nimport { type Module, parseSync } from \"@swc/core\";\nimport pkg from \"../../package.json\";\n\ntype LoaderOptions = {\n  debug?: boolean;\n};\n\ntype LoaderContext = {\n  resourcePath: string;\n  getOptions(): LoaderOptions;\n};\n\nconst PACKAGE_NAME = pkg.name;\nconst AGENT_PROTOCOL_VERSION = \"v1\";\nconst TYPESCRIPT_EXT_REGEX = /\\.(ts|tsx|mts|cts)$/;\n\n/**\n * Webpack/Turbopack loader that wires up agent.rpc by requiring steps.js\n * at the END of the file. Using require() avoids import hoisting issues.\n */\nexport default function agentRpcLoader(\n  this: LoaderContext,\n  source: string\n): string {\n  const { debug } = this.getOptions();\n  const log = debug\n    ? (...args: unknown[]) => console.log(\"[agent-loader]\", ...args)\n    : () => undefined;\n\n  log(\"processing:\", this.resourcePath);\n\n  if (!source.includes(PACKAGE_NAME)) {\n    log(\"skipping - no package name\");\n    return source;\n  }\n\n  const filename = this.resourcePath;\n  const isTypeScript = TYPESCRIPT_EXT_REGEX.test(filename);\n\n  let ast: Module;\n  try {\n    ast = parseSync(source, {\n      syntax: isTypeScript ? \"typescript\" : \"ecmascript\",\n      tsx: filename.endsWith(\".tsx\"),\n      jsx: filename.endsWith(\".jsx\"),\n    });\n  } catch {\n    return source;\n  }\n\n  const agentExports = findAgentExports(ast);\n  if (agentExports.length === 0) {\n    log(\"skipping - no agent exports\");\n    return source;\n  }\n\n  log(\"found agent exports:\", agentExports);\n\n  // Calculate path to steps.js\n  const fileDir = path.dirname(filename);\n  const srcIndex = filename.lastIndexOf(`${path.sep}src${path.sep}`);\n  if (srcIndex === -1) {\n    log(\"skipping - no src dir found\");\n    return source;\n  }\n\n  const srcDir = filename.substring(0, srcIndex + 4);\n  const appDir = path.join(srcDir, \"app\");\n  const stepsPath = path.join(\n    appDir,\n    \".well-known\",\n    \"agent\",\n    AGENT_PROTOCOL_VERSION,\n    \"steps.js\"\n  );\n  let relativePath = path.relative(fileDir, stepsPath).replace(/\\\\/g, \"/\");\n\n  if (!(relativePath.startsWith(\"./\") || relativePath.startsWith(\"../\"))) {\n    relativePath = `./${relativePath}`;\n  }\n\n  // Import the init function from steps.js and call it for each agent\n  // steps.js no longer imports the agent, so no circular dependency\n  const initCalls = agentExports\n    .map((name) => {\n      const initName = `__init${name[0].toUpperCase()}${name.slice(1)}`;\n      return `${initName}(${name});`;\n    })\n    .join(\"\\n\");\n\n  const initImports = agentExports\n    .map((name) => `__init${name[0].toUpperCase()}${name.slice(1)}`)\n    .join(\", \");\n\n  log(\"injecting init calls for:\", agentExports);\n  return `${source}\nimport { ${initImports} } from \"${relativePath}\";\n${initCalls}`;\n}\n\nfunction findAgentExports(ast: Module): string[] {\n  let agentLocalName: string | null = null;\n\n  for (const item of ast.body) {\n    if (\n      item.type === \"ImportDeclaration\" &&\n      item.source.value === PACKAGE_NAME\n    ) {\n      for (const specifier of item.specifiers) {\n        if (specifier.type === \"ImportSpecifier\") {\n          const imported =\n            specifier.imported?.type === \"Identifier\"\n              ? specifier.imported.value\n              : specifier.local.value;\n\n          if (imported === \"agent\") {\n            agentLocalName = specifier.local.value;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (!agentLocalName) {\n    return [];\n  }\n\n  const exports: string[] = [];\n\n  for (const item of ast.body) {\n    if (item.type === \"ExportDeclaration\" && item.declaration) {\n      const decl = item.declaration;\n      if (decl.type === \"VariableDeclaration\") {\n        for (const declarator of decl.declarations) {\n          if (\n            declarator.id.type === \"Identifier\" &&\n            declarator.init?.type === \"CallExpression\" &&\n            declarator.init.callee.type === \"Identifier\" &&\n            declarator.init.callee.value === agentLocalName\n          ) {\n            exports.push(declarator.id.value);\n          }\n        }\n      }\n    }\n  }\n\n  return exports;\n}\n", "{\n  \"name\": \"experimental-agent\",\n  \"version\": \"0.1.2\",\n  \"main\": \"./dist/index.js\",\n  \"module\": \"./dist/index.mjs\",\n  \"types\": \"./dist/index.d.ts\",\n  \"sideEffects\": true,\n  \"license\": \"MIT\",\n  \"files\": [\n    \"dist/**\"\n  ],\n  \"exports\": {\n    \".\": {\n      \"types\": \"./dist/index.d.ts\",\n      \"import\": \"./dist/index.mjs\",\n      \"require\": \"./dist/index.js\"\n    },\n    \"./next\": {\n      \"types\": \"./dist/next.d.ts\",\n      \"import\": \"./dist/next.mjs\",\n      \"require\": \"./dist/next.js\"\n    },\n    \"./next/loader\": {\n      \"types\": \"./dist/next/loader.d.ts\",\n      \"import\": \"./dist/next/loader.mjs\",\n      \"require\": \"./dist/next/loader.js\"\n    },\n    \"./client\": {\n      \"types\": \"./dist/client.d.ts\",\n      \"import\": \"./dist/client.mjs\",\n      \"require\": \"./dist/client.js\"\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"dev\": \"tsup --watch\",\n    \"clean\": \"rm -rf .turbo && rm -rf node_modules && rm -rf dist\",\n    \"release\": \"pnpm build && npm publish\",\n    \"typecheck\": \"tsc --noEmit\",\n    \"test\": \"vitest run\",\n    \"test:watch\": \"vitest\"\n  },\n  \"dependencies\": {\n    \"@hono/node-server\": \"^1.19.9\",\n    \"@swc/core\": \"^1.10.0\",\n    \"@vercel/oidc\": \"^3.1.0\",\n    \"better-all\": \"^0.0.5\",\n    \"errore\": \"^0.8.2\",\n    \"fast-deep-equal\": \"^3.1.3\",\n    \"glob\": \"^11.0.0\",\n    \"hono\": \"^4.11.6\",\n    \"@vercel/sandbox\": \"^1.5.0\",\n    \"ulid\": \"^3.0.2\",\n    \"zod\": \"^4.3.6\"\n  },\n  \"devDependencies\": {\n    \"@agent/tsconfig\": \"workspace:*\",\n    \"@types/node\": \"^20.11.24\",\n    \"dotenv\": \"^17.2.3\",\n    \"next\": \"^16.0.0\",\n    \"tsup\": \"^8.0.2\",\n    \"type-fest\": \"^5.4.2\",\n    \"typescript\": \"5.5.4\",\n    \"vitest\": \"^3.0.0\"\n  },\n  \"peerDependencies\": {\n    \"ai\": \"^6.0.0\",\n    \"workflow\": \"https://workflow-docs-6sokmamy6.vercel.sh/workflow.tgz\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": "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",
  "names": ["exports"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/next/loader.ts", "../../package.json"],
  "sourcesContent": ["import * as path from \"node:path\";\nimport { type Module, parseSync } from \"@swc/core\";\nimport pkg from \"../../package.json\";\n\ntype LoaderOptions = {\n  debug?: boolean;\n};\n\ntype LoaderContext = {\n  resourcePath: string;\n  getOptions(): LoaderOptions;\n};\n\nconst PACKAGE_NAME = pkg.name;\nconst AGENT_PROTOCOL_VERSION = \"v1\";\nconst TYPESCRIPT_EXT_REGEX = /\\.(ts|tsx|mts|cts)$/;\n\n/**\n * Webpack/Turbopack loader that wires up agent.rpc by requiring steps.js\n * at the END of the file. Using require() avoids import hoisting issues.\n */\nexport default function agentRpcLoader(\n  this: LoaderContext,\n  source: string\n): string {\n  const { debug } = this.getOptions();\n  const log = debug\n    ? (...args: unknown[]) => console.log(\"[agent-loader]\", ...args)\n    : () => undefined;\n\n  log(\"processing:\", this.resourcePath);\n\n  if (!source.includes(PACKAGE_NAME)) {\n    log(\"skipping - no package name\");\n    return source;\n  }\n\n  const filename = this.resourcePath;\n  const isTypeScript = TYPESCRIPT_EXT_REGEX.test(filename);\n\n  let ast: Module;\n  try {\n    ast = parseSync(source, {\n      syntax: isTypeScript ? \"typescript\" : \"ecmascript\",\n      tsx: filename.endsWith(\".tsx\"),\n      jsx: filename.endsWith(\".jsx\"),\n    });\n  } catch {\n    return source;\n  }\n\n  const agentExports = findAgentExports(ast);\n  if (agentExports.length === 0) {\n    log(\"skipping - no agent exports\");\n    return source;\n  }\n\n  log(\"found agent exports:\", agentExports);\n\n  // Calculate path to steps.js\n  const fileDir = path.dirname(filename);\n  const srcIndex = filename.lastIndexOf(`${path.sep}src${path.sep}`);\n  if (srcIndex === -1) {\n    log(\"skipping - no src dir found\");\n    return source;\n  }\n\n  const srcDir = filename.substring(0, srcIndex + 4);\n  const appDir = path.join(srcDir, \"app\");\n  const stepsPath = path.join(\n    appDir,\n    \".well-known\",\n    \"agent\",\n    AGENT_PROTOCOL_VERSION,\n    \"steps.js\"\n  );\n  let relativePath = path.relative(fileDir, stepsPath).replace(/\\\\/g, \"/\");\n\n  if (!(relativePath.startsWith(\"./\") || relativePath.startsWith(\"../\"))) {\n    relativePath = `./${relativePath}`;\n  }\n\n  // Import the init function from steps.js and call it for each agent\n  // steps.js no longer imports the agent, so no circular dependency\n  const initCalls = agentExports\n    .map((name) => {\n      const initName = `__init${name[0].toUpperCase()}${name.slice(1)}`;\n      return `${initName}(${name});`;\n    })\n    .join(\"\\n\");\n\n  const initImports = agentExports\n    .map((name) => `__init${name[0].toUpperCase()}${name.slice(1)}`)\n    .join(\", \");\n\n  log(\"injecting init calls for:\", agentExports);\n  return `${source}\nimport { ${initImports} } from \"${relativePath}\";\n${initCalls}`;\n}\n\nfunction findAgentExports(ast: Module): string[] {\n  let agentLocalName: string | null = null;\n\n  for (const item of ast.body) {\n    if (\n      item.type === \"ImportDeclaration\" &&\n      item.source.value === PACKAGE_NAME\n    ) {\n      for (const specifier of item.specifiers) {\n        if (specifier.type === \"ImportSpecifier\") {\n          const imported =\n            specifier.imported?.type === \"Identifier\"\n              ? specifier.imported.value\n              : specifier.local.value;\n\n          if (imported === \"agent\") {\n            agentLocalName = specifier.local.value;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (!agentLocalName) {\n    return [];\n  }\n\n  const exports: string[] = [];\n\n  for (const item of ast.body) {\n    if (item.type === \"ExportDeclaration\" && item.declaration) {\n      const decl = item.declaration;\n      if (decl.type === \"VariableDeclaration\") {\n        for (const declarator of decl.declarations) {\n          if (\n            declarator.id.type === \"Identifier\" &&\n            declarator.init?.type === \"CallExpression\" &&\n            declarator.init.callee.type === \"Identifier\" &&\n            declarator.init.callee.value === agentLocalName\n          ) {\n            exports.push(declarator.id.value);\n          }\n        }\n      }\n    }\n  }\n\n  return exports;\n}\n", "{\n  \"name\": \"experimental-agent\",\n  \"version\": \"0.1.3\",\n  \"main\": \"./dist/index.js\",\n  \"module\": \"./dist/index.mjs\",\n  \"types\": \"./dist/index.d.ts\",\n  \"sideEffects\": true,\n  \"license\": \"MIT\",\n  \"files\": [\n    \"dist/**\"\n  ],\n  \"exports\": {\n    \".\": {\n      \"types\": \"./dist/index.d.ts\",\n      \"import\": \"./dist/index.mjs\",\n      \"require\": \"./dist/index.js\"\n    },\n    \"./next\": {\n      \"types\": \"./dist/next.d.ts\",\n      \"import\": \"./dist/next.mjs\",\n      \"require\": \"./dist/next.js\"\n    },\n    \"./next/loader\": {\n      \"types\": \"./dist/next/loader.d.ts\",\n      \"import\": \"./dist/next/loader.mjs\",\n      \"require\": \"./dist/next/loader.js\"\n    },\n    \"./client\": {\n      \"types\": \"./dist/client.d.ts\",\n      \"import\": \"./dist/client.mjs\",\n      \"require\": \"./dist/client.js\"\n    }\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"dev\": \"tsup --watch\",\n    \"clean\": \"rm -rf .turbo && rm -rf node_modules && rm -rf dist\",\n    \"release\": \"pnpm build && npm publish\",\n    \"typecheck\": \"tsc --noEmit\",\n    \"test\": \"vitest run\",\n    \"test:watch\": \"vitest\"\n  },\n  \"dependencies\": {\n    \"@hono/node-server\": \"^1.19.9\",\n    \"@swc/core\": \"^1.10.0\",\n    \"@vercel/oidc\": \"^3.1.0\",\n    \"better-all\": \"^0.0.5\",\n    \"errore\": \"^0.8.2\",\n    \"fast-deep-equal\": \"^3.1.3\",\n    \"glob\": \"^11.0.0\",\n    \"hono\": \"^4.11.6\",\n    \"@vercel/sandbox\": \"^1.5.0\",\n    \"ulid\": \"^3.0.2\",\n    \"zod\": \"^4.3.6\"\n  },\n  \"devDependencies\": {\n    \"@agent/tsconfig\": \"workspace:*\",\n    \"@types/node\": \"^20.11.24\",\n    \"dotenv\": \"^17.2.3\",\n    \"next\": \"^16.0.0\",\n    \"tsup\": \"^8.0.2\",\n    \"type-fest\": \"^5.4.2\",\n    \"typescript\": \"5.5.4\",\n    \"vitest\": \"^3.0.0\"\n  },\n  \"peerDependencies\": {\n    \"ai\": \"^6.0.0\",\n    \"workflow\": \"*\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": "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",
  "names": ["exports"]
}


package/dist/next/loader.mjs

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunk-E7TOPGHY.mjs";
+} from "../chunk-RXPVLORL.mjs";
 import "../chunk-BJTO5JO5.mjs";
 
 // src/next/loader.ts