experimental-agent 0.0.2 → 0.0.4

package/dist/lifecycle-workflow.mjs

@@ -1,44 +1,8 @@
-// src/sandbox/lifecycle-workflow.ts
-import { defineHook, FatalError, sleep } from "workflow";
-var sandboxActivityHook = defineHook();
-var DEFAULT_IDLE_TIMEOUT_MS = 5 * 60 * 1e3;
-async function sandboxLifecycleWorkflow({
-  input
-}) {
-  "use workflow";
-  const activityHook = sandboxActivityHook.create({ token: input.id });
-  const iterator = activityHook[Symbol.asyncIterator]();
-  let pendingNext = iterator.next();
-  let sandboxConfig = input.initialConfig;
-  if (sandboxConfig.type !== "vercel") {
-    throw new Error("Sandbox config is not a Vercel sandbox");
-  }
-  const idleTimeoutMs = sandboxConfig.lifecycle?.stopAfterInactiveMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-  while (true) {
-    const result = await Promise.race([
-      pendingNext.then((r) => ({ ...r, type: "activity" })),
-      sleep(idleTimeoutMs).then(() => ({ type: "timeout" }))
-    ]);
-    if (result.type === "timeout") {
-      const { snapshotSandboxStep } = await import("./lifecycle-workflow-steps-HHN46ZAD.mjs");
-      await snapshotSandboxStep(input).catch((e) => {
-        if (FatalError.is(e)) {
-          console.error("Snapshot failed permanently:", e.message);
-          return;
-        }
-        throw e;
-      });
-      break;
-    }
-    if (result.done) {
-      break;
-    }
-    sandboxConfig = result.value.newConfig;
-    pendingNext = iterator.next();
-  }
-}
+import {
+  sandboxLifecycleWorkflow
+} from "./chunk-TQRCSTCF.mjs";
+import "./chunk-3ODWQVIA.mjs";
 export {
-  sandboxActivityHook,
   sandboxLifecycleWorkflow
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

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

@@ -0,0 +1,235 @@
+import "./chunk-3ODWQVIA.mjs";
+
+// src/storage/bindings/local-fs-handlers.ts
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+
+// 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");
+  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, 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]) => sessionTags[key] === value
+          );
+        });
+      }
+      filtered.sort((a, b) => a.createdAt - b.createdAt);
+      return paginate({ items: filtered, cursor, limit });
+    },
+    "session.listBySandbox": async ({ sandboxId, tags, 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]) => sessionTags[key] === value
+          );
+        });
+      }
+      filtered.sort((a, b) => a.createdAt - b.createdAt);
+      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]) => 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;
+    },
+    "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 { paginate } from \"../../utils/paginate\";\nimport type {\n  Command,\n  Handlers,\n  Message,\n  Part,\n  SandboxRecord,\n  Session,\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\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, 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(\n            ([key, value]) => sessionTags[key] === value\n          );\n        });\n      }\n      filtered.sort((a, b) => a.createdAt - b.createdAt);\n      return paginate({ items: filtered, cursor, limit });\n    },\n\n    \"session.listBySandbox\": async ({ sandboxId, tags, cursor, limit }) => {\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(\n            ([key, value]) => sessionTags[key] === value\n          );\n        });\n      }\n      filtered.sort((a, b) => a.createdAt - b.createdAt);\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(\n            ([key, value]) => 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    \"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.d.mts

@@ -0,0 +1,14 @@
+type LoaderOptions = {
+    debug?: boolean;
+};
+type LoaderContext = {
+    resourcePath: string;
+    getOptions(): LoaderOptions;
+};
+/**
+ * Webpack/Turbopack loader that wires up agent.rpc by requiring steps.js
+ * at the END of the file. Using require() avoids import hoisting issues.
+ */
+declare function agentRpcLoader(this: LoaderContext, source: string): string;
+
+export { agentRpcLoader as default };

package/dist/next/loader.d.ts

@@ -0,0 +1,14 @@
+type LoaderOptions = {
+    debug?: boolean;
+};
+type LoaderContext = {
+    resourcePath: string;
+    getOptions(): LoaderOptions;
+};
+/**
+ * Webpack/Turbopack loader that wires up agent.rpc by requiring steps.js
+ * at the END of the file. Using require() avoids import hoisting issues.
+ */
+declare function agentRpcLoader(this: LoaderContext, source: string): string;
+
+export { agentRpcLoader as default };

package/dist/next/loader.js

