experimental-agent 0.0.4 → 0.1.1

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

@@ -0,0 +1,290 @@
+import "./chunk-BJTO5JO5.mjs";
+
+// src/storage/bindings/local-fs-handlers.ts
+import { mkdir, readdir, readFile, 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");
+  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 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) => {
+      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.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 }) => {
+      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) => {
+      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.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 }) => {
+      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 allSandboxes = await readAllFromDir(sandboxDir);
+      const matching = allSandboxes.filter(
+        (s) => s.id.startsWith(`${sessionId}-`)
+      );
+      if (matching.length === 0) {
+        return null;
+      }
+      matching.sort(
+        (a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0)
+      );
+      return matching[0];
+    },
+    "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) => {
+      const safeName = Buffer.from(snapshot.key).toString("base64url");
+      await writeJsonFile(join(setupDir, `${safeName}.json`), snapshot);
+    },
+    "setup.acquireLock": async ({ key, lockId, lockTimeoutMs }) => {
+      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 }) => {
+      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 { mkdir, readdir, readFile, unlink, writeFile } from \"node:fs/promises\";\nimport { dirname, join, resolve } from \"node:path\";\nimport equal from \"fast-deep-equal\";\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\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 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      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    \"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      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    \"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      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    \"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      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    \"sandbox.getBySession\": async ({ sessionId }) => {\n      const allSandboxes = await readAllFromDir<SandboxRecord>(sandboxDir);\n      const matching = allSandboxes.filter((s) =>\n        s.id.startsWith(`${sessionId}-`)\n      );\n      if (matching.length === 0) {\n        return null;\n      }\n      matching.sort(\n        (a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0)\n      );\n      return matching[0];\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      const safeName = Buffer.from(snapshot.key).toString(\"base64url\");\n      await writeJsonFile(join(setupDir, `${safeName}.json`), snapshot);\n    },\n\n    \"setup.acquireLock\": async ({ key, lockId, lockTimeoutMs }) => {\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; // active lock held by someone else\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    \"sandbox.acquireLock\": async ({ record, lockTimeoutMs }) => {\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; // active lock held by someone else\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    \"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.0.4",
+  version: "0.1.1",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
   types: "./dist/index.d.ts",
@@ -88,7 +88,7 @@ var package_default = {
     "fast-deep-equal": "^3.1.3",
     glob: "^11.0.0",
     hono: "^4.11.6",
-    sandbox: "^1.0.18",
+    "@vercel/sandbox": "^1.5.0",
     ulid: "^3.0.2",
     zod: "^4.3.6"
   },
@@ -104,7 +104,7 @@ var package_default = {
   },
   peerDependencies: {
     ai: "^6.0.0",
-    workflow: "https://workflow-docs-7evupb64d.vercel.sh/workflow.tgz"
+    workflow: "https://workflow-docs-ad7o5pmal.vercel.sh/workflow.tgz"
   },
   publishConfig: {
     access: "public"
@@ -188,19 +188,19 @@ function findAgentExports(ast) {
   if (!agentLocalName) {
     return [];
   }
-  const exports = [];
+  const exports2 = [];
   for (const item of ast.body) {
     if (item.type === "ExportDeclaration" && item.declaration) {
       const decl = item.declaration;
       if (decl.type === "VariableDeclaration") {
         for (const declarator of decl.declarations) {
           if (declarator.id.type === "Identifier" && declarator.init?.type === "CallExpression" && declarator.init.callee.type === "Identifier" && declarator.init.callee.value === agentLocalName) {
-            exports.push(declarator.id.value);
+            exports2.push(declarator.id.value);
           }
         }
       }
     }
   }
-  return exports;
+  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.0.4\",\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    \"sandbox\": \"^1.0.18\",\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-7evupb64d.vercel.sh/workflow.tgz\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,WAAsB;AACtB,kBAAuC;;;ACDvC;AAAA,EACE,MAAQ;AAAA,EACR,SAAW;AAAA,EACX,MAAQ;AAAA,EACR,QAAU;AAAA,EACV,OAAS;AAAA,EACT,aAAe;AAAA,EACf,SAAW;AAAA,EACX,OAAS;AAAA,IACP;AAAA,EACF;AAAA,EACA,SAAW;AAAA,IACT,KAAK;AAAA,MACH,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,UAAU;AAAA,MACR,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,iBAAiB;AAAA,MACf,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,YAAY;AAAA,MACV,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,EACF;AAAA,EACA,SAAW;AAAA,IACT,OAAS;AAAA,IACT,KAAO;AAAA,IACP,OAAS;AAAA,IACT,SAAW;AAAA,IACX,WAAa;AAAA,IACb,MAAQ;AAAA,IACR,cAAc;AAAA,EAChB;AAAA,EACA,cAAgB;AAAA,IACd,qBAAqB;AAAA,IACrB,aAAa;AAAA,IACb,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,QAAU;AAAA,IACV,mBAAmB;AAAA,IACnB,MAAQ;AAAA,IACR,MAAQ;AAAA,IACR,SAAW;AAAA,IACX,MAAQ;AAAA,IACR,KAAO;AAAA,EACT;AAAA,EACA,iBAAmB;AAAA,IACjB,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,QAAU;AAAA,IACV,MAAQ;AAAA,IACR,MAAQ;AAAA,IACR,aAAa;AAAA,IACb,YAAc;AAAA,IACd,QAAU;AAAA,EACZ;AAAA,EACA,kBAAoB;AAAA,IAClB,IAAM;AAAA,IACN,UAAY;AAAA,EACd;AAAA,EACA,eAAiB;AAAA,IACf,QAAU;AAAA,EACZ;AACF;;;AD3DA,IAAM,eAAe,gBAAI;AACzB,IAAM,yBAAyB;AAC/B,IAAM,uBAAuB;AAMd,SAAR,eAEL,QACQ;AACR,QAAM,EAAE,MAAM,IAAI,KAAK,WAAW;AAClC,QAAM,MAAM,QACR,IAAI,SAAoB,QAAQ,IAAI,kBAAkB,GAAG,IAAI,IAC7D,MAAM;AAEV,MAAI,eAAe,KAAK,YAAY;AAEpC,MAAI,CAAC,OAAO,SAAS,YAAY,GAAG;AAClC,QAAI,4BAA4B;AAChC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,KAAK;AACtB,QAAM,eAAe,qBAAqB,KAAK,QAAQ;AAEvD,MAAI;AACJ,MAAI;AACF,cAAM,uBAAU,QAAQ;AAAA,MACtB,QAAQ,eAAe,eAAe;AAAA,MACtC,KAAK,SAAS,SAAS,MAAM;AAAA,MAC7B,KAAK,SAAS,SAAS,MAAM;AAAA,IAC/B,CAAC;AAAA,EACH,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,QAAM,eAAe,iBAAiB,GAAG;AACzC,MAAI,aAAa,WAAW,GAAG;AAC7B,QAAI,6BAA6B;AACjC,WAAO;AAAA,EACT;AAEA,MAAI,wBAAwB,YAAY;AAGxC,QAAM,UAAe,aAAQ,QAAQ;AACrC,QAAM,WAAW,SAAS,YAAY,GAAQ,QAAG,MAAW,QAAG,EAAE;AACjE,MAAI,aAAa,IAAI;AACnB,QAAI,6BAA6B;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,SAAS,UAAU,GAAG,WAAW,CAAC;AACjD,QAAM,SAAc,UAAK,QAAQ,KAAK;AACtC,QAAM,YAAiB;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,MAAI,eAAoB,cAAS,SAAS,SAAS,EAAE,QAAQ,OAAO,GAAG;AAEvE,MAAI,EAAE,aAAa,WAAW,IAAI,KAAK,aAAa,WAAW,KAAK,IAAI;AACtE,mBAAe,KAAK,YAAY;AAAA,EAClC;AAIA,QAAM,YAAY,aACf,IAAI,CAAC,SAAS;AACb,UAAM,WAAW,SAAS,KAAK,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC;AAC/D,WAAO,GAAG,QAAQ,IAAI,IAAI;AAAA,EAC5B,CAAC,EACA,KAAK,IAAI;AAEZ,QAAM,cAAc,aACjB,IAAI,CAAC,SAAS,SAAS,KAAK,CAAC,EAAE,YAAY,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC,EAAE,EAC9D,KAAK,IAAI;AAEZ,MAAI,6BAA6B,YAAY;AAC7C,SAAO,GAAG,MAAM;AAAA,WACP,WAAW,YAAY,YAAY;AAAA,EAC5C,SAAS;AACX;AAEA,SAAS,iBAAiB,KAAuB;AAC/C,MAAI,iBAAgC;AAEpC,aAAW,QAAQ,IAAI,MAAM;AAC3B,QACE,KAAK,SAAS,uBACd,KAAK,OAAO,UAAU,cACtB;AACA,iBAAW,aAAa,KAAK,YAAY;AACvC,YAAI,UAAU,SAAS,mBAAmB;AACxC,gBAAM,WACJ,UAAU,UAAU,SAAS,eACzB,UAAU,SAAS,QACnB,UAAU,MAAM;AAEtB,cAAI,aAAa,SAAS;AACxB,6BAAiB,UAAU,MAAM;AACjC;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,MAAI,CAAC,gBAAgB;AACnB,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,UAAoB,CAAC;AAE3B,aAAW,QAAQ,IAAI,MAAM;AAC3B,QAAI,KAAK,SAAS,uBAAuB,KAAK,aAAa;AACzD,YAAM,OAAO,KAAK;AAClB,UAAI,KAAK,SAAS,uBAAuB;AACvC,mBAAW,cAAc,KAAK,cAAc;AAC1C,cACE,WAAW,GAAG,SAAS,gBACvB,WAAW,MAAM,SAAS,oBAC1B,WAAW,KAAK,OAAO,SAAS,gBAChC,WAAW,KAAK,OAAO,UAAU,gBACjC;AACA,oBAAQ,KAAK,WAAW,GAAG,KAAK;AAAA,UAClC;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}

+//# 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.1\",\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-ad7o5pmal.vercel.sh/workflow.tgz\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": "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",
  "names": ["exports"]
}


package/dist/next/loader.mjs

@@ -1,10 +1,10 @@
 import {
   package_default
-} from "../chunk-T7PMZLOX.mjs";
-import "../chunk-3ODWQVIA.mjs";
+} from "../chunk-T2UUL6VC.mjs";
+import "../chunk-BJTO5JO5.mjs";
 
 // src/next/loader.ts
-import * as path from "node:path";
+import * as path from "path";
 import { parseSync } from "@swc/core";
 var PACKAGE_NAME = package_default.name;
 var AGENT_PROTOCOL_VERSION = "v1";

package/dist/next.js

@@ -40,7 +40,7 @@ var path = __toESM(require("path"));
 // package.json
 var package_default = {
   name: "experimental-agent",
-  version: "0.0.4",
+  version: "0.1.1",
   main: "./dist/index.js",
   module: "./dist/index.mjs",
   types: "./dist/index.d.ts",
@@ -89,7 +89,7 @@ var package_default = {
     "fast-deep-equal": "^3.1.3",
     glob: "^11.0.0",
     hono: "^4.11.6",
-    sandbox: "^1.0.18",
+    "@vercel/sandbox": "^1.5.0",
     ulid: "^3.0.2",
     zod: "^4.3.6"
   },
@@ -105,7 +105,7 @@ var package_default = {
   },
   peerDependencies: {
     ai: "^6.0.0",
-    workflow: "https://workflow-docs-7evupb64d.vercel.sh/workflow.tgz"
+    workflow: "https://workflow-docs-ad7o5pmal.vercel.sh/workflow.tgz"
   },
   publishConfig: {
     access: "public"
@@ -222,9 +222,11 @@ export function __init${a.exportName[0].toUpperCase()}${a.exportName.slice(
       1
     )}(agent) {
   agent.rpc = ${a.uniqueId}Rpc;
+  registerRpc(agent._agentName, ${a.uniqueId}Rpc);
 }`
   ).join("\n");
   const stepsContent = `// Auto-generated by withAgent - do not edit
+import { registerRpc } from "experimental-agent";
 ${rpcFunctions}
 ${initFunctions}
 `;
@@ -248,6 +250,9 @@ export function GET() {
 }
 function withAgent(configOrFn, agentConfig) {
   const debug = agentConfig?.debug ?? false;
+  if (debug) {
+    process.env.AGENT_DEBUG = "1";
+  }
   const cwd = process.cwd();
   const appDir = getAppDir(cwd);
   const agentDir = `${appDir}/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;
@@ -326,4 +331,4 @@ function withAgent(configOrFn, agentConfig) {
 0 && (module.exports = {
   withAgent
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/next/index.ts", "../package.json"],
  "sourcesContent": ["import * as crypto from \"node:crypto\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { NextConfig } from \"next\";\nimport pkg from \"../../package.json\";\n\nexport type WithAgentConfig = {\n  /** Enable debug logging */\n  debug?: boolean;\n};\n\nconst PACKAGE_NAME = pkg.name;\nconst AGENT_PROTOCOL_VERSION = \"v1\";\nconst FILE_EXT_REGEX = /\\.(ts|tsx|js|jsx)$/;\nconst AGENT_EXPORT_REGEX = /export\\s+const\\s+(\\w+)\\s*=\\s*agent\\s*\\(/g;\nconst DEFAULT_WORKFLOW_DIRS = [\"pages\", \"app\", \"src/pages\", \"src/app\"];\n\ntype DetectedAgent = {\n  exportName: string;\n  filePath: string;\n  /** Unique identifier: exportName or exportName_hash if duplicates exist */\n  uniqueId: string;\n};\n\nfunction shortHash(str: string): string {\n  let hash = 0;\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i);\n    // biome-ignore lint/suspicious/noBitwiseOperators: intentional hash computation\n    hash = (hash << 5) - hash + char;\n    // biome-ignore lint/suspicious/noBitwiseOperators: convert to 32-bit integer\n    hash &= hash;\n  }\n  return Math.abs(hash).toString(36).slice(0, 6);\n}\n\n/**\n * Detects whether the project uses src/app or app directory structure.\n * Returns the app directory path relative to cwd.\n */\nfunction getAppDir(cwd: string): string {\n  const srcAppDir = path.join(cwd, \"src\", \"app\");\n  if (fs.existsSync(srcAppDir)) {\n    return \"src/app\";\n  }\n  return \"app\";\n}\n\n/**\n * Scans for agent exports in the project.\n */\nfunction detectAgents(cwd: string, debug: boolean): DetectedAgent[] {\n  const agents: DetectedAgent[] = [];\n\n  const dirsToScan = [path.join(cwd, \"src\"), cwd];\n\n  function scanDir(dir: string) {\n    if (!fs.existsSync(dir)) {\n      return;\n    }\n\n    const entries = fs.readdirSync(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      if (\n        entry.isDirectory() &&\n        !entry.name.startsWith(\".\") &&\n        entry.name !== \"node_modules\" &&\n        entry.name !== \"src\"\n      ) {\n        scanDir(fullPath);\n      } else if (entry.isFile() && FILE_EXT_REGEX.test(entry.name)) {\n        try {\n          const content = fs.readFileSync(fullPath, \"utf-8\");\n          if (content.includes(PACKAGE_NAME) && content.includes(\"agent(\")) {\n            const exportMatches = content.matchAll(AGENT_EXPORT_REGEX);\n            for (const match of exportMatches) {\n              agents.push({\n                exportName: match[1],\n                filePath: fullPath,\n                uniqueId: \"\", // Will be set after all agents are found\n              });\n              if (debug) {\n                console.log(\n                  `[withAgent] Found agent: ${match[1]} in ${fullPath}`\n                );\n              }\n            }\n          }\n        } catch {\n          // Ignore read errors\n        }\n      }\n    }\n  }\n\n  for (const dir of dirsToScan) {\n    scanDir(dir);\n  }\n\n  // Assign unique IDs - add hash suffix if duplicate export names exist\n  const nameCounts = new Map<string, number>();\n  for (const agent of agents) {\n    nameCounts.set(\n      agent.exportName,\n      (nameCounts.get(agent.exportName) || 0) + 1\n    );\n  }\n\n  for (const agent of agents) {\n    const count = nameCounts.get(agent.exportName) ?? 0;\n    if (count > 1) {\n      agent.uniqueId = `${agent.exportName}_${shortHash(agent.filePath)}`;\n    } else {\n      agent.uniqueId = agent.exportName;\n    }\n  }\n\n  return agents;\n}\n\n/**\n * Generates all agent files in .well-known/agent/v1/:\n * - steps.js: RPC step functions with \"use step\"\n * - route.js: triggers workflow discovery\n */\nfunction generateAgentFiles(\n  agents: DetectedAgent[],\n  outputDir: string,\n  _cwd: string,\n  debug: boolean\n): void {\n  if (agents.length === 0) {\n    if (debug) {\n      console.log(\"[withAgent] No agents found, skipping generation\");\n    }\n    return;\n  }\n\n  if (!fs.existsSync(outputDir)) {\n    fs.mkdirSync(outputDir, { recursive: true });\n  }\n\n  /**\n   * Generate step functions that use dynamic import.\n   * Dynamic import ensures the agent module loads (including loader-injected init)\n   * when the step runs in workflow context, avoiding the \"not initialized\" error.\n   *\n   * Uses uniqueId for function names to handle duplicate export names across files.\n   */\n  const rpcFunctions = agents\n    .map((a) => {\n      // Calculate relative path from steps.js to the agent file\n      let agentRelPath = path\n        .relative(outputDir, a.filePath)\n        .replace(/\\\\/g, \"/\");\n\n      if (!agentRelPath.startsWith(\".\")) {\n        agentRelPath = `./${agentRelPath}`;\n      }\n\n      return `\nexport const ${a.uniqueId}Rpc = async (params) => {\n  \"use step\";\n  const { ${a.exportName} } = await import(\"${agentRelPath}\");\n  const res = await ${a.exportName}.handler(params);\n  if (res instanceof Response) {\n    return res.json();\n  }\n  return res;\n};`;\n    })\n    .join(\"\\n\");\n\n  /**\n   * Init functions wire up agent.rpc in the main app context.\n   * Uses exportName for the function name (loader matches by export name),\n   * but references uniqueId for the Rpc function.\n   */\n  const initFunctions = agents\n    .map(\n      (a) => `\nexport function __init${a.exportName[0].toUpperCase()}${a.exportName.slice(\n        1\n      )}(agent) {\n  agent.rpc = ${a.uniqueId}Rpc;\n}`\n    )\n    .join(\"\\n\");\n\n  const stepsContent = `// Auto-generated by withAgent - do not edit\n${rpcFunctions}\n${initFunctions}\n`;\n\n  const stepsPath = path.join(outputDir, \"steps.js\");\n  fs.writeFileSync(stepsPath, stepsContent);\n\n  /**\n   * Generate route.js that imports steps.js.\n   * This ensures workflow discovers the \"use step\" functions.\n   * No actual handler needed - storage RPC uses the step function directly.\n   */\n  const routeContent = `// Auto-generated by withAgent - triggers workflow discovery\nimport \"./steps.js\";\nexport function GET() {\n  return new Response(\"ok\");\n}\n`;\n\n  const routePath = path.join(outputDir, \"route.js\");\n  fs.writeFileSync(routePath, routeContent);\n\n  // Add .gitignore\n  const gitignorePath = path.join(outputDir, \".gitignore\");\n  if (!fs.existsSync(gitignorePath)) {\n    fs.writeFileSync(gitignorePath, \"*\\n\");\n  }\n\n  if (debug) {\n    console.log(`[withAgent] Generated agent files at ${outputDir}`);\n  }\n}\n\ntype TurbopackRule = {\n  loaders?: string[];\n  condition?: {\n    all?: unknown[];\n    any?: unknown[];\n    path?: RegExp;\n    content?: RegExp;\n    not?: unknown;\n  };\n};\n\ntype WorkflowConfigFn = (\n  phase: string,\n  ctx: { defaultConfig: NextConfig }\n) => Promise<NextConfig>;\n\ntype NextConfigInput =\n  | NextConfig\n  | ((\n      phase: string,\n      ctx: { defaultConfig: NextConfig }\n    ) => Promise<NextConfig>);\n\n/**\n * Next.js plugin that configures agent support.\n *\n * - Detects agents and generates RPC steps with \"use step\" in .well-known/agent/v1/\n * - Generates AGENT_SECRET for secure RPC calls\n * - Wraps withWorkflow for workflow support\n *\n * @example\n * ```ts\n * // next.config.ts\n * import { withAgent } from \"experimental-agent/next\";\n *\n * // Option 1: withAgent handles everything (recommended)\n * export default withAgent({});\n *\n * // Option 2: Compose with other plugins\n * export default withAgent(withSomeOtherPlugin({}));\n * ```\n */\nexport function withAgent(\n  configOrFn: NextConfigInput,\n  agentConfig?: WithAgentConfig\n): WorkflowConfigFn {\n  const debug = agentConfig?.debug ?? false;\n  const cwd = process.cwd();\n\n  // Detect app directory structure (src/app vs app)\n  const appDir = getAppDir(cwd);\n  const agentDir = `${appDir}/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;\n\n  // Detect agents and generate files FIRST (before workflow discovers them)\n  const agents = detectAgents(cwd, debug);\n  const outputDir = path.join(cwd, agentDir);\n  generateAgentFiles(agents, outputDir, cwd, debug);\n\n  const agentFilePaths = agents.map((a) => a.filePath);\n  const loaderPath = require.resolve(\"./next/loader\");\n\n  if (debug) {\n    console.log(\"[withAgent] loader path:\", loaderPath);\n    console.log(\"[withAgent] agent files:\", agentFilePaths);\n    console.log(\"[withAgent] agent dir:\", agentDir);\n  }\n\n  // Build regex to match agent file paths\n  const agentPathRegex =\n    agentFilePaths.length > 0\n      ? new RegExp(\n          `${agentFilePaths\n            .map((p) =>\n              path\n                .relative(cwd, p)\n                .replace(/\\\\/g, \"/\")\n                .replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n            )\n            .join(\"|\")}$`\n        )\n      : null;\n\n  /**\n   * Always pass through withWorkflow - it handles both NextConfig and async functions.\n   * This ensures workflow is always configured, regardless of what the user passed.\n   */\n  let withWorkflow: (\n    config: NextConfigInput,\n    options?: { workflows?: { dirs?: string[] } }\n  ) => WorkflowConfigFn;\n  try {\n    withWorkflow = require(\"workflow/next\").withWorkflow;\n  } catch {\n    console.warn(\n      \"[withAgent] workflow/next not found. Make sure workflow is installed.\"\n    );\n    return typeof configOrFn === \"function\"\n      ? configOrFn\n      : async () => configOrFn;\n  }\n\n  const baseConfigFn = withWorkflow(configOrFn, {\n    workflows: {\n      dirs: [...DEFAULT_WORKFLOW_DIRS, agentDir],\n    },\n  });\n\n  /**\n   * Return a wrapper that runs AFTER workflow processes, then adds our loader.\n   * This is necessary because workflow overwrites turbopack rules - we need to\n   * modify them after workflow is done.\n   */\n  return async (phase, ctx) => {\n    const nextConfig = await baseConfigFn(phase, ctx);\n\n    // Set up AGENT_SECRET if not already set\n    if (!process.env.AGENT_SECRET) {\n      nextConfig.env = {\n        ...nextConfig.env,\n        AGENT_SECRET: crypto.randomUUID(),\n      };\n      if (debug) {\n        console.log(\"[withAgent] Generated AGENT_SECRET\");\n      }\n    }\n\n    if (!agentPathRegex || agentFilePaths.length === 0) {\n      return nextConfig;\n    }\n\n    // Modify turbopack rules to include our loader for agent files\n    const rules = (nextConfig.turbopack?.rules || {}) as Record<\n      string,\n      TurbopackRule\n    >;\n\n    for (const key of [\"*.ts\", \"*.tsx\", \"*.js\", \"*.jsx\"]) {\n      const existingRule = rules[key];\n      if (!existingRule) {\n        continue;\n      }\n\n      /**\n       * Workflow's rule has: condition.all = [{ not: path }, { content: /use step|.../ }]\n       * We want: run loader if workflow's conditions match OR it's an agent file.\n       * So we wrap in: condition.any = [existingCondition, { path: agentPathRegex }]\n       */\n      rules[key] = {\n        ...existingRule,\n        loaders: [loaderPath, ...(existingRule.loaders || [])],\n        condition: {\n          any: [existingRule.condition, { path: agentPathRegex }],\n        },\n      };\n    }\n\n    // Also configure webpack for non-turbopack builds\n    const existingWebpack = nextConfig.webpack;\n    nextConfig.webpack = (webpackConfig, context) => {\n      webpackConfig.module.rules.push({\n        test: (resourcePath: string) => agentFilePaths.includes(resourcePath),\n        use: [{ loader: loaderPath }],\n      });\n      return existingWebpack?.(webpackConfig, context) ?? webpackConfig;\n    };\n\n    if (debug) {\n      console.log(\"[withAgent] Added agent loader to turbopack rules\");\n    }\n\n    return nextConfig;\n  };\n}\n", "{\n  \"name\": \"experimental-agent\",\n  \"version\": \"0.0.4\",\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    \"sandbox\": \"^1.0.18\",\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-7evupb64d.vercel.sh/workflow.tgz\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,aAAwB;AACxB,SAAoB;AACpB,WAAsB;;;ACFtB;AAAA,EACE,MAAQ;AAAA,EACR,SAAW;AAAA,EACX,MAAQ;AAAA,EACR,QAAU;AAAA,EACV,OAAS;AAAA,EACT,aAAe;AAAA,EACf,SAAW;AAAA,EACX,OAAS;AAAA,IACP;AAAA,EACF;AAAA,EACA,SAAW;AAAA,IACT,KAAK;AAAA,MACH,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,UAAU;AAAA,MACR,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,iBAAiB;AAAA,MACf,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,IACA,YAAY;AAAA,MACV,OAAS;AAAA,MACT,QAAU;AAAA,MACV,SAAW;AAAA,IACb;AAAA,EACF;AAAA,EACA,SAAW;AAAA,IACT,OAAS;AAAA,IACT,KAAO;AAAA,IACP,OAAS;AAAA,IACT,SAAW;AAAA,IACX,WAAa;AAAA,IACb,MAAQ;AAAA,IACR,cAAc;AAAA,EAChB;AAAA,EACA,cAAgB;AAAA,IACd,qBAAqB;AAAA,IACrB,aAAa;AAAA,IACb,gBAAgB;AAAA,IAChB,cAAc;AAAA,IACd,QAAU;AAAA,IACV,mBAAmB;AAAA,IACnB,MAAQ;AAAA,IACR,MAAQ;AAAA,IACR,SAAW;AAAA,IACX,MAAQ;AAAA,IACR,KAAO;AAAA,EACT;AAAA,EACA,iBAAmB;AAAA,IACjB,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,QAAU;AAAA,IACV,MAAQ;AAAA,IACR,MAAQ;AAAA,IACR,aAAa;AAAA,IACb,YAAc;AAAA,IACd,QAAU;AAAA,EACZ;AAAA,EACA,kBAAoB;AAAA,IAClB,IAAM;AAAA,IACN,UAAY;AAAA,EACd;AAAA,EACA,eAAiB;AAAA,IACf,QAAU;AAAA,EACZ;AACF;;;AD7DA,IAAM,eAAe,gBAAI;AACzB,IAAM,yBAAyB;AAC/B,IAAM,iBAAiB;AACvB,IAAM,qBAAqB;AAC3B,IAAM,wBAAwB,CAAC,SAAS,OAAO,aAAa,SAAS;AASrE,SAAS,UAAU,KAAqB;AACtC,MAAI,OAAO;AACX,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,UAAM,OAAO,IAAI,WAAW,CAAC;AAE7B,YAAQ,QAAQ,KAAK,OAAO;AAE5B,YAAQ;AAAA,EACV;AACA,SAAO,KAAK,IAAI,IAAI,EAAE,SAAS,EAAE,EAAE,MAAM,GAAG,CAAC;AAC/C;AAMA,SAAS,UAAU,KAAqB;AACtC,QAAM,YAAiB,UAAK,KAAK,OAAO,KAAK;AAC7C,MAAO,cAAW,SAAS,GAAG;AAC5B,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAKA,SAAS,aAAa,KAAa,OAAiC;AAClE,QAAM,SAA0B,CAAC;AAEjC,QAAM,aAAa,CAAM,UAAK,KAAK,KAAK,GAAG,GAAG;AAE9C,WAAS,QAAQ,KAAa;AAC5B,QAAI,CAAI,cAAW,GAAG,GAAG;AACvB;AAAA,IACF;AAEA,UAAM,UAAa,eAAY,KAAK,EAAE,eAAe,KAAK,CAAC;AAC3D,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAgB,UAAK,KAAK,MAAM,IAAI;AAC1C,UACE,MAAM,YAAY,KAClB,CAAC,MAAM,KAAK,WAAW,GAAG,KAC1B,MAAM,SAAS,kBACf,MAAM,SAAS,OACf;AACA,gBAAQ,QAAQ;AAAA,MAClB,WAAW,MAAM,OAAO,KAAK,eAAe,KAAK,MAAM,IAAI,GAAG;AAC5D,YAAI;AACF,gBAAM,UAAa,gBAAa,UAAU,OAAO;AACjD,cAAI,QAAQ,SAAS,YAAY,KAAK,QAAQ,SAAS,QAAQ,GAAG;AAChE,kBAAM,gBAAgB,QAAQ,SAAS,kBAAkB;AACzD,uBAAW,SAAS,eAAe;AACjC,qBAAO,KAAK;AAAA,gBACV,YAAY,MAAM,CAAC;AAAA,gBACnB,UAAU;AAAA,gBACV,UAAU;AAAA;AAAA,cACZ,CAAC;AACD,kBAAI,OAAO;AACT,wBAAQ;AAAA,kBACN,4BAA4B,MAAM,CAAC,CAAC,OAAO,QAAQ;AAAA,gBACrD;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEA,aAAW,OAAO,YAAY;AAC5B,YAAQ,GAAG;AAAA,EACb;AAGA,QAAM,aAAa,oBAAI,IAAoB;AAC3C,aAAW,SAAS,QAAQ;AAC1B,eAAW;AAAA,MACT,MAAM;AAAA,OACL,WAAW,IAAI,MAAM,UAAU,KAAK,KAAK;AAAA,IAC5C;AAAA,EACF;AAEA,aAAW,SAAS,QAAQ;AAC1B,UAAM,QAAQ,WAAW,IAAI,MAAM,UAAU,KAAK;AAClD,QAAI,QAAQ,GAAG;AACb,YAAM,WAAW,GAAG,MAAM,UAAU,IAAI,UAAU,MAAM,QAAQ,CAAC;AAAA,IACnE,OAAO;AACL,YAAM,WAAW,MAAM;AAAA,IACzB;AAAA,EACF;AAEA,SAAO;AACT;AAOA,SAAS,mBACP,QACA,WACA,MACA,OACM;AACN,MAAI,OAAO,WAAW,GAAG;AACvB,QAAI,OAAO;AACT,cAAQ,IAAI,kDAAkD;AAAA,IAChE;AACA;AAAA,EACF;AAEA,MAAI,CAAI,cAAW,SAAS,GAAG;AAC7B,IAAG,aAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AAAA,EAC7C;AASA,QAAM,eAAe,OAClB,IAAI,CAAC,MAAM;AAEV,QAAI,eACD,cAAS,WAAW,EAAE,QAAQ,EAC9B,QAAQ,OAAO,GAAG;AAErB,QAAI,CAAC,aAAa,WAAW,GAAG,GAAG;AACjC,qBAAe,KAAK,YAAY;AAAA,IAClC;AAEA,WAAO;AAAA,eACE,EAAE,QAAQ;AAAA;AAAA,YAEb,EAAE,UAAU,sBAAsB,YAAY;AAAA,sBACpC,EAAE,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAM9B,CAAC,EACA,KAAK,IAAI;AAOZ,QAAM,gBAAgB,OACnB;AAAA,IACC,CAAC,MAAM;AAAA,wBACW,EAAE,WAAW,CAAC,EAAE,YAAY,CAAC,GAAG,EAAE,WAAW;AAAA,MAC7D;AAAA,IACF,CAAC;AAAA,gBACS,EAAE,QAAQ;AAAA;AAAA,EAEtB,EACC,KAAK,IAAI;AAEZ,QAAM,eAAe;AAAA,EACrB,YAAY;AAAA,EACZ,aAAa;AAAA;AAGb,QAAM,YAAiB,UAAK,WAAW,UAAU;AACjD,EAAG,iBAAc,WAAW,YAAY;AAOxC,QAAM,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAOrB,QAAM,YAAiB,UAAK,WAAW,UAAU;AACjD,EAAG,iBAAc,WAAW,YAAY;AAGxC,QAAM,gBAAqB,UAAK,WAAW,YAAY;AACvD,MAAI,CAAI,cAAW,aAAa,GAAG;AACjC,IAAG,iBAAc,eAAe,KAAK;AAAA,EACvC;AAEA,MAAI,OAAO;AACT,YAAQ,IAAI,wCAAwC,SAAS,EAAE;AAAA,EACjE;AACF;AA4CO,SAAS,UACd,YACA,aACkB;AAClB,QAAM,QAAQ,aAAa,SAAS;AACpC,QAAM,MAAM,QAAQ,IAAI;AAGxB,QAAM,SAAS,UAAU,GAAG;AAC5B,QAAM,WAAW,GAAG,MAAM,sBAAsB,sBAAsB;AAGtE,QAAM,SAAS,aAAa,KAAK,KAAK;AACtC,QAAM,YAAiB,UAAK,KAAK,QAAQ;AACzC,qBAAmB,QAAQ,WAAW,KAAK,KAAK;AAEhD,QAAM,iBAAiB,OAAO,IAAI,CAAC,MAAM,EAAE,QAAQ;AACnD,QAAM,aAAa,gBAAgB,eAAe;AAElD,MAAI,OAAO;AACT,YAAQ,IAAI,4BAA4B,UAAU;AAClD,YAAQ,IAAI,4BAA4B,cAAc;AACtD,YAAQ,IAAI,0BAA0B,QAAQ;AAAA,EAChD;AAGA,QAAM,iBACJ,eAAe,SAAS,IACpB,IAAI;AAAA,IACF,GAAG,eACA;AAAA,MAAI,CAAC,MAED,cAAS,KAAK,CAAC,EACf,QAAQ,OAAO,GAAG,EAClB,QAAQ,uBAAuB,MAAM;AAAA,IAC1C,EACC,KAAK,GAAG,CAAC;AAAA,EACd,IACA;AAMN,MAAI;AAIJ,MAAI;AACF,mBAAe,QAAQ,eAAe,EAAE;AAAA,EAC1C,QAAQ;AACN,YAAQ;AAAA,MACN;AAAA,IACF;AACA,WAAO,OAAO,eAAe,aACzB,aACA,YAAY;AAAA,EAClB;AAEA,QAAM,eAAe,aAAa,YAAY;AAAA,IAC5C,WAAW;AAAA,MACT,MAAM,CAAC,GAAG,uBAAuB,QAAQ;AAAA,IAC3C;AAAA,EACF,CAAC;AAOD,SAAO,OAAO,OAAO,QAAQ;AAC3B,UAAM,aAAa,MAAM,aAAa,OAAO,GAAG;AAGhD,QAAI,CAAC,QAAQ,IAAI,cAAc;AAC7B,iBAAW,MAAM;AAAA,QACf,GAAG,WAAW;AAAA,QACd,cAAqB,kBAAW;AAAA,MAClC;AACA,UAAI,OAAO;AACT,gBAAQ,IAAI,oCAAoC;AAAA,MAClD;AAAA,IACF;AAEA,QAAI,CAAC,kBAAkB,eAAe,WAAW,GAAG;AAClD,aAAO;AAAA,IACT;AAGA,UAAM,QAAS,WAAW,WAAW,SAAS,CAAC;AAK/C,eAAW,OAAO,CAAC,QAAQ,SAAS,QAAQ,OAAO,GAAG;AACpD,YAAM,eAAe,MAAM,GAAG;AAC9B,UAAI,CAAC,cAAc;AACjB;AAAA,MACF;AAOA,YAAM,GAAG,IAAI;AAAA,QACX,GAAG;AAAA,QACH,SAAS,CAAC,YAAY,GAAI,aAAa,WAAW,CAAC,CAAE;AAAA,QACrD,WAAW;AAAA,UACT,KAAK,CAAC,aAAa,WAAW,EAAE,MAAM,eAAe,CAAC;AAAA,QACxD;AAAA,MACF;AAAA,IACF;AAGA,UAAM,kBAAkB,WAAW;AACnC,eAAW,UAAU,CAAC,eAAe,YAAY;AAC/C,oBAAc,OAAO,MAAM,KAAK;AAAA,QAC9B,MAAM,CAAC,iBAAyB,eAAe,SAAS,YAAY;AAAA,QACpE,KAAK,CAAC,EAAE,QAAQ,WAAW,CAAC;AAAA,MAC9B,CAAC;AACD,aAAO,kBAAkB,eAAe,OAAO,KAAK;AAAA,IACtD;AAEA,QAAI,OAAO;AACT,cAAQ,IAAI,mDAAmD;AAAA,IACjE;AAEA,WAAO;AAAA,EACT;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/next/index.ts", "../package.json"],
  "sourcesContent": ["import * as crypto from \"node:crypto\";\nimport * as fs from \"node:fs\";\nimport * as path from \"node:path\";\nimport type { NextConfig } from \"next\";\nimport pkg from \"../../package.json\";\n\nexport type WithAgentConfig = {\n  /** Enable debug logging */\n  debug?: boolean;\n};\n\nconst PACKAGE_NAME = pkg.name;\nconst AGENT_PROTOCOL_VERSION = \"v1\";\nconst FILE_EXT_REGEX = /\\.(ts|tsx|js|jsx)$/;\nconst AGENT_EXPORT_REGEX = /export\\s+const\\s+(\\w+)\\s*=\\s*agent\\s*\\(/g;\nconst DEFAULT_WORKFLOW_DIRS = [\"pages\", \"app\", \"src/pages\", \"src/app\"];\n\ntype DetectedAgent = {\n  exportName: string;\n  filePath: string;\n  /** Unique identifier: exportName or exportName_hash if duplicates exist */\n  uniqueId: string;\n};\n\nfunction shortHash(str: string): string {\n  let hash = 0;\n  for (let i = 0; i < str.length; i++) {\n    const char = str.charCodeAt(i);\n    // biome-ignore lint/suspicious/noBitwiseOperators: intentional hash computation\n    hash = (hash << 5) - hash + char;\n    // biome-ignore lint/suspicious/noBitwiseOperators: convert to 32-bit integer\n    hash &= hash;\n  }\n  return Math.abs(hash).toString(36).slice(0, 6);\n}\n\n/**\n * Detects whether the project uses src/app or app directory structure.\n * Returns the app directory path relative to cwd.\n */\nfunction getAppDir(cwd: string): string {\n  const srcAppDir = path.join(cwd, \"src\", \"app\");\n  if (fs.existsSync(srcAppDir)) {\n    return \"src/app\";\n  }\n  return \"app\";\n}\n\n/**\n * Scans for agent exports in the project.\n */\nfunction detectAgents(cwd: string, debug: boolean): DetectedAgent[] {\n  const agents: DetectedAgent[] = [];\n\n  const dirsToScan = [path.join(cwd, \"src\"), cwd];\n\n  function scanDir(dir: string) {\n    if (!fs.existsSync(dir)) {\n      return;\n    }\n\n    const entries = fs.readdirSync(dir, { withFileTypes: true });\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      if (\n        entry.isDirectory() &&\n        !entry.name.startsWith(\".\") &&\n        entry.name !== \"node_modules\" &&\n        entry.name !== \"src\"\n      ) {\n        scanDir(fullPath);\n      } else if (entry.isFile() && FILE_EXT_REGEX.test(entry.name)) {\n        try {\n          const content = fs.readFileSync(fullPath, \"utf-8\");\n          if (content.includes(PACKAGE_NAME) && content.includes(\"agent(\")) {\n            const exportMatches = content.matchAll(AGENT_EXPORT_REGEX);\n            for (const match of exportMatches) {\n              agents.push({\n                exportName: match[1],\n                filePath: fullPath,\n                uniqueId: \"\", // Will be set after all agents are found\n              });\n              if (debug) {\n                console.log(\n                  `[withAgent] Found agent: ${match[1]} in ${fullPath}`\n                );\n              }\n            }\n          }\n        } catch {\n          // Ignore read errors\n        }\n      }\n    }\n  }\n\n  for (const dir of dirsToScan) {\n    scanDir(dir);\n  }\n\n  // Assign unique IDs - add hash suffix if duplicate export names exist\n  const nameCounts = new Map<string, number>();\n  for (const agent of agents) {\n    nameCounts.set(\n      agent.exportName,\n      (nameCounts.get(agent.exportName) || 0) + 1\n    );\n  }\n\n  for (const agent of agents) {\n    const count = nameCounts.get(agent.exportName) ?? 0;\n    if (count > 1) {\n      agent.uniqueId = `${agent.exportName}_${shortHash(agent.filePath)}`;\n    } else {\n      agent.uniqueId = agent.exportName;\n    }\n  }\n\n  return agents;\n}\n\n/**\n * Generates all agent files in .well-known/agent/v1/:\n * - steps.js: RPC step functions with \"use step\"\n * - route.js: triggers workflow discovery\n */\nfunction generateAgentFiles(\n  agents: DetectedAgent[],\n  outputDir: string,\n  _cwd: string,\n  debug: boolean\n): void {\n  if (agents.length === 0) {\n    if (debug) {\n      console.log(\"[withAgent] No agents found, skipping generation\");\n    }\n    return;\n  }\n\n  if (!fs.existsSync(outputDir)) {\n    fs.mkdirSync(outputDir, { recursive: true });\n  }\n\n  /**\n   * Generate step functions that use dynamic import.\n   * Dynamic import ensures the agent module loads (including loader-injected init)\n   * when the step runs in workflow context, avoiding the \"not initialized\" error.\n   *\n   * Uses uniqueId for function names to handle duplicate export names across files.\n   */\n  const rpcFunctions = agents\n    .map((a) => {\n      // Calculate relative path from steps.js to the agent file\n      let agentRelPath = path\n        .relative(outputDir, a.filePath)\n        .replace(/\\\\/g, \"/\");\n\n      if (!agentRelPath.startsWith(\".\")) {\n        agentRelPath = `./${agentRelPath}`;\n      }\n\n      return `\nexport const ${a.uniqueId}Rpc = async (params) => {\n  \"use step\";\n  const { ${a.exportName} } = await import(\"${agentRelPath}\");\n  const res = await ${a.exportName}.handler(params);\n  if (res instanceof Response) {\n    return res.json();\n  }\n  return res;\n};`;\n    })\n    .join(\"\\n\");\n\n  /**\n   * Init functions wire up agent.rpc in the main app context.\n   * Uses exportName for the function name (loader matches by export name),\n   * but references uniqueId for the Rpc function.\n   */\n  const initFunctions = agents\n    .map(\n      (a) => `\nexport function __init${a.exportName[0].toUpperCase()}${a.exportName.slice(\n        1\n      )}(agent) {\n  agent.rpc = ${a.uniqueId}Rpc;\n  registerRpc(agent._agentName, ${a.uniqueId}Rpc);\n}`\n    )\n    .join(\"\\n\");\n\n  const stepsContent = `// Auto-generated by withAgent - do not edit\nimport { registerRpc } from \"experimental-agent\";\n${rpcFunctions}\n${initFunctions}\n`;\n\n  const stepsPath = path.join(outputDir, \"steps.js\");\n  fs.writeFileSync(stepsPath, stepsContent);\n\n  /**\n   * Generate route.js that imports steps.js.\n   * This ensures workflow discovers the \"use step\" functions.\n   * No actual handler needed - storage RPC uses the step function directly.\n   */\n  const routeContent = `// Auto-generated by withAgent - triggers workflow discovery\nimport \"./steps.js\";\nexport function GET() {\n  return new Response(\"ok\");\n}\n`;\n\n  const routePath = path.join(outputDir, \"route.js\");\n  fs.writeFileSync(routePath, routeContent);\n\n  // Add .gitignore\n  const gitignorePath = path.join(outputDir, \".gitignore\");\n  if (!fs.existsSync(gitignorePath)) {\n    fs.writeFileSync(gitignorePath, \"*\\n\");\n  }\n\n  if (debug) {\n    console.log(`[withAgent] Generated agent files at ${outputDir}`);\n  }\n}\n\ntype TurbopackRule = {\n  loaders?: string[];\n  condition?: {\n    all?: unknown[];\n    any?: unknown[];\n    path?: RegExp;\n    content?: RegExp;\n    not?: unknown;\n  };\n};\n\ntype WorkflowConfigFn = (\n  phase: string,\n  ctx: { defaultConfig: NextConfig }\n) => Promise<NextConfig>;\n\ntype NextConfigInput =\n  | NextConfig\n  | ((\n      phase: string,\n      ctx: { defaultConfig: NextConfig }\n    ) => Promise<NextConfig>);\n\n/**\n * Next.js plugin that configures agent support.\n *\n * - Detects agents and generates RPC steps with \"use step\" in .well-known/agent/v1/\n * - Generates AGENT_SECRET for secure RPC calls\n * - Wraps withWorkflow for workflow support\n *\n * @example\n * ```ts\n * // next.config.ts\n * import { withAgent } from \"experimental-agent/next\";\n *\n * // Option 1: withAgent handles everything (recommended)\n * export default withAgent({});\n *\n * // Option 2: Compose with other plugins\n * export default withAgent(withSomeOtherPlugin({}));\n * ```\n */\nexport function withAgent(\n  configOrFn: NextConfigInput,\n  agentConfig?: WithAgentConfig\n): WorkflowConfigFn {\n  const debug = agentConfig?.debug ?? false;\n  if (debug) {\n    process.env.AGENT_DEBUG = \"1\";\n  }\n  const cwd = process.cwd();\n\n  // Detect app directory structure (src/app vs app)\n  const appDir = getAppDir(cwd);\n  const agentDir = `${appDir}/.well-known/agent/${AGENT_PROTOCOL_VERSION}`;\n\n  // Detect agents and generate files FIRST (before workflow discovers them)\n  const agents = detectAgents(cwd, debug);\n  const outputDir = path.join(cwd, agentDir);\n  generateAgentFiles(agents, outputDir, cwd, debug);\n\n  const agentFilePaths = agents.map((a) => a.filePath);\n  const loaderPath = require.resolve(\"./next/loader\");\n\n  if (debug) {\n    console.log(\"[withAgent] loader path:\", loaderPath);\n    console.log(\"[withAgent] agent files:\", agentFilePaths);\n    console.log(\"[withAgent] agent dir:\", agentDir);\n  }\n\n  // Build regex to match agent file paths\n  const agentPathRegex =\n    agentFilePaths.length > 0\n      ? new RegExp(\n          `${agentFilePaths\n            .map((p) =>\n              path\n                .relative(cwd, p)\n                .replace(/\\\\/g, \"/\")\n                .replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\")\n            )\n            .join(\"|\")}$`\n        )\n      : null;\n\n  /**\n   * Always pass through withWorkflow - it handles both NextConfig and async functions.\n   * This ensures workflow is always configured, regardless of what the user passed.\n   */\n  let withWorkflow: (\n    config: NextConfigInput,\n    options?: { workflows?: { dirs?: string[] } }\n  ) => WorkflowConfigFn;\n  try {\n    withWorkflow = require(\"workflow/next\").withWorkflow;\n  } catch {\n    console.warn(\n      \"[withAgent] workflow/next not found. Make sure workflow is installed.\"\n    );\n    return typeof configOrFn === \"function\"\n      ? configOrFn\n      : async () => configOrFn;\n  }\n\n  const baseConfigFn = withWorkflow(configOrFn, {\n    workflows: {\n      dirs: [...DEFAULT_WORKFLOW_DIRS, agentDir],\n    },\n  });\n\n  /**\n   * Return a wrapper that runs AFTER workflow processes, then adds our loader.\n   * This is necessary because workflow overwrites turbopack rules - we need to\n   * modify them after workflow is done.\n   */\n  return async (phase, ctx) => {\n    const nextConfig = await baseConfigFn(phase, ctx);\n\n    // Set up AGENT_SECRET if not already set\n    if (!process.env.AGENT_SECRET) {\n      nextConfig.env = {\n        ...nextConfig.env,\n        AGENT_SECRET: crypto.randomUUID(),\n      };\n      if (debug) {\n        console.log(\"[withAgent] Generated AGENT_SECRET\");\n      }\n    }\n\n    if (!agentPathRegex || agentFilePaths.length === 0) {\n      return nextConfig;\n    }\n\n    // Modify turbopack rules to include our loader for agent files\n    const rules = (nextConfig.turbopack?.rules || {}) as Record<\n      string,\n      TurbopackRule\n    >;\n\n    for (const key of [\"*.ts\", \"*.tsx\", \"*.js\", \"*.jsx\"]) {\n      const existingRule = rules[key];\n      if (!existingRule) {\n        continue;\n      }\n\n      /**\n       * Workflow's rule has: condition.all = [{ not: path }, { content: /use step|.../ }]\n       * We want: run loader if workflow's conditions match OR it's an agent file.\n       * So we wrap in: condition.any = [existingCondition, { path: agentPathRegex }]\n       */\n      rules[key] = {\n        ...existingRule,\n        loaders: [loaderPath, ...(existingRule.loaders || [])],\n        condition: {\n          any: [existingRule.condition, { path: agentPathRegex }],\n        },\n      };\n    }\n\n    // Also configure webpack for non-turbopack builds\n    const existingWebpack = nextConfig.webpack;\n    nextConfig.webpack = (webpackConfig, context) => {\n      webpackConfig.module.rules.push({\n        test: (resourcePath: string) => agentFilePaths.includes(resourcePath),\n        use: [{ loader: loaderPath }],\n      });\n      return existingWebpack?.(webpackConfig, context) ?? webpackConfig;\n    };\n\n    if (debug) {\n      console.log(\"[withAgent] Added agent loader to turbopack rules\");\n    }\n\n    return nextConfig;\n  };\n}\n", "{\n  \"name\": \"experimental-agent\",\n  \"version\": \"0.1.1\",\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-ad7o5pmal.vercel.sh/workflow.tgz\"\n  },\n  \"publishConfig\": {\n    \"access\": \"public\"\n  }\n}\n"],
  "mappings": "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",
  "names": []
}