@@ -0,0 +1,206 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => agentRpcLoader
+});
+module.exports = __toCommonJS(loader_exports);
+var path = __toESM(require("path"));
+var import_core = require("@swc/core");
+
+// package.json
+var package_default = {
+  name: "experimental-agent",
+  version: "0.0.4",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  sideEffects: true,
+  license: "MIT",
+  files: [
+    "dist/**"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./next": {
+      types: "./dist/next.d.ts",
+      import: "./dist/next.mjs",
+      require: "./dist/next.js"
+    },
+    "./next/loader": {
+      types: "./dist/next/loader.d.ts",
+      import: "./dist/next/loader.mjs",
+      require: "./dist/next/loader.js"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.mjs",
+      require: "./dist/client.js"
+    }
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    release: "pnpm build && npm publish",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: {
+    "@hono/node-server": "^1.19.9",
+    "@swc/core": "^1.10.0",
+    "@vercel/oidc": "^3.1.0",
+    "better-all": "^0.0.5",
+    errore: "^0.8.2",
+    "fast-deep-equal": "^3.1.3",
+    glob: "^11.0.0",
+    hono: "^4.11.6",
+    sandbox: "^1.0.18",
+    ulid: "^3.0.2",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@agent/tsconfig": "workspace:*",
+    "@types/node": "^20.11.24",
+    dotenv: "^17.2.3",
+    next: "^16.0.0",
+    tsup: "^8.0.2",
+    "type-fest": "^5.4.2",
+    typescript: "5.5.4",
+    vitest: "^3.0.0"
+  },
+  peerDependencies: {
+    ai: "^6.0.0",
+    workflow: "https://workflow-docs-7evupb64d.vercel.sh/workflow.tgz"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/next/loader.ts
+var PACKAGE_NAME = package_default.name;
+var AGENT_PROTOCOL_VERSION = "v1";
+var TYPESCRIPT_EXT_REGEX = /\.(ts|tsx|mts|cts)$/;
+function agentRpcLoader(source) {
+  const { debug } = this.getOptions();
+  const log = debug ? (...args) => console.log("[agent-loader]", ...args) : () => void 0;
+  log("processing:", this.resourcePath);
+  if (!source.includes(PACKAGE_NAME)) {
+    log("skipping - no package name");
+    return source;
+  }
+  const filename = this.resourcePath;
+  const isTypeScript = TYPESCRIPT_EXT_REGEX.test(filename);
+  let ast;
+  try {
+    ast = (0, import_core.parseSync)(source, {
+      syntax: isTypeScript ? "typescript" : "ecmascript",
+      tsx: filename.endsWith(".tsx"),
+      jsx: filename.endsWith(".jsx")
+    });
+  } catch {
+    return source;
+  }
+  const agentExports = findAgentExports(ast);
+  if (agentExports.length === 0) {
+    log("skipping - no agent exports");
+    return source;
+  }
+  log("found agent exports:", agentExports);
+  const fileDir = path.dirname(filename);
+  const srcIndex = filename.lastIndexOf(`${path.sep}src${path.sep}`);
+  if (srcIndex === -1) {
+    log("skipping - no src dir found");
+    return source;
+  }
+  const srcDir = filename.substring(0, srcIndex + 4);
+  const appDir = path.join(srcDir, "app");
+  const stepsPath = path.join(
+    appDir,
+    ".well-known",
+    "agent",
+    AGENT_PROTOCOL_VERSION,
+    "steps.js"
+  );
+  let relativePath = path.relative(fileDir, stepsPath).replace(/\\/g, "/");
+  if (!(relativePath.startsWith("./") || relativePath.startsWith("../"))) {
+    relativePath = `./${relativePath}`;
+  }
+  const initCalls = agentExports.map((name) => {
+    const initName = `__init${name[0].toUpperCase()}${name.slice(1)}`;
+    return `${initName}(${name});`;
+  }).join("\n");
+  const initImports = agentExports.map((name) => `__init${name[0].toUpperCase()}${name.slice(1)}`).join(", ");
+  log("injecting init calls for:", agentExports);
+  return `${source}
+import { ${initImports} } from "${relativePath}";
+${initCalls}`;
+}
+function findAgentExports(ast) {
+  let agentLocalName = null;
+  for (const item of ast.body) {
+    if (item.type === "ImportDeclaration" && item.source.value === PACKAGE_NAME) {
+      for (const specifier of item.specifiers) {
+        if (specifier.type === "ImportSpecifier") {
+          const imported = specifier.imported?.type === "Identifier" ? specifier.imported.value : specifier.local.value;
+          if (imported === "agent") {
+            agentLocalName = specifier.local.value;
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (!agentLocalName) {
+    return [];
+  }
+  const exports = [];
+  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);
+          }
+        }
+      }
+    }
+  }
+  return 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.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": "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",
  "names": []
}
