experimental-agent 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,97 +1,518 @@
-import "./chunk-36X6L7SK.mjs";
+import "./chunk-TAXLUVIC.mjs";
+import {
+  STORAGE_RPC_METHODS,
+  handleStorageRpc
+} from "./chunk-VBLZWXVE.mjs";
 import {
   getSandbox
-} from "./chunk-4RGMKC2M.mjs";
+} from "./chunk-JEE2FQ4O.mjs";
 import {
   agentMessageHook,
   agentWorkflow,
+  approvalHook,
   assembleUIMessages,
-  normalizeSkillsDirs
-} from "./chunk-PGYYQ3WZ.mjs";
+  builtInTools,
+  builtinToolNames,
+  computeSessionUsage,
+  normalizeSkillsDirs,
+  resolveApiUrl
+} from "./chunk-JCPQQWIK.mjs";
+import "./chunk-TQRCSTCF.mjs";
+import "./chunk-64THY7Y7.mjs";
 import {
-  handleStorageRpc
-} from "./chunk-6ICYKNCC.mjs";
+  DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION,
+  getStorage
+} from "./chunk-GSRJYPWF.mjs";
 import {
   MessageNotFoundError,
   SandboxError,
   SandboxNotFoundError,
   SessionError,
   SessionNotFoundError,
-  StorageError,
-  getStorage
-} from "./chunk-24DJSI7C.mjs";
+  StorageError
+} from "./chunk-HJGPUEFC.mjs";
+import "./chunk-3ODWQVIA.mjs";
 
 // src/client.ts
 import { all } from "better-all";
 import * as errore from "errore";
 import equal from "fast-deep-equal";
-import { ulid } from "ulid";
+import { ulid as ulid2 } from "ulid";
 import { getRun, start } from "workflow/api";
 
-// src/mcp/index.ts
+// src/rpc-dispatch.ts
 import { z } from "zod";
-function serializeMcpConfig(mcp2) {
-  return Object.entries(mcp2).map(([name, server]) => ({
-    name,
-    url: server.url,
-    description: server.description,
-    tools: Object.entries(server.tools).map(([toolName, tool]) => ({
-      name: toolName,
-      description: tool.description,
-      inputSchema: z.toJSONSchema(tool.inputSchema),
-      outputSchema: tool.outputSchema ? z.toJSONSchema(tool.outputSchema) : void 0
-    }))
-  }));
+function handleOverrideResult(res) {
+  if (res === null) {
+    return null;
+  }
+  if (res.ok) {
+    return { result: res.result };
+  }
+  return {
+    error: { code: "HANDLER_ERROR", message: res.error },
+    status: 400
+  };
+}
+async function dispatch(method, params, context, name) {
+  const {
+    tools,
+    hooks,
+    needsApproval,
+    storageConfig,
+    getStorageInstance,
+    getStorageHandlers,
+    rpc,
+    overrides
+  } = context;
+  switch (method) {
+    case "tools.list": {
+      const defaultHandler = () => {
+        const toolsMap = tools ?? {};
+        const result = Object.entries(toolsMap).map(([name2, t]) => ({
+          name: name2,
+          description: t.description,
+          inputSchema: schemaToJsonSchema(t.inputSchema)
+        }));
+        return { result };
+      };
+      const override = overrides?.["tools.list"];
+      try {
+        const overrideResult = await override?.({});
+        if (overrideResult) {
+          const handled = handleOverrideResult(overrideResult);
+          if (handled) {
+            return handled;
+          }
+        }
+        return defaultHandler();
+      } catch (e) {
+        return {
+          error: {
+            code: "HANDLER_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+    case "tools.needsApproval": {
+      const p = params;
+      const defaultHandler = async () => {
+        const toolsMap = tools ?? {};
+        const toolDef = toolsMap[p.toolName];
+        if (toolDef?.needsApproval != null) {
+          if (typeof toolDef.needsApproval === "boolean") {
+            return { result: toolDef.needsApproval };
+          }
+          const result2 = await toolDef.needsApproval(p.input, {
+            toolCallId: p.toolCallId,
+            messages: p.messages,
+            experimental_context: void 0
+          });
+          return { result: result2 };
+        }
+        if (!needsApproval) {
+          return { result: false };
+        }
+        const entry = needsApproval[p.toolName];
+        if (entry == null) {
+          return { result: false };
+        }
+        if (typeof entry === "boolean") {
+          return { result: entry };
+        }
+        const result = await entry(p.input, {
+          toolCallId: p.toolCallId,
+          messages: p.messages,
+          experimental_context: void 0
+        });
+        return { result };
+      };
+      const override = overrides?.["tools.needsApproval"];
+      try {
+        const overrideResult = await override?.(p);
+        if (overrideResult) {
+          const handled = handleOverrideResult(overrideResult);
+          if (handled) {
+            return handled;
+          }
+        }
+        return await defaultHandler();
+      } catch (e) {
+        return {
+          error: {
+            code: "NEEDS_APPROVAL_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+    case "hook.tool.before": {
+      const p = params;
+      const defaultHandler = async (hookParams) => {
+        if (!hooks?.["tool.before"]) {
+          return {};
+        }
+        const hookResult = await hooks["tool.before"](hookParams);
+        return hookResult ?? {};
+      };
+      const override = overrides?.["hook.tool.before"];
+      try {
+        let currentParams = p;
+        let merged = {};
+        const overrideResult = await override?.(p);
+        if (overrideResult?.ok) {
+          merged = { ...merged, ...overrideResult.result };
+          if (merged.stop) {
+            return { result: merged };
+          }
+          if (overrideResult.result.input !== void 0) {
+            currentParams = {
+              ...currentParams,
+              input: overrideResult.result.input
+            };
+          }
+        }
+        const defaultResult = await defaultHandler(currentParams);
+        merged = { ...merged, ...defaultResult };
+        return { result: merged };
+      } catch (e) {
+        return {
+          error: {
+            code: "HOOK_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+    case "hook.tool.after": {
+      const p = params;
+      const defaultHandler = async (hookParams) => {
+        if (!hooks?.["tool.after"]) {
+          return {};
+        }
+        const hookResult = await hooks["tool.after"](hookParams);
+        return hookResult ?? {};
+      };
+      const override = overrides?.["hook.tool.after"];
+      try {
+        let currentParams = p;
+        let merged = {};
+        const overrideResult = await override?.(p);
+        if (overrideResult?.ok) {
+          merged = { ...merged, ...overrideResult.result };
+          if (merged.stop) {
+            return { result: merged };
+          }
+          if (overrideResult.result.result !== void 0) {
+            currentParams = {
+              ...currentParams,
+              result: overrideResult.result.result
+            };
+          }
+        }
+        const defaultResult = await defaultHandler(currentParams);
+        merged = { ...merged, ...defaultResult };
+        return { result: merged };
+      } catch (e) {
+        return {
+          error: {
+            code: "HOOK_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+    case "tools.execute": {
+      const p = params;
+      const defaultHandler = async () => {
+        const toolsMap = tools ?? {};
+        const toolDef = toolsMap[p.name];
+        if (!toolDef) {
+          return {
+            error: {
+              code: "TOOL_NOT_FOUND",
+              message: `Unknown tool: ${p.name}`
+            },
+            status: 400
+          };
+        }
+        const execute = toolDef.execute;
+        if (!execute) {
+          return {
+            error: {
+              code: "NO_EXECUTE",
+              message: `Tool ${p.name} has no execute function`
+            },
+            status: 400
+          };
+        }
+        const sandboxInstance = getSandbox({
+          sandboxRecord: p.sandboxRecord,
+          storageConfig,
+          storage: getStorageInstance(),
+          rpc
+        });
+        const toolContext = {
+          session: p.session,
+          sandbox: sandboxInstance,
+          storage: getStorageInstance(),
+          context: p.context
+        };
+        let toolInput = p.input;
+        const beforeResult = await dispatch(
+          "hook.tool.before",
+          {
+            name: p.name,
+            input: toolInput,
+            context: toolContext
+          },
+          context,
+          name
+        );
+        if ("error" in beforeResult) {
+          return beforeResult;
+        }
+        const beforeHook = beforeResult.result;
+        if (beforeHook.stop) {
+          return {
+            error: {
+              code: "HOOK_STOPPED",
+              message: "tool.before hook stopped execution"
+            },
+            status: 400
+          };
+        }
+        if (beforeHook.input !== void 0) {
+          toolInput = beforeHook.input;
+        }
+        let result = await execute(toolInput, {
+          experimental_context: toolContext,
+          toolCallId: "rpc",
+          messages: []
+        });
+        const afterResult = await dispatch(
+          "hook.tool.after",
+          {
+            name: p.name,
+            input: toolInput,
+            result,
+            context: toolContext
+          },
+          context,
+          name
+        );
+        if ("error" in afterResult) {
+          return afterResult;
+        }
+        const afterHook = afterResult.result;
+        if (afterHook.stop) {
+          return {
+            error: {
+              code: "HOOK_STOPPED",
+              message: "tool.after hook stopped execution"
+            },
+            status: 400
+          };
+        }
+        if (afterHook.result !== void 0) {
+          result = afterHook.result;
+        }
+        return { result };
+      };
+      const override = overrides?.["tools.execute"];
+      try {
+        const overrideResult = await override?.(p);
+        if (overrideResult) {
+          const handled = handleOverrideResult(overrideResult);
+          if (handled) {
+            return handled;
+          }
+        }
+        return await defaultHandler();
+      } catch (e) {
+        return {
+          error: {
+            code: "EXECUTE_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+    default: {
+      const methodName = method;
+      if (!STORAGE_RPC_METHODS.includes(methodName)) {
+        return {
+          error: {
+            code: "UNKNOWN_METHOD",
+            message: `Unknown RPC method: ${method}`
+          },
+          status: 400
+        };
+      }
+      const defaultHandler = async () => {
+        return await handleStorageRequest({
+          config: storageConfig,
+          request: { method, params },
+          name: name ?? storageConfig.name ?? "default",
+          getStorageHandlers
+        });
+      };
+      const override = overrides?.[methodName];
+      try {
+        const overrideResult = await override?.(params);
+        if (overrideResult) {
+          const handled = handleOverrideResult(overrideResult);
+          if (handled) {
+            return handled;
+          }
+        }
+        return await defaultHandler();
+      } catch (e) {
+        return {
+          error: {
+            code: "STORAGE_ERROR",
+            message: e instanceof Error ? e.message : String(e)
+          },
+          status: 500
+        };
+      }
+    }
+  }
+}
+async function handleStorageRequest({
+  config,
+  request,
+  name,
+  getStorageHandlers
+}) {
+  switch (config.type) {
+    case "local": {
+      const handlers = await getStorageHandlers(name);
+      const { handleStorageRpc: handleStorageRpc2 } = await import("./handler-36FM5H35.mjs");
+      return handleStorageRpc2(request, handlers);
+    }
+    case "vercel": {
+      const { getVercelStorageConfig } = await import("./vercel-LLXAHKVJ.mjs");
+      const resolved = await getVercelStorageConfig();
+      return await proxyStorageRequest({
+        url: resolved.url,
+        headers: { ...resolved.headers, "x-agent-name": name },
+        request
+      });
+    }
+    case "custom": {
+      return await proxyStorageRequest({
+        url: resolveApiUrl({ api: config.url }),
+        headers: { ...config.headers, "x-agent-name": name },
+        request
+      });
+    }
+    default: {
+      config;
+      throw new Error(
+        `Unknown storage type: ${config.type}`
+      );
+    }
+  }
+}
+async function proxyStorageRequest({
+  url,
+  headers,
+  request
+}) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(request)
+  });
+  if (!response.ok) {
+    return {
+      error: {
+        code: "PROXY_ERROR",
+        message: `Storage proxy failed: ${response.status} ${response.statusText}`
+      }
+    };
+  }
+  return response.json();
 }
-function mcp(opts) {
-  return opts;
+function schemaToJsonSchema(schema) {
+  if (!schema) {
+    return void 0;
+  }
+  if (typeof schema === "object" && schema !== null && "_def" in schema && typeof schema._def === "object") {
+    return z.toJSONSchema(schema);
+  }
+  if (typeof schema === "object" && schema !== null) {
+    const s = schema;
+    if (Symbol.for("vercel.ai.schema") in s && "jsonSchema" in s) {
+      return s.jsonSchema;
+    }
+  }
+  if (typeof schema === "object" && schema !== null && ("type" in schema || "properties" in schema)) {
+    return schema;
+  }
+  return void 0;
 }
 
 // src/utils/message.ts
+import { ulid } from "ulid";
 function toMessageAndParts({
   sessionId,
   id,
   input,
-  generateId,
   defaultRole
 }) {
-  const messageId = id ?? generateId("message");
+  const messageId = id ?? `message_${ulid()}`;
   if (typeof input === "string") {
+    const now2 = Date.now();
     return {
       message: {
         id: messageId,
         sessionId,
         role: defaultRole,
-        createdAt: Date.now(),
-        completedAt: Date.now(),
+        createdAt: now2,
+        startedAt: null,
+        completedAt: null,
         interruptedAt: null,
-        mcpContext: null
+        usage: null
       },
       parts: [
         {
           sessionId,
           messageId,
-          id: generateId("part"),
+          id: `part_${ulid()}`,
           index: 0,
           part: { type: "text", text: input }
         }
       ]
     };
   }
+  const now = Date.now();
   return {
     message: {
       sessionId,
       id: messageId,
-      createdAt: Date.now(),
-      completedAt: Date.now(),
+      createdAt: now,
+      startedAt: null,
+      completedAt: null,
       interruptedAt: null,
-      mcpContext: null,
+      usage: null,
       role: input.role ?? defaultRole
     },
     parts: input.parts.map((part, index) => ({
       sessionId,
       messageId,
-      id: generateId("part"),
+      id: `part_${ulid()}`,
       index,
       part
     }))
@@ -100,16 +521,52 @@ function toMessageAndParts({
 
 // src/client.ts
 var agent = (options) => {
-  const storageConfig = options.storage ?? { type: "vercel" };
-  const storage = getStorage(storageConfig);
-  const generateId = options.generateId ?? ((resource) => `${resource}_${ulid()}`);
+  const agentSecret = process.env.AGENT_SECRET;
+  if (!agentSecret) {
+    throw new Error(
+      "AGENT_SECRET env var is required. Use withAgent() or set it manually."
+    );
+  }
+  const baseStorageConfig = options.storage ?? { type: "vercel" };
+  const storageConfig = {
+    ...baseStorageConfig,
+    name: options.name ?? baseStorageConfig.name
+  };
+  let _storage = null;
+  const getStorageInstance = () => {
+    if (!_storage) {
+      _storage = getStorage({
+        config: storageConfig,
+        rpc: agentObj.rpc
+      });
+    }
+    return _storage;
+  };
+  let storageHandlersPromise = null;
+  const getStorageHandlers = (name) => {
+    if (storageConfig.type !== "local") {
+      return Promise.reject(
+        new Error("Storage handlers only available for local storage")
+      );
+    }
+    if (!storageHandlersPromise) {
+      storageHandlersPromise = (async () => {
+        const { join } = await import("node:path");
+        const { createFilesystemHandlers } = await import("./local-fs-handlers-P4WGW3QY.mjs");
+        const basePath = storageConfig.path ?? ".agent-storage";
+        const fullPath = join(basePath, name, LOCAL_STORAGE_VERSION);
+        return createFilesystemHandlers(fullPath);
+      })();
+    }
+    return storageHandlersPromise;
+  };
   const sandbox = async (sandboxId, opts) => {
-    const existingRecord = await storage.sandbox.get(sandboxId);
+    const existingRecord = await getStorageInstance().sandbox.get(sandboxId);
     if (existingRecord instanceof Error) {
       if (!(existingRecord instanceof SandboxNotFoundError)) {
         throw existingRecord;
       }
-      const sandboxRecord = await storage.sandbox.set({
+      const sandboxRecord = await getStorageInstance().sandbox.set({
         id: sandboxId,
         tags: opts?.tags ?? null,
         acquiringLockAt: null,
@@ -121,34 +578,40 @@ var agent = (options) => {
       if (sandboxRecord instanceof Error) {
         throw sandboxRecord;
       }
-      return getSandbox({ storageConfig, sandboxRecord });
+      return getSandbox({
+        storageConfig,
+        sandboxRecord,
+        storage: getStorageInstance(),
+        rpc: agentObj.rpc
+      });
     }
     const newConfig = opts?.config ?? existingRecord.config;
     if (!equal(existingRecord.config, newConfig)) {
-      throw new SandboxError({
-        reason: "sandbox config changes are not supported"
-      });
+      console.warn("sandbox config changes are not supported");
     }
-    return getSandbox({ storageConfig, sandboxRecord: existingRecord });
+    return getSandbox({
+      storageConfig,
+      sandboxRecord: existingRecord,
+      storage: getStorageInstance(),
+      rpc: agentObj.rpc
+    });
   };
-  return {
+  const agentObj = {
     session: async (sessionId, sessionOptions) => {
-      let session = await storage.session.get(sessionId);
+      let session = await getStorageInstance().session.get(sessionId);
       const sandboxInput = sessionOptions?.sandbox ?? options.sandbox;
       const sandboxId = typeof sandboxInput === "string" ? sandboxInput : (
         // biome-ignore lint/style/noNestedTernary: ok
-        session instanceof Error ? generateId("sandbox") : session.sandboxId ?? generateId("sandbox")
+        session instanceof Error ? `sandbox_${ulid2()}` : session.sandboxId ?? `sandbox_${ulid2()}`
       );
       const sandboxPromise = sandbox(
         sandboxId,
         typeof sandboxInput === "string" ? void 0 : { config: sandboxInput }
       );
       const existingSession = session instanceof Error ? null : session;
-      const mcpConfig = options.mcp || sessionOptions?.mcp ? { ...options.mcp, ...sessionOptions?.mcp } : null;
       const skillsDir = sessionOptions?.skillsDir ?? existingSession?.skillsDir ?? options.skillsDir ?? null;
       if (session instanceof Error) {
         if (session instanceof SessionNotFoundError) {
-          const instructions = sessionOptions?.instructions ?? options.instructions ?? null;
           const model = sessionOptions?.model ?? options.model ?? null;
           if (!model) {
             throw new SessionError({
@@ -156,19 +619,20 @@ var agent = (options) => {
               reason: "Model is not set"
             });
           }
-          session = await storage.session.set({
+          session = await getStorageInstance().session.set({
             id: sessionId,
             createdAt: Date.now(),
             updatedAt: Date.now(),
             lastMessageId: null,
             runId: null,
             tags: sessionOptions?.tags ?? null,
-            instructions,
+            system: sessionOptions?.system ?? options.system ?? null,
             model,
-            mcp: mcpConfig ? serializeMcpConfig(mcpConfig) : null,
             sandboxId,
             skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,
-            hookToken: null
+            hookToken: null,
+            activeTools: sessionOptions?.activeTools ?? options.activeTools ?? null,
+            generation: options.generation || sessionOptions?.generation ? { ...options.generation, ...sessionOptions?.generation } : null
           });
         } else {
           throw session;
@@ -177,46 +641,73 @@ var agent = (options) => {
         const updated = {
           ...session,
           ...sessionOptions,
-          mcp: mcpConfig ? serializeMcpConfig(mcpConfig) : session.mcp,
           sandboxId,
           skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null
         };
         if (!equal(updated, session)) {
-          session = await storage.session.set(updated);
+          session = await getStorageInstance().session.set(updated);
           if (session instanceof Error) {
             throw session;
           }
         }
       }
       const interruptCurrentMessage = async () => {
-        const currentSession = await storage.session.get(sessionId);
-        if (currentSession instanceof Error) {
-          return currentSession;
-        }
-        if (!currentSession.lastMessageId) {
-          return void 0;
-        }
-        const message = await storage.message.get(currentSession.lastMessageId);
-        if (message instanceof Error) {
-          return message;
+        const messagesResult = await getStorageInstance().message.list(sessionId);
+        if (messagesResult instanceof Error) {
+          return messagesResult;
         }
-        if (message.completedAt !== null || message.interruptedAt !== null) {
-          return void 0;
+        const now = Date.now();
+        const pendingAssistantMessages = messagesResult.items.filter(
+          (m) => m.role === "assistant" && m.completedAt === null && m.interruptedAt === null
+        );
+        const results = await Promise.all(
+          pendingAssistantMessages.map(
+            (m) => getStorageInstance().message.set({ ...m, interruptedAt: now })
+          )
+        );
+        for (const result of results) {
+          if (result instanceof Error) {
+            return result;
+          }
         }
-        const result = await storage.message.set({
-          ...message,
-          interruptedAt: Date.now()
-        });
-        if (result instanceof Error) {
-          return result;
+        for (const m of pendingAssistantMessages) {
+          const partsResult = await getStorageInstance().part.listByMessage(
+            m.id
+          );
+          if (partsResult instanceof Error) {
+            continue;
+          }
+          for (const p of partsResult.items) {
+            if (p.part && "state" in p.part && p.part.state === "approval-requested" && "approval" in p.part) {
+              const approval = p.part.approval;
+              if (approval?.id) {
+                await getStorageInstance().part.set({
+                  ...p,
+                  part: {
+                    ...p.part,
+                    state: "approval-responded",
+                    approval: {
+                      ...approval,
+                      approved: false,
+                      reason: "interrupted"
+                    }
+                  }
+                });
+                await approvalHook.resume(approval.id, {
+                  approved: false,
+                  reason: "interrupted"
+                });
+              }
+            }
+          }
         }
         return void 0;
       };
       return {
         send: async ({
           input,
-          mcpContext,
-          interruptIfStreaming
+          interruptIfStreaming,
+          context
         }) => {
           if (interruptIfStreaming) {
             const interruptResult = await interruptCurrentMessage();
@@ -231,8 +722,7 @@ var agent = (options) => {
               const { message, parts } = toMessageAndParts({
                 sessionId,
                 input: i,
-                defaultRole: "user",
-                generateId: () => generateId("message")
+                defaultRole: "user"
               });
               newMessages.push(message);
               newParts.push(...parts);
@@ -241,47 +731,56 @@ var agent = (options) => {
             const { message, parts } = toMessageAndParts({
               sessionId,
               input,
-              defaultRole: "user",
-              generateId: () => generateId("message")
+              defaultRole: "user"
             });
             newMessages.push(message);
             newParts.push(...parts);
           }
-          const assistantMessageId = generateId("message");
+          const assistantMessageId = `message_${ulid2()}`;
+          const baseTime = Date.now();
+          const assistantMessageCreatedAt = baseTime + newMessages.length;
           newMessages.push({
             id: assistantMessageId,
             sessionId,
             role: "assistant",
-            createdAt: Date.now(),
+            createdAt: assistantMessageCreatedAt,
+            startedAt: null,
             completedAt: null,
             interruptedAt: null,
-            mcpContext
+            usage: null
           });
-          const session2 = await storage.session.get(sessionId);
+          const session2 = await getStorageInstance().session.get(sessionId);
           if (session2 instanceof Error) {
             throw session2;
           }
           const agentInput = {
             storageConfig,
-            sessionId
+            sessionId,
+            rpc: agentObj.rpc
           };
           const event = {
             assistantMessageId,
-            hookToken: crypto.randomUUID()
+            hookToken: crypto.randomUUID(),
+            createdAt: assistantMessageCreatedAt,
+            context: context ?? {}
           };
           return await errore.tryAsync({
             try: async () => {
               await all({
                 async saveMessages() {
-                  const baseTime = Date.now();
                   await Promise.all(
                     newMessages.map(
-                      (m, i) => storage.message.set({ ...m, createdAt: baseTime + i })
+                      (m, i) => getStorageInstance().message.set({
+                        ...m,
+                        createdAt: baseTime + i
+                      })
                     )
                   );
                 },
                 async saveParts() {
-                  await Promise.all(newParts.map(storage.part.set));
+                  await Promise.all(
+                    newParts.map(getStorageInstance().part.set)
+                  );
                 },
                 async resumeOrStartAgentWorkflow() {
                   if (session2.runId) {
@@ -295,7 +794,7 @@ var agent = (options) => {
                 },
                 async updateSession() {
                   await this.$.resumeOrStartAgentWorkflow;
-                  const result = await storage.session.set({
+                  const result = await getStorageInstance().session.set({
                     ...session2,
                     updatedAt: Date.now(),
                     lastMessageId: assistantMessageId,
@@ -321,7 +820,7 @@ var agent = (options) => {
           });
         },
         stream: async (opts) => {
-          const session2 = await storage.session.get(sessionId);
+          const session2 = await getStorageInstance().session.get(sessionId);
           if (session2 instanceof Error) {
             return session2;
           }
@@ -343,8 +842,8 @@ var agent = (options) => {
         },
         ui: async () => {
           const [messagesResult, partsResult] = await Promise.all([
-            storage.message.list(sessionId),
-            storage.part.listBySession(sessionId)
+            getStorageInstance().message.list(sessionId),
+            getStorageInstance().part.listBySession(sessionId)
           ]);
           if (messagesResult instanceof Error) {
             return messagesResult;
@@ -356,28 +855,33 @@ var agent = (options) => {
             messages: messagesResult.items,
             parts: partsResult.items
           });
-          const lastMessage = messagesResult.items.at(-1);
-          const isStreaming = lastMessage?.role === "assistant" && lastMessage.completedAt === null && lastMessage.interruptedAt === null;
-          const streamingMessageId = isStreaming ? lastMessage.id : null;
-          return { messages, streamingMessageId };
+          const lastStartedAssistant = messagesResult.items.filter((m) => m.role === "assistant" && m.startedAt !== null).at(-1);
+          const isStreaming = lastStartedAssistant && lastStartedAssistant.completedAt === null && lastStartedAssistant.interruptedAt === null;
+          const streamingMessageId = isStreaming ? lastStartedAssistant.id : null;
+          const usage = computeSessionUsage(messagesResult.items);
+          return {
+            messages,
+            streamingMessageId,
+            usage
+          };
         },
         tag: {
           list: async () => {
-            const session2 = await storage.session.get(sessionId);
+            const session2 = await getStorageInstance().session.get(sessionId);
             if (session2 instanceof Error) {
               return session2;
             }
             return session2.tags ?? {};
           },
           get: async (key) => {
-            const session2 = await storage.session.get(sessionId);
+            const session2 = await getStorageInstance().session.get(sessionId);
             if (session2 instanceof Error) {
               return session2;
             }
             return session2.tags?.[key];
           },
           set: async (key, value) => {
-            const result = await storage.session.tag.set({
+            const result = await getStorageInstance().session.tag.set({
               sessionId,
               tags: { [key]: value }
             });
@@ -387,7 +891,7 @@ var agent = (options) => {
             return void 0;
           },
           setMany: async (tags) => {
-            const result = await storage.session.tag.set({
+            const result = await getStorageInstance().session.tag.set({
               sessionId,
               tags
             });
@@ -398,56 +902,125 @@ var agent = (options) => {
           }
         },
         sandbox: await sandboxPromise,
-        interrupt: interruptCurrentMessage
+        interrupt: interruptCurrentMessage,
+        resolveApproval: async ({
+          approvalId,
+          approved,
+          reason
+        }) => {
+          const partsResult = await getStorageInstance().part.listBySession(sessionId);
+          if (partsResult instanceof Error) {
+            return partsResult;
+          }
+          const targetPart = partsResult.items.find(
+            (p) => p.part && "approval" in p.part && p.part.approval?.id === approvalId
+          );
+          if (!targetPart) {
+            return new SessionError({
+              id: sessionId,
+              reason: `Approval ${approvalId} not found`
+            });
+          }
+          const updatedPart = {
+            ...targetPart,
+            part: {
+              ...targetPart.part,
+              state: "approval-responded",
+              approval: { id: approvalId, approved, reason }
+            }
+          };
+          const setResult = await getStorageInstance().part.set(
+            updatedPart
+          );
+          if (setResult instanceof Error) {
+            return setResult;
+          }
+          try {
+            await approvalHook.resume(approvalId, { approved, reason });
+          } catch {
+          }
+          return void 0;
+        },
+        usage: async () => {
+          const messagesResult = await getStorageInstance().message.list(sessionId);
+          if (messagesResult instanceof Error) {
+            return messagesResult;
+          }
+          return computeSessionUsage(messagesResult.items);
+        }
       };
     },
     sandbox,
-    storage,
-    handleMcpToolCall: async (body, handlers) => {
-      const { server, tool, input, sessionId, messageId, hookToken } = body;
-      const handlerKey = `${server}/${tool}`;
-      const handler = handlers[handlerKey];
-      if (!handler) {
-        return {
-          error: {
-            code: "HANDLER_NOT_FOUND",
-            message: `No handler for ${handlerKey}`
-          }
-        };
-      }
-      const session = await storage.session.get(sessionId);
-      if (session instanceof Error) {
-        return {
-          error: { code: "SESSION_NOT_FOUND", message: "Session not found" }
-        };
-      }
-      if (!session.hookToken || session.hookToken !== hookToken) {
-        return {
-          error: { code: "INVALID_TOKEN", message: "Invalid hook token" }
-        };
-      }
-      const message = await storage.message.get(messageId);
-      if (message instanceof Error) {
-        return {
-          error: { code: "MESSAGE_NOT_FOUND", message: "Message not found" }
-        };
+    get storage() {
+      return getStorageInstance();
+    },
+    /**
+     * RPC handler for agent operations.
+     * Handles tools.list, tools.execute, storage RPC, and hooks.
+     *
+     * Called internally by the `rpc` step function during workflow execution.
+     * Can also be exposed via HTTP for external access if needed.
+     */
+    handler: async (input, overrides) => {
+      const isRequest = input instanceof Request;
+      let method;
+      let params;
+      let name;
+      if (isRequest) {
+        const secret = input.headers.get("x-agent-secret");
+        if (secret !== agentSecret) {
+          return Response.json(
+            { error: { code: "UNAUTHORIZED", message: "Invalid secret" } },
+            { status: 401 }
+          );
+        }
+        let body;
+        try {
+          body = await input.json();
+        } catch {
+          return Response.json(
+            {
+              error: { code: "INVALID_REQUEST", message: "Invalid JSON body" }
+            },
+            { status: 400 }
+          );
+        }
+        method = body.method;
+        params = body.params;
+        name = input.headers.get("x-agent-name") ?? DEFAULT_NAMESPACE;
+      } else {
+        method = input.method;
+        params = input.params;
+        name = input.name ?? DEFAULT_NAMESPACE;
       }
-      const mcpContext = message.mcpContext;
-      const serverContext = mcpContext?.[server];
-      const headers = serverContext?.headers ?? {};
-      try {
-        const result = await handler({ input, headers, body });
-        return { result };
-      } catch (e) {
-        return {
-          error: {
-            code: "EXECUTION_ERROR",
-            message: e instanceof Error ? e.message : String(e)
-          }
-        };
+      const dispatchContext = {
+        tools: options.tools,
+        hooks: options.hooks,
+        needsApproval: options.needsApproval,
+        storageConfig,
+        getStorageInstance,
+        getStorageHandlers,
+        rpc: agentObj.rpc,
+        overrides
+      };
+      const result = await dispatch(method, params, dispatchContext, name);
+      if (!isRequest) {
+        return result;
       }
+      const status = "error" in result ? result.status ?? 500 : 200;
+      return Response.json(
+        "error" in result ? { error: result.error } : { result: result.result },
+        { status }
+      );
+    },
+    tools: { ...builtInTools, ...options.tools },
+    rpc: () => {
+      throw new Error(
+        "rpc not configured. Ensure withAgent is set up in next.config.ts"
+      );
     }
   };
+  return agentObj;
 };
 export {
   MessageNotFoundError,
@@ -456,7 +1029,7 @@ export {
   SessionNotFoundError,
   StorageError,
   agent,
-  handleStorageRpc,
-  mcp
+  builtinToolNames,
+  handleStorageRpc
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/client.ts", "../src/mcp/index.ts", "../src/utils/message.ts"],
  "sourcesContent": ["import type { GatewayModelId, UIMessage } from \"ai\";\nimport { all } from \"better-all\";\nimport * as errore from \"errore\";\nimport equal from \"fast-deep-equal\";\nimport { ulid } from \"ulid\";\nimport { getRun, start } from \"workflow/api\";\nimport {\n  type AgentInput,\n  type AgentMessageInput,\n  agentMessageHook,\n  agentWorkflow,\n} from \"./agent-workflow\";\nimport {\n  SandboxError,\n  SandboxNotFoundError,\n  SessionError,\n  SessionNotFoundError,\n} from \"./errors\";\nimport { type McpConfig, type McpSendOptions, serializeMcpConfig } from \"./mcp\";\nimport { getSandbox } from \"./sandbox\";\nimport { normalizeSkillsDirs } from \"./skills/parser\";\nimport type { SkillsDir } from \"./skills/types\";\nimport {\n  getStorage,\n  type Message,\n  type Part,\n  type Session,\n  type StorageConfig,\n} from \"./storage\";\nimport type { SandboxConfig } from \"./storage/rpc\";\nimport { toMessageAndParts } from \"./utils/message\";\nimport { assembleUIMessages } from \"./utils/ui\";\n\nexport type SendInput =\n  | string\n  | { role?: UIMessage[\"role\"]; parts: UIMessage[\"parts\"]; id?: string };\n\nexport type SessionOptions<\n  // biome-ignore lint/complexity/noBannedTypes: needed for generic default\n  TMcp extends McpConfig = {},\n  TTags extends TagsSchema = TagsSchema\n> = {\n  model?: GatewayModelId;\n  instructions?: string;\n  sandbox?: SandboxConfig | string;\n  tags?: TTags;\n  skillsDir?: SkillsDir;\n  mcp?: TMcp;\n};\n\nexport type McpToolCallBody = {\n  server: string;\n  tool: string;\n  input: unknown;\n  sessionId: string;\n  messageId: string;\n  hookToken: string;\n};\n\n// biome-ignore lint/complexity/noBannedTypes: needed for generic default\nexport type AgentOptions<TMcp extends McpConfig = {}> = {\n  storage?: StorageConfig;\n  generateId?: (\n    resource: \"session\" | \"message\" | \"part\" | \"sandbox\" | \"command\"\n  ) => string;\n} & SessionOptions<TMcp>;\n\nexport type TagsSchema = Record<string, unknown>;\n\n// biome-ignore lint/complexity/noBannedTypes: needed for generic default\nexport const agent = <TMcp extends McpConfig = {}>(\n  options: AgentOptions<TMcp>\n) => {\n  const storageConfig = options.storage ?? { type: \"vercel\" };\n  const storage = getStorage(storageConfig);\n  const generateId =\n    options.generateId ?? ((resource) => `${resource}_${ulid()}`);\n\n  const sandbox = async <TTags extends TagsSchema = TagsSchema>(\n    sandboxId: string,\n    opts?: { config?: SandboxConfig; tags?: TTags }\n  ) => {\n    const existingRecord = await storage.sandbox.get(sandboxId);\n\n    if (existingRecord instanceof Error) {\n      if (!(existingRecord instanceof SandboxNotFoundError)) {\n        throw existingRecord;\n      }\n      const sandboxRecord = await storage.sandbox.set({\n        id: sandboxId,\n        tags: opts?.tags ?? null,\n        acquiringLockAt: null,\n        acquiringLockId: null,\n        createdAt: Date.now(),\n        lastActivityAt: Date.now(),\n        config: opts?.config ??\n          (typeof options.sandbox === \"string\"\n            ? undefined\n            : options.sandbox) ?? { type: \"vercel\" },\n      });\n      if (sandboxRecord instanceof Error) {\n        throw sandboxRecord;\n      }\n      return getSandbox<TTags>({ storageConfig, sandboxRecord });\n    }\n\n    const newConfig = opts?.config ?? existingRecord.config;\n    if (!equal(existingRecord.config, newConfig)) {\n      throw new SandboxError({\n        reason: \"sandbox config changes are not supported\",\n      });\n    }\n\n    return getSandbox<TTags>({ storageConfig, sandboxRecord: existingRecord });\n  };\n\n  return {\n    session: async <\n      TTags extends TagsSchema = TagsSchema,\n      // biome-ignore lint/complexity/noBannedTypes: needed for generic default\n      TMcpOverride extends McpConfig = {}\n    >(\n      sessionId: string,\n      sessionOptions?: SessionOptions<TMcp & TMcpOverride, TTags>\n    ) => {\n      let session = await storage.session.get(sessionId);\n\n      /**\n       * normalize sandbox input to a sandbox ID and config\n       */\n      const sandboxInput = sessionOptions?.sandbox ?? options.sandbox;\n      const sandboxId =\n        typeof sandboxInput === \"string\"\n          ? sandboxInput\n          : // biome-ignore lint/style/noNestedTernary: ok\n          session instanceof Error\n          ? generateId(\"sandbox\")\n          : session.sandboxId ?? generateId(\"sandbox\");\n      const sandboxPromise = sandbox(\n        sandboxId,\n        typeof sandboxInput === \"string\" ? undefined : { config: sandboxInput }\n      );\n\n      const existingSession = session instanceof Error ? null : session;\n      const mcpConfig =\n        options.mcp || sessionOptions?.mcp\n          ? { ...options.mcp, ...sessionOptions?.mcp }\n          : null;\n      const skillsDir =\n        sessionOptions?.skillsDir ??\n        existingSession?.skillsDir ??\n        options.skillsDir ??\n        null;\n\n      if (session instanceof Error) {\n        if (session instanceof SessionNotFoundError) {\n          const instructions =\n            sessionOptions?.instructions ?? options.instructions ?? null;\n          const model = sessionOptions?.model ?? options.model ?? null;\n          if (!model) {\n            throw new SessionError({\n              id: sessionId,\n              reason: \"Model is not set\",\n            });\n          }\n          session = await storage.session.set({\n            id: sessionId,\n            createdAt: Date.now(),\n            updatedAt: Date.now(),\n            lastMessageId: null,\n            runId: null,\n            tags: sessionOptions?.tags ?? null,\n            instructions,\n            model,\n            mcp: mcpConfig ? serializeMcpConfig(mcpConfig) : null,\n            sandboxId,\n            skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,\n            hookToken: null,\n          });\n        } else {\n          throw session;\n        }\n      } else {\n        /**\n         * this is an existing session. we compare the options and update the session if necessary.\n         */\n        const updated: Session = {\n          ...session,\n          ...sessionOptions,\n          mcp: mcpConfig ? serializeMcpConfig(mcpConfig) : session.mcp,\n          sandboxId,\n          skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,\n        };\n        if (!equal(updated, session)) {\n          session = await storage.session.set(updated);\n          if (session instanceof Error) {\n            throw session;\n          }\n        }\n      }\n\n      const interruptCurrentMessage = async () => {\n        const currentSession = await storage.session.get(sessionId);\n        if (currentSession instanceof Error) {\n          return currentSession;\n        }\n        if (!currentSession.lastMessageId) {\n          return undefined;\n        }\n        const message = await storage.message.get(currentSession.lastMessageId);\n        if (message instanceof Error) {\n          return message;\n        }\n        if (message.completedAt !== null || message.interruptedAt !== null) {\n          return undefined;\n        }\n        const result = await storage.message.set({\n          ...message,\n          interruptedAt: Date.now(),\n        });\n        if (result instanceof Error) {\n          return result;\n        }\n        return undefined;\n      };\n\n      return {\n        send: async ({\n          input,\n          mcpContext,\n          interruptIfStreaming,\n        }: {\n          input: SendInput | SendInput[];\n          mcpContext?: McpSendOptions<TMcp & TMcpOverride>;\n          interruptIfStreaming?: boolean;\n        }) => {\n          if (interruptIfStreaming) {\n            const interruptResult = await interruptCurrentMessage();\n            if (interruptResult instanceof Error) {\n              return interruptResult;\n            }\n          }\n          const newMessages: Message[] = [];\n          const newParts: Part[] = [];\n          if (Array.isArray(input)) {\n            for (const i of input) {\n              const { message, parts } = toMessageAndParts({\n                sessionId,\n                input: i,\n                defaultRole: \"user\",\n                generateId: () => generateId(\"message\"),\n              });\n\n              newMessages.push(message);\n              newParts.push(...parts);\n            }\n          } else {\n            const { message, parts } = toMessageAndParts({\n              sessionId,\n              input,\n              defaultRole: \"user\",\n              generateId: () => generateId(\"message\"),\n            });\n            newMessages.push(message);\n            newParts.push(...parts);\n          }\n          /**\n           * we also pre-create the assistant message\n           */\n          const assistantMessageId = generateId(\"message\");\n          newMessages.push({\n            id: assistantMessageId,\n            sessionId,\n            role: \"assistant\",\n            createdAt: Date.now(),\n            completedAt: null,\n            interruptedAt: null,\n            mcpContext,\n          });\n\n          const session2 = await storage.session.get(sessionId);\n          if (session2 instanceof Error) {\n            throw session2;\n          }\n\n          const agentInput: AgentInput = {\n            storageConfig,\n            sessionId,\n          };\n          const event: AgentMessageInput = {\n            assistantMessageId,\n            hookToken: crypto.randomUUID(),\n          };\n\n          return await errore.tryAsync({\n            try: async () => {\n              await all({\n                async saveMessages() {\n                  const baseTime = Date.now();\n                  await Promise.all(\n                    newMessages.map((m, i) =>\n                      storage.message.set({ ...m, createdAt: baseTime + i })\n                    )\n                  );\n                },\n                async saveParts() {\n                  await Promise.all(newParts.map(storage.part.set));\n                },\n                async resumeOrStartAgentWorkflow() {\n                  if (session2.runId) {\n                    await agentMessageHook.resume(sessionId, event);\n                  } else {\n                    const startResult = await start(agentWorkflow, [\n                      { input: agentInput, event },\n                    ]);\n                    session2.runId = startResult.runId;\n                  }\n                },\n                async updateSession() {\n                  await this.$.resumeOrStartAgentWorkflow;\n                  const result = await storage.session.set({\n                    ...session2,\n                    updatedAt: Date.now(),\n                    lastMessageId: assistantMessageId,\n                    hookToken: event.hookToken,\n                  });\n                  if (result instanceof Error) {\n                    throw result;\n                  }\n                  return result;\n                },\n              });\n            },\n            catch: (e) => {\n              if (e instanceof Error) {\n                throw e;\n              }\n              return new SessionError({\n                id: sessionId,\n                reason: `failed to send: ${String(e)}`,\n                cause: e,\n              });\n            },\n          });\n        },\n\n        stream: async (opts?: { messageId?: string }) => {\n          const session = await storage.session.get(sessionId);\n          if (session instanceof Error) {\n            return session;\n          }\n          const messageId = opts?.messageId ?? session.lastMessageId;\n          if (!messageId) {\n            return new SessionError({\n              id: sessionId,\n              reason: \"No message associated with session\",\n            });\n          }\n          if (!session.runId) {\n            return new SessionError({\n              id: sessionId,\n              reason: \"No run associated with session\",\n            });\n          }\n          const run = getRun(session.runId);\n          return run.getReadable({ namespace: messageId });\n        },\n\n        ui: async () => {\n          const [messagesResult, partsResult] = await Promise.all([\n            storage.message.list(sessionId),\n            storage.part.listBySession(sessionId),\n          ]);\n\n          if (messagesResult instanceof Error) {\n            return messagesResult;\n          }\n          if (partsResult instanceof Error) {\n            return partsResult;\n          }\n\n          const messages = assembleUIMessages({\n            messages: messagesResult.items,\n            parts: partsResult.items,\n          });\n\n          const lastMessage = messagesResult.items.at(-1);\n          const isStreaming =\n            lastMessage?.role === \"assistant\" &&\n            lastMessage.completedAt === null &&\n            lastMessage.interruptedAt === null;\n          const streamingMessageId = isStreaming ? lastMessage.id : null;\n\n          return { messages, streamingMessageId };\n        },\n        tag: {\n          list: async () => {\n            const session = await storage.session.get(sessionId);\n            if (session instanceof Error) {\n              return session;\n            }\n            return (session.tags ?? {}) as TTags;\n          },\n          get: async (key: string) => {\n            const session = await storage.session.get(sessionId);\n            if (session instanceof Error) {\n              return session;\n            }\n            return session.tags?.[key as string] as\n              | TTags[typeof key]\n              | undefined;\n          },\n          set: async (key: string, value: unknown) => {\n            const result = await storage.session.tag.set({\n              sessionId,\n              tags: { [key]: value } as Record<string, unknown>,\n            });\n            if (result instanceof Error) {\n              return result;\n            }\n            return undefined;\n          },\n          setMany: async (tags: Record<string, unknown>) => {\n            const result = await storage.session.tag.set({\n              sessionId,\n              tags: tags as Record<string, unknown>,\n            });\n            if (result instanceof Error) {\n              return result;\n            }\n            return undefined;\n          },\n        },\n        sandbox: await sandboxPromise,\n\n        interrupt: interruptCurrentMessage,\n      };\n    },\n    sandbox,\n    storage,\n    handleMcpToolCall: async (\n      body: McpToolCallBody,\n      handlers: Record<\n        string,\n        (opts: {\n          input: unknown;\n          headers: Record<string, string>;\n          body: McpToolCallBody;\n        }) => Promise<unknown>\n      >\n    ): Promise<\n      { result: unknown } | { error: { code: string; message: string } }\n    > => {\n      const { server, tool, input, sessionId, messageId, hookToken } = body;\n\n      const handlerKey = `${server}/${tool}`;\n      const handler = handlers[handlerKey];\n      if (!handler) {\n        return {\n          error: {\n            code: \"HANDLER_NOT_FOUND\",\n            message: `No handler for ${handlerKey}`,\n          },\n        };\n      }\n\n      const session = await storage.session.get(sessionId);\n      if (session instanceof Error) {\n        return {\n          error: { code: \"SESSION_NOT_FOUND\", message: \"Session not found\" },\n        };\n      }\n\n      if (!session.hookToken || session.hookToken !== hookToken) {\n        return {\n          error: { code: \"INVALID_TOKEN\", message: \"Invalid hook token\" },\n        };\n      }\n\n      const message = await storage.message.get(messageId);\n      if (message instanceof Error) {\n        return {\n          error: { code: \"MESSAGE_NOT_FOUND\", message: \"Message not found\" },\n        };\n      }\n\n      const mcpContext = message.mcpContext as McpSendOptions<TMcp> | undefined;\n      const serverContext = mcpContext?.[server as keyof typeof mcpContext];\n      const headers = (serverContext?.headers ?? {}) as Record<string, string>;\n\n      try {\n        const result = await handler({ input, headers, body });\n        return { result };\n      } catch (e) {\n        return {\n          error: {\n            code: \"EXECUTION_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n        };\n      }\n    },\n  };\n};\n", "import { z } from \"zod\";\n\nexport type McpToolDef = {\n  description: string;\n  inputSchema: z.ZodType;\n  outputSchema?: z.ZodType;\n};\n\nexport type McpServerDef<\n  TTools extends Record<string, McpToolDef> = Record<string, McpToolDef>,\n  THeaders extends z.ZodType = z.ZodType,\n> = {\n  url: string;\n  description?: string;\n  headersSchema?: THeaders;\n  tools: TTools;\n};\n\nexport type McpConfig = Record<string, McpServerDef>;\n\nexport function serializeMcpConfig(mcp: McpConfig): McpServerSchema[] {\n  return Object.entries(mcp).map(([name, server]) => ({\n    name,\n    url: server.url,\n    description: server.description,\n    tools: Object.entries(server.tools).map(([toolName, tool]) => ({\n      name: toolName,\n      description: tool.description,\n      inputSchema: z.toJSONSchema(tool.inputSchema),\n      outputSchema: tool.outputSchema\n        ? z.toJSONSchema(tool.outputSchema)\n        : undefined,\n    })),\n  }));\n}\n\nexport type McpToolSchema = {\n  name: string;\n  description: string;\n  inputSchema: unknown;\n  outputSchema?: unknown;\n};\n\nexport type McpServerSchema = {\n  name: string;\n  url: string;\n  description?: string;\n  tools: McpToolSchema[];\n};\n\ntype ExtractHeaders<T> =\n  T extends McpServerDef<infer _TTools, infer THeaders>\n    ? THeaders extends z.ZodType\n      ? z.infer<THeaders>\n      : Record<string, string>\n    : Record<string, string>;\n\ntype HasRequiredHeaders<T extends McpServerDef> = T extends {\n  headersSchema: z.ZodType;\n}\n  ? true\n  : false;\n\ntype ServerSendOptions<T extends McpServerDef> =\n  HasRequiredHeaders<T> extends true\n    ?\n        | { headers: ExtractHeaders<T>; disabled?: false }\n        | { disabled: true; headers?: ExtractHeaders<T> }\n    : { headers?: ExtractHeaders<T>; disabled?: boolean };\n\nexport type McpSendOptions<TMcp extends McpConfig> = {\n  [K in keyof TMcp]?: ServerSendOptions<TMcp[K]>;\n};\n\nexport type McpToolCallRequest = {\n  server: string;\n  tool: string;\n  input: unknown;\n  messageId: string;\n  mcpToken: string;\n};\n\nexport type McpToolCallSuccessResponse<T = unknown> = {\n  result: T;\n};\n\nexport type McpToolCallErrorResponse = {\n  error: { code: string; message: string };\n};\n\nexport type McpToolCallResponse<T = unknown> =\n  | McpToolCallSuccessResponse<T>\n  | McpToolCallErrorResponse;\n\ntype ExtractInput<T extends McpToolDef> = T extends { inputSchema: infer S }\n  ? S extends z.ZodType\n    ? z.infer<S>\n    : unknown\n  : unknown;\n\ntype HandlerForTool<\n  TServer extends McpServerDef,\n  TTool extends McpToolDef,\n> = (opts: {\n  input: ExtractInput<TTool>;\n  headers: ExtractHeaders<TServer>;\n}) => Promise<unknown>;\n\ntype BuildHandlers<TMcp extends McpConfig> = {\n  [K in keyof TMcp & string]: {\n    [T in keyof TMcp[K][\"tools\"] & string]: {\n      key: `${K}/${T}`;\n      handler: HandlerForTool<TMcp[K], TMcp[K][\"tools\"][T]>;\n    };\n  }[keyof TMcp[K][\"tools\"] & string];\n}[keyof TMcp & string];\n\ntype UnionToIntersection<U> = (\n  U extends unknown\n    ? (k: U) => void\n    : never\n) extends (k: infer I) => void\n  ? I\n  : never;\n\ntype HandlersFromUnion<U> = UnionToIntersection<\n  U extends { key: infer K; handler: infer H }\n    ? K extends string\n      ? { [P in K]: H }\n      : never\n    : never\n>;\n\nexport type McpToolCallHandlers<TMcp extends McpConfig> = HandlersFromUnion<\n  BuildHandlers<TMcp>\n>;\n\nexport function mcp<\n  THeaders extends z.ZodType,\n  TTools extends Record<string, McpToolDef>,\n>(opts: {\n  url: string;\n  description?: string;\n  headersSchema?: THeaders;\n  tools: TTools;\n}): McpServerDef<TTools, THeaders> {\n  return opts;\n}\n", "import type { UIMessage } from \"ai\";\nimport type { AgentOptions, SendInput } from \"../client\";\nimport type { Message, Part } from \"../storage\";\n\nexport function toMessageAndParts({\n  sessionId,\n  id,\n  input,\n  generateId,\n  defaultRole,\n}: {\n  sessionId: string;\n  id?: string;\n  input: SendInput;\n  generateId: NonNullable<AgentOptions[\"generateId\"]>;\n  defaultRole: UIMessage[\"role\"];\n}): { message: Message; parts: Part[] } {\n  const messageId = id ?? generateId(\"message\");\n  if (typeof input === \"string\") {\n    return {\n      message: {\n        id: messageId,\n        sessionId,\n        role: defaultRole,\n        createdAt: Date.now(),\n        completedAt: Date.now(),\n        interruptedAt: null,\n        mcpContext: null,\n      },\n      parts: [\n        {\n          sessionId,\n          messageId,\n          id: generateId(\"part\"),\n          index: 0,\n          part: { type: \"text\", text: input },\n        },\n      ],\n    };\n  }\n  return {\n    message: {\n      sessionId,\n      id: messageId,\n      createdAt: Date.now(),\n      completedAt: Date.now(),\n      interruptedAt: null,\n      mcpContext: null,\n      role: input.role ?? defaultRole,\n    },\n    parts: input.parts.map((part, index) => ({\n      sessionId,\n      messageId,\n      id: generateId(\"part\"),\n      index,\n      part,\n    })),\n  };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AACA,SAAS,WAAW;AACpB,YAAY,YAAY;AACxB,OAAO,WAAW;AAClB,SAAS,YAAY;AACrB,SAAS,QAAQ,aAAa;;;ACL9B,SAAS,SAAS;AAoBX,SAAS,mBAAmBA,MAAmC;AACpE,SAAO,OAAO,QAAQA,IAAG,EAAE,IAAI,CAAC,CAAC,MAAM,MAAM,OAAO;AAAA,IAClD;AAAA,IACA,KAAK,OAAO;AAAA,IACZ,aAAa,OAAO;AAAA,IACpB,OAAO,OAAO,QAAQ,OAAO,KAAK,EAAE,IAAI,CAAC,CAAC,UAAU,IAAI,OAAO;AAAA,MAC7D,MAAM;AAAA,MACN,aAAa,KAAK;AAAA,MAClB,aAAa,EAAE,aAAa,KAAK,WAAW;AAAA,MAC5C,cAAc,KAAK,eACf,EAAE,aAAa,KAAK,YAAY,IAChC;AAAA,IACN,EAAE;AAAA,EACJ,EAAE;AACJ;AAuGO,SAAS,IAGd,MAKiC;AACjC,SAAO;AACT;;;AC/IO,SAAS,kBAAkB;AAAA,EAChC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAMwC;AACtC,QAAM,YAAY,MAAM,WAAW,SAAS;AAC5C,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO;AAAA,MACL,SAAS;AAAA,QACP,IAAI;AAAA,QACJ;AAAA,QACA,MAAM;AAAA,QACN,WAAW,KAAK,IAAI;AAAA,QACpB,aAAa,KAAK,IAAI;AAAA,QACtB,eAAe;AAAA,QACf,YAAY;AAAA,MACd;AAAA,MACA,OAAO;AAAA,QACL;AAAA,UACE;AAAA,UACA;AAAA,UACA,IAAI,WAAW,MAAM;AAAA,UACrB,OAAO;AAAA,UACP,MAAM,EAAE,MAAM,QAAQ,MAAM,MAAM;AAAA,QACpC;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL,SAAS;AAAA,MACP;AAAA,MACA,IAAI;AAAA,MACJ,WAAW,KAAK,IAAI;AAAA,MACpB,aAAa,KAAK,IAAI;AAAA,MACtB,eAAe;AAAA,MACf,YAAY;AAAA,MACZ,MAAM,MAAM,QAAQ;AAAA,IACtB;AAAA,IACA,OAAO,MAAM,MAAM,IAAI,CAAC,MAAM,WAAW;AAAA,MACvC;AAAA,MACA;AAAA,MACA,IAAI,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,IACF,EAAE;AAAA,EACJ;AACF;;;AFYO,IAAM,QAAQ,CACnB,YACG;AACH,QAAM,gBAAgB,QAAQ,WAAW,EAAE,MAAM,SAAS;AAC1D,QAAM,UAAU,WAAW,aAAa;AACxC,QAAM,aACJ,QAAQ,eAAe,CAAC,aAAa,GAAG,QAAQ,IAAI,KAAK,CAAC;AAE5D,QAAM,UAAU,OACd,WACA,SACG;AACH,UAAM,iBAAiB,MAAM,QAAQ,QAAQ,IAAI,SAAS;AAE1D,QAAI,0BAA0B,OAAO;AACnC,UAAI,EAAE,0BAA0B,uBAAuB;AACrD,cAAM;AAAA,MACR;AACA,YAAM,gBAAgB,MAAM,QAAQ,QAAQ,IAAI;AAAA,QAC9C,IAAI;AAAA,QACJ,MAAM,MAAM,QAAQ;AAAA,QACpB,iBAAiB;AAAA,QACjB,iBAAiB;AAAA,QACjB,WAAW,KAAK,IAAI;AAAA,QACpB,gBAAgB,KAAK,IAAI;AAAA,QACzB,QAAQ,MAAM,WACX,OAAO,QAAQ,YAAY,WACxB,SACA,QAAQ,YAAY,EAAE,MAAM,SAAS;AAAA,MAC7C,CAAC;AACD,UAAI,yBAAyB,OAAO;AAClC,cAAM;AAAA,MACR;AACA,aAAO,WAAkB,EAAE,eAAe,cAAc,CAAC;AAAA,IAC3D;AAEA,UAAM,YAAY,MAAM,UAAU,eAAe;AACjD,QAAI,CAAC,MAAM,eAAe,QAAQ,SAAS,GAAG;AAC5C,YAAM,IAAI,aAAa;AAAA,QACrB,QAAQ;AAAA,MACV,CAAC;AAAA,IACH;AAEA,WAAO,WAAkB,EAAE,eAAe,eAAe,eAAe,CAAC;AAAA,EAC3E;AAEA,SAAO;AAAA,IACL,SAAS,OAKP,WACA,mBACG;AACH,UAAI,UAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AAKjD,YAAM,eAAe,gBAAgB,WAAW,QAAQ;AACxD,YAAM,YACJ,OAAO,iBAAiB,WACpB;AAAA;AAAA,QAEF,mBAAmB,QACjB,WAAW,SAAS,IACpB,QAAQ,aAAa,WAAW,SAAS;AAAA;AAC/C,YAAM,iBAAiB;AAAA,QACrB;AAAA,QACA,OAAO,iBAAiB,WAAW,SAAY,EAAE,QAAQ,aAAa;AAAA,MACxE;AAEA,YAAM,kBAAkB,mBAAmB,QAAQ,OAAO;AAC1D,YAAM,YACJ,QAAQ,OAAO,gBAAgB,MAC3B,EAAE,GAAG,QAAQ,KAAK,GAAG,gBAAgB,IAAI,IACzC;AACN,YAAM,YACJ,gBAAgB,aAChB,iBAAiB,aACjB,QAAQ,aACR;AAEF,UAAI,mBAAmB,OAAO;AAC5B,YAAI,mBAAmB,sBAAsB;AAC3C,gBAAM,eACJ,gBAAgB,gBAAgB,QAAQ,gBAAgB;AAC1D,gBAAM,QAAQ,gBAAgB,SAAS,QAAQ,SAAS;AACxD,cAAI,CAAC,OAAO;AACV,kBAAM,IAAI,aAAa;AAAA,cACrB,IAAI;AAAA,cACJ,QAAQ;AAAA,YACV,CAAC;AAAA,UACH;AACA,oBAAU,MAAM,QAAQ,QAAQ,IAAI;AAAA,YAClC,IAAI;AAAA,YACJ,WAAW,KAAK,IAAI;AAAA,YACpB,WAAW,KAAK,IAAI;AAAA,YACpB,eAAe;AAAA,YACf,OAAO;AAAA,YACP,MAAM,gBAAgB,QAAQ;AAAA,YAC9B;AAAA,YACA;AAAA,YACA,KAAK,YAAY,mBAAmB,SAAS,IAAI;AAAA,YACjD;AAAA,YACA,WAAW,YAAY,oBAAoB,SAAS,IAAI;AAAA,YACxD,WAAW;AAAA,UACb,CAAC;AAAA,QACH,OAAO;AACL,gBAAM;AAAA,QACR;AAAA,MACF,OAAO;AAIL,cAAM,UAAmB;AAAA,UACvB,GAAG;AAAA,UACH,GAAG;AAAA,UACH,KAAK,YAAY,mBAAmB,SAAS,IAAI,QAAQ;AAAA,UACzD;AAAA,UACA,WAAW,YAAY,oBAAoB,SAAS,IAAI;AAAA,QAC1D;AACA,YAAI,CAAC,MAAM,SAAS,OAAO,GAAG;AAC5B,oBAAU,MAAM,QAAQ,QAAQ,IAAI,OAAO;AAC3C,cAAI,mBAAmB,OAAO;AAC5B,kBAAM;AAAA,UACR;AAAA,QACF;AAAA,MACF;AAEA,YAAM,0BAA0B,YAAY;AAC1C,cAAM,iBAAiB,MAAM,QAAQ,QAAQ,IAAI,SAAS;AAC1D,YAAI,0BAA0B,OAAO;AACnC,iBAAO;AAAA,QACT;AACA,YAAI,CAAC,eAAe,eAAe;AACjC,iBAAO;AAAA,QACT;AACA,cAAM,UAAU,MAAM,QAAQ,QAAQ,IAAI,eAAe,aAAa;AACtE,YAAI,mBAAmB,OAAO;AAC5B,iBAAO;AAAA,QACT;AACA,YAAI,QAAQ,gBAAgB,QAAQ,QAAQ,kBAAkB,MAAM;AAClE,iBAAO;AAAA,QACT;AACA,cAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI;AAAA,UACvC,GAAG;AAAA,UACH,eAAe,KAAK,IAAI;AAAA,QAC1B,CAAC;AACD,YAAI,kBAAkB,OAAO;AAC3B,iBAAO;AAAA,QACT;AACA,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,QACL,MAAM,OAAO;AAAA,UACX;AAAA,UACA;AAAA,UACA;AAAA,QACF,MAIM;AACJ,cAAI,sBAAsB;AACxB,kBAAM,kBAAkB,MAAM,wBAAwB;AACtD,gBAAI,2BAA2B,OAAO;AACpC,qBAAO;AAAA,YACT;AAAA,UACF;AACA,gBAAM,cAAyB,CAAC;AAChC,gBAAM,WAAmB,CAAC;AAC1B,cAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,uBAAW,KAAK,OAAO;AACrB,oBAAM,EAAE,SAAS,MAAM,IAAI,kBAAkB;AAAA,gBAC3C;AAAA,gBACA,OAAO;AAAA,gBACP,aAAa;AAAA,gBACb,YAAY,MAAM,WAAW,SAAS;AAAA,cACxC,CAAC;AAED,0BAAY,KAAK,OAAO;AACxB,uBAAS,KAAK,GAAG,KAAK;AAAA,YACxB;AAAA,UACF,OAAO;AACL,kBAAM,EAAE,SAAS,MAAM,IAAI,kBAAkB;AAAA,cAC3C;AAAA,cACA;AAAA,cACA,aAAa;AAAA,cACb,YAAY,MAAM,WAAW,SAAS;AAAA,YACxC,CAAC;AACD,wBAAY,KAAK,OAAO;AACxB,qBAAS,KAAK,GAAG,KAAK;AAAA,UACxB;AAIA,gBAAM,qBAAqB,WAAW,SAAS;AAC/C,sBAAY,KAAK;AAAA,YACf,IAAI;AAAA,YACJ;AAAA,YACA,MAAM;AAAA,YACN,WAAW,KAAK,IAAI;AAAA,YACpB,aAAa;AAAA,YACb,eAAe;AAAA,YACf;AAAA,UACF,CAAC;AAED,gBAAM,WAAW,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACpD,cAAI,oBAAoB,OAAO;AAC7B,kBAAM;AAAA,UACR;AAEA,gBAAM,aAAyB;AAAA,YAC7B;AAAA,YACA;AAAA,UACF;AACA,gBAAM,QAA2B;AAAA,YAC/B;AAAA,YACA,WAAW,OAAO,WAAW;AAAA,UAC/B;AAEA,iBAAO,MAAa,gBAAS;AAAA,YAC3B,KAAK,YAAY;AACf,oBAAM,IAAI;AAAA,gBACR,MAAM,eAAe;AACnB,wBAAM,WAAW,KAAK,IAAI;AAC1B,wBAAM,QAAQ;AAAA,oBACZ,YAAY;AAAA,sBAAI,CAAC,GAAG,MAClB,QAAQ,QAAQ,IAAI,EAAE,GAAG,GAAG,WAAW,WAAW,EAAE,CAAC;AAAA,oBACvD;AAAA,kBACF;AAAA,gBACF;AAAA,gBACA,MAAM,YAAY;AAChB,wBAAM,QAAQ,IAAI,SAAS,IAAI,QAAQ,KAAK,GAAG,CAAC;AAAA,gBAClD;AAAA,gBACA,MAAM,6BAA6B;AACjC,sBAAI,SAAS,OAAO;AAClB,0BAAM,iBAAiB,OAAO,WAAW,KAAK;AAAA,kBAChD,OAAO;AACL,0BAAM,cAAc,MAAM,MAAM,eAAe;AAAA,sBAC7C,EAAE,OAAO,YAAY,MAAM;AAAA,oBAC7B,CAAC;AACD,6BAAS,QAAQ,YAAY;AAAA,kBAC/B;AAAA,gBACF;AAAA,gBACA,MAAM,gBAAgB;AACpB,wBAAM,KAAK,EAAE;AACb,wBAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI;AAAA,oBACvC,GAAG;AAAA,oBACH,WAAW,KAAK,IAAI;AAAA,oBACpB,eAAe;AAAA,oBACf,WAAW,MAAM;AAAA,kBACnB,CAAC;AACD,sBAAI,kBAAkB,OAAO;AAC3B,0BAAM;AAAA,kBACR;AACA,yBAAO;AAAA,gBACT;AAAA,cACF,CAAC;AAAA,YACH;AAAA,YACA,OAAO,CAAC,MAAM;AACZ,kBAAI,aAAa,OAAO;AACtB,sBAAM;AAAA,cACR;AACA,qBAAO,IAAI,aAAa;AAAA,gBACtB,IAAI;AAAA,gBACJ,QAAQ,mBAAmB,OAAO,CAAC,CAAC;AAAA,gBACpC,OAAO;AAAA,cACT,CAAC;AAAA,YACH;AAAA,UACF,CAAC;AAAA,QACH;AAAA,QAEA,QAAQ,OAAO,SAAkC;AAC/C,gBAAMC,WAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACnD,cAAIA,oBAAmB,OAAO;AAC5B,mBAAOA;AAAA,UACT;AACA,gBAAM,YAAY,MAAM,aAAaA,SAAQ;AAC7C,cAAI,CAAC,WAAW;AACd,mBAAO,IAAI,aAAa;AAAA,cACtB,IAAI;AAAA,cACJ,QAAQ;AAAA,YACV,CAAC;AAAA,UACH;AACA,cAAI,CAACA,SAAQ,OAAO;AAClB,mBAAO,IAAI,aAAa;AAAA,cACtB,IAAI;AAAA,cACJ,QAAQ;AAAA,YACV,CAAC;AAAA,UACH;AACA,gBAAM,MAAM,OAAOA,SAAQ,KAAK;AAChC,iBAAO,IAAI,YAAY,EAAE,WAAW,UAAU,CAAC;AAAA,QACjD;AAAA,QAEA,IAAI,YAAY;AACd,gBAAM,CAAC,gBAAgB,WAAW,IAAI,MAAM,QAAQ,IAAI;AAAA,YACtD,QAAQ,QAAQ,KAAK,SAAS;AAAA,YAC9B,QAAQ,KAAK,cAAc,SAAS;AAAA,UACtC,CAAC;AAED,cAAI,0BAA0B,OAAO;AACnC,mBAAO;AAAA,UACT;AACA,cAAI,uBAAuB,OAAO;AAChC,mBAAO;AAAA,UACT;AAEA,gBAAM,WAAW,mBAAmB;AAAA,YAClC,UAAU,eAAe;AAAA,YACzB,OAAO,YAAY;AAAA,UACrB,CAAC;AAED,gBAAM,cAAc,eAAe,MAAM,GAAG,EAAE;AAC9C,gBAAM,cACJ,aAAa,SAAS,eACtB,YAAY,gBAAgB,QAC5B,YAAY,kBAAkB;AAChC,gBAAM,qBAAqB,cAAc,YAAY,KAAK;AAE1D,iBAAO,EAAE,UAAU,mBAAmB;AAAA,QACxC;AAAA,QACA,KAAK;AAAA,UACH,MAAM,YAAY;AAChB,kBAAMA,WAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACnD,gBAAIA,oBAAmB,OAAO;AAC5B,qBAAOA;AAAA,YACT;AACA,mBAAQA,SAAQ,QAAQ,CAAC;AAAA,UAC3B;AAAA,UACA,KAAK,OAAO,QAAgB;AAC1B,kBAAMA,WAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACnD,gBAAIA,oBAAmB,OAAO;AAC5B,qBAAOA;AAAA,YACT;AACA,mBAAOA,SAAQ,OAAO,GAAa;AAAA,UAGrC;AAAA,UACA,KAAK,OAAO,KAAa,UAAmB;AAC1C,kBAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI,IAAI;AAAA,cAC3C;AAAA,cACA,MAAM,EAAE,CAAC,GAAG,GAAG,MAAM;AAAA,YACvB,CAAC;AACD,gBAAI,kBAAkB,OAAO;AAC3B,qBAAO;AAAA,YACT;AACA,mBAAO;AAAA,UACT;AAAA,UACA,SAAS,OAAO,SAAkC;AAChD,kBAAM,SAAS,MAAM,QAAQ,QAAQ,IAAI,IAAI;AAAA,cAC3C;AAAA,cACA;AAAA,YACF,CAAC;AACD,gBAAI,kBAAkB,OAAO;AAC3B,qBAAO;AAAA,YACT;AACA,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,QACA,SAAS,MAAM;AAAA,QAEf,WAAW;AAAA,MACb;AAAA,IACF;AAAA,IACA;AAAA,IACA;AAAA,IACA,mBAAmB,OACjB,MACA,aAUG;AACH,YAAM,EAAE,QAAQ,MAAM,OAAO,WAAW,WAAW,UAAU,IAAI;AAEjE,YAAM,aAAa,GAAG,MAAM,IAAI,IAAI;AACpC,YAAM,UAAU,SAAS,UAAU;AACnC,UAAI,CAAC,SAAS;AACZ,eAAO;AAAA,UACL,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS,kBAAkB,UAAU;AAAA,UACvC;AAAA,QACF;AAAA,MACF;AAEA,YAAM,UAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACnD,UAAI,mBAAmB,OAAO;AAC5B,eAAO;AAAA,UACL,OAAO,EAAE,MAAM,qBAAqB,SAAS,oBAAoB;AAAA,QACnE;AAAA,MACF;AAEA,UAAI,CAAC,QAAQ,aAAa,QAAQ,cAAc,WAAW;AACzD,eAAO;AAAA,UACL,OAAO,EAAE,MAAM,iBAAiB,SAAS,qBAAqB;AAAA,QAChE;AAAA,MACF;AAEA,YAAM,UAAU,MAAM,QAAQ,QAAQ,IAAI,SAAS;AACnD,UAAI,mBAAmB,OAAO;AAC5B,eAAO;AAAA,UACL,OAAO,EAAE,MAAM,qBAAqB,SAAS,oBAAoB;AAAA,QACnE;AAAA,MACF;AAEA,YAAM,aAAa,QAAQ;AAC3B,YAAM,gBAAgB,aAAa,MAAiC;AACpE,YAAM,UAAW,eAAe,WAAW,CAAC;AAE5C,UAAI;AACF,cAAM,SAAS,MAAM,QAAQ,EAAE,OAAO,SAAS,KAAK,CAAC;AACrD,eAAO,EAAE,OAAO;AAAA,MAClB,SAAS,GAAG;AACV,eAAO;AAAA,UACL,OAAO;AAAA,YACL,MAAM;AAAA,YACN,SAAS,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC;AAAA,UACpD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
  "names": ["mcp", "session"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/client.ts", "../src/rpc-dispatch.ts", "../src/utils/message.ts"],
  "sourcesContent": ["import type {\n  GatewayModelId,\n  InferToolInput,\n  InferUITools,\n  ModelMessage,\n  ToolSet,\n  UIDataTypes,\n  UIMessage,\n  UIMessageChunk,\n} from \"ai\";\nimport { all } from \"better-all\";\nimport * as errore from \"errore\";\nimport equal from \"fast-deep-equal\";\nimport { ulid } from \"ulid\";\nimport { getRun, start } from \"workflow/api\";\nimport type { z } from \"zod\";\nimport {\n  type AgentInput,\n  type AgentMessageInput,\n  agentMessageHook,\n  agentWorkflow,\n  approvalHook,\n} from \"./agent-workflow\";\nimport {\n  SandboxNotFoundError,\n  SessionError,\n  SessionNotFoundError,\n} from \"./errors\";\nimport type { GenerationOptions } from \"./generation\";\nimport {\n  type DispatchContext,\n  dispatch,\n  type HookToolAfterParams,\n  type HookToolAfterResult,\n  type HookToolBeforeParams,\n  type HookToolBeforeResult,\n  type ToolMetadata,\n  type ToolsExecuteParams,\n  type ToolsNeedsApprovalParams,\n  type ToolsNeedsApprovalResult,\n} from \"./rpc-dispatch\";\nimport { getSandbox } from \"./sandbox\";\nimport { normalizeSkillsDirs } from \"./skills/parser\";\nimport type { SkillsDir } from \"./skills/types\";\nimport {\n  type Storage as AgentStorage,\n  DEFAULT_NAMESPACE,\n  getStorage,\n  LOCAL_STORAGE_VERSION,\n  type Message,\n  type Part,\n  type SandboxConfig,\n  type Session,\n  type StorageConfig,\n  type Handlers as StorageHandlers,\n  type StorageMethods,\n} from \"./storage\";\nimport { type BuiltInToolName, builtInTools, type ToolContext } from \"./tools\";\nimport { toMessageAndParts } from \"./utils/message\";\nimport { assembleUIMessages } from \"./utils/ui\";\nimport { computeSessionUsage, type SessionUsage } from \"./utils/usage\";\n\nexport type SendInput =\n  | string\n  | { role?: UIMessage[\"role\"]; parts: UIMessage[\"parts\"]; id?: string };\n\n/**\n * Infer a typed UIMessage from an agent instance.\n * Tool parts are discriminated by `type: \"tool-${name}\"` with typed input/output.\n *\n * @example\n * ```ts\n * const myAgent = agent({ tools: { myTool: tool({...}) } });\n * type MyMessage = InferUIMessage<typeof myAgent>;\n * // MyMessage.parts includes { type: \"tool-myTool\"; input: MyInput; output: MyOutput; ... }\n * ```\n */\nexport type InferUIMessage<A> = A extends { tools: infer T extends ToolSet }\n  ? UIMessage<unknown, UIDataTypes, InferUITools<T>>\n  : UIMessage;\n\ntype ToolName<Tools> = Extract<keyof Tools, string> | BuiltInToolName;\n\ntype ToolInput<Tools, K> = K extends BuiltInToolName\n  ? InferToolInput<(typeof builtInTools)[K]>\n  : K extends keyof Tools\n    ? Tools[K] extends import(\"ai\").Tool\n      ? InferToolInput<Tools[K]>\n      : unknown\n    : unknown;\n\nexport type NeedsApprovalMap<Tools> = {\n  [K in ToolName<Tools>]?:\n    | boolean\n    | ((\n        input: ToolInput<Tools, K>,\n        options: {\n          toolCallId: string;\n          messages: ModelMessage[];\n          experimental_context: unknown;\n        }\n      ) => boolean | Promise<boolean>);\n};\n\n/**\n * Options that can be set per-session, overriding agent-level defaults.\n */\nexport type SessionOptions<\n  Tools extends ToolSet,\n  TTags extends Record<string, unknown> = Record<string, never>,\n> = {\n  /** The AI model to use. */\n  model?: GatewayModelId;\n  /** System prompt for the AI model. */\n  system?: string;\n  /** Sandbox configuration or ID. If string, uses as sandbox ID with its config. */\n  sandbox?: SandboxConfig | string;\n  /** Key-value metadata tags for the session. */\n  tags?: TTags;\n  /** Directory containing skill definitions for the agent. */\n  skillsDir?: SkillsDir;\n  /**\n   * Names of tools to activate for this session.\n   * If not specified, all agent-level tools are active.\n   * Use this to restrict which tools are available per-session.\n   */\n  activeTools?: (Extract<keyof Tools, string> | BuiltInToolName)[];\n  /** Generation options (temperature, maxSteps, etc.). Overrides agent-level defaults. */\n  generation?: GenerationOptions;\n};\n\n/**\n * Configuration options for creating an agent instance.\n *\n * @example\n * ```ts\n * const myAgent = agent({\n *   model: \"anthropic/claude-opus-4.5\",\n *   system: \"You are a helpful assistant...\",\n *   tagsSchema: z.object({ userId: z.string() }),\n *   contextSchema: z.object({ authToken: z.string() }),\n * });\n * ```\n */\nexport type AgentOptions<\n  Tools extends ToolSet,\n  TTags extends Record<string, unknown> = Record<string, never>,\n  TContext extends Record<string, unknown> = Record<string, never>,\n> = {\n  /**\n   * Agent name. Used to isolate storage data - different names have separate data.\n   * @default \"default\"\n   */\n  name?: string;\n  /**\n   * Storage backend configuration.\n   * - `{ type: \"local\" }` - filesystem storage (dev)\n   * - `{ type: \"vercel\" }` - Vercel managed storage (prod)\n   * - `{ type: \"custom\", url: \"...\" }` - custom HTTP backend\n   * @default { type: \"vercel\" }\n   */\n  storage?: StorageConfig;\n  /**\n   * Custom tools available to the agent.\n   * These are exposed via the RPC handler and called over HTTP.\n   */\n  tools?: Tools;\n  /**\n   * Hooks for intercepting agent operations.\n   */\n  hooks?: AgentHooks;\n  /**\n   * Schema for session tags. All sessions share this schema.\n   * Tags are persisted in storage and survive across requests.\n   */\n  tagsSchema?: z.ZodType<TTags>;\n  /**\n   * Schema for transient tool context. Passed per-request via send().\n   * NOT persisted - use for secrets like auth tokens.\n   */\n  contextSchema?: z.ZodType<TContext>;\n  /**\n   * Approval rules for tools you don't own (built-in or third-party).\n   * Maps tool names to a boolean or a function that decides whether to ask.\n   *\n   * @example\n   * ```ts\n   * needsApproval: {\n   *   Bash: (input) => input.command.startsWith(\"rm\"),\n   *   Write: true,\n   * }\n   * ```\n   */\n  needsApproval?: NeedsApprovalMap<Tools>;\n} & Omit<SessionOptions<Tools, TTags>, \"tags\">;\n\n/**\n * Base type for session/sandbox tags. Used for generic constraints.\n * For agent-level tag validation, use `tagsSchema` option with a zod schema.\n */\nexport type TagsSchema = Record<string, unknown>;\n\n/**\n * Hooks for intercepting agent operations.\n */\nexport type AgentHooks = {\n  /** Called before a tool is executed. Can modify input or throw to block. */\n  \"tool.before\"?: (opts: {\n    name: string;\n    input: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { input: unknown }>;\n  /** Called after a tool is executed. Can modify result. */\n  \"tool.after\"?: (opts: {\n    name: string;\n    input: unknown;\n    result: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { result: unknown }>;\n};\n\n/**\n * RPC request body for agent handler.\n * Discriminated union on `method` for type-safe params.\n */\nexport type AgentRpcRequest = {\n  [K in keyof AgentRpcMethods]: {\n    method: K;\n    params: AgentRpcMethods[K][\"params\"];\n  };\n}[keyof AgentRpcMethods];\n\n/**\n * RPC response type for dispatch.\n */\nexport type RpcResult<T = unknown> =\n  | { result: T }\n  | { error: { code: string; message: string }; status?: number };\n\n/**\n * Direct RPC payload for step function calls (no HTTP).\n */\nexport type RpcPayload = {\n  name?: string;\n  method: string;\n  params: unknown;\n};\n\n/**\n * All RPC methods available on the agent handler.\n * Combines tools methods, hooks, and storage methods.\n */\nexport type AgentRpcMethods = {\n  \"tools.list\": { params: Record<string, never>; result: ToolMetadata[] };\n  \"tools.execute\": { params: ToolsExecuteParams; result: unknown };\n  \"tools.needsApproval\": {\n    params: ToolsNeedsApprovalParams;\n    result: ToolsNeedsApprovalResult;\n  };\n  \"hook.tool.before\": {\n    params: HookToolBeforeParams;\n    result: HookToolBeforeResult;\n  };\n  \"hook.tool.after\": {\n    params: HookToolAfterParams;\n    result: HookToolAfterResult;\n  };\n} & StorageMethods;\n\nexport type AgentRpcMethodName = keyof AgentRpcMethods;\n\n/**\n * Result type for RPC override handlers.\n * - `{ ok: true; result: T }` - return this result\n * - `{ ok: false; error: string }` - return this error\n * - `null` - use default handler\n */\nexport type AgentRpcResult<T> =\n  | { ok: true; result: T }\n  | { ok: false; error: string }\n  | null;\n\n/**\n * Override handlers for agent RPC methods.\n * Each method can be individually overridden.\n * Return `null` to fall back to the default handler.\n */\nexport type AgentRpcOverrides = {\n  [K in AgentRpcMethodName]?: (\n    params: AgentRpcMethods[K][\"params\"]\n  ) => Promise<AgentRpcResult<AgentRpcMethods[K][\"result\"]>>;\n};\n\nexport const agent = <\n  Tools extends {},\n  TTags extends Record<string, unknown> = Record<string, never>,\n  TContext extends Record<string, unknown> = Record<string, never>,\n>(\n  options: AgentOptions<Tools, TTags, TContext>\n) => {\n  const agentSecret = process.env.AGENT_SECRET;\n  if (!agentSecret) {\n    throw new Error(\n      \"AGENT_SECRET env var is required. Use withAgent() or set it manually.\"\n    );\n  }\n\n  const baseStorageConfig = options.storage ?? { type: \"vercel\" };\n  const storageConfig: StorageConfig = {\n    ...baseStorageConfig,\n    name: options.name ?? baseStorageConfig.name,\n  };\n\n  /**\n   * Storage is initialized lazily.\n   * Uses agentObj.rpc which is wired up by the loader calling __initAgent.\n   */\n  let _storage: AgentStorage | null = null;\n  const getStorageInstance = (): AgentStorage => {\n    if (!_storage) {\n      _storage = getStorage({\n        config: storageConfig,\n        rpc: agentObj.rpc,\n      });\n    }\n    return _storage;\n  };\n\n  /**\n   * Lazy-initialized storage handlers for local storage.\n   * Created on first storage RPC request.\n   */\n  let storageHandlersPromise: Promise<StorageHandlers> | null = null;\n  const getStorageHandlers = (name: string): Promise<StorageHandlers> => {\n    if (storageConfig.type !== \"local\") {\n      return Promise.reject(\n        new Error(\"Storage handlers only available for local storage\")\n      );\n    }\n    if (!storageHandlersPromise) {\n      storageHandlersPromise = (async () => {\n        const { join } = await import(\"node:path\");\n        const { createFilesystemHandlers } = await import(\n          \"./storage/bindings/local-fs-handlers\"\n        );\n        const basePath = storageConfig.path ?? \".agent-storage\";\n        const fullPath = join(basePath, name, LOCAL_STORAGE_VERSION);\n        return createFilesystemHandlers(fullPath);\n      })();\n    }\n    return storageHandlersPromise;\n  };\n\n  const sandbox = async (\n    sandboxId: string,\n    opts?: { config?: SandboxConfig; tags?: TTags }\n  ) => {\n    const existingRecord = await getStorageInstance().sandbox.get(sandboxId);\n\n    if (existingRecord instanceof Error) {\n      if (!(existingRecord instanceof SandboxNotFoundError)) {\n        throw existingRecord;\n      }\n      const sandboxRecord = await getStorageInstance().sandbox.set({\n        id: sandboxId,\n        tags: opts?.tags ?? null,\n        acquiringLockAt: null,\n        acquiringLockId: null,\n        createdAt: Date.now(),\n        lastActivityAt: Date.now(),\n        config: opts?.config ??\n          (typeof options.sandbox === \"string\"\n            ? undefined\n            : options.sandbox) ?? { type: \"vercel\" },\n      });\n      if (sandboxRecord instanceof Error) {\n        throw sandboxRecord;\n      }\n      return getSandbox<TTags>({\n        storageConfig,\n        sandboxRecord,\n        storage: getStorageInstance(),\n        rpc: agentObj.rpc,\n      });\n    }\n\n    const newConfig = opts?.config ?? existingRecord.config;\n    if (!equal(existingRecord.config, newConfig)) {\n      // throw new SandboxError({\n      //   reason: \"sandbox config changes are not supported\",\n      // });\n      console.warn(\"sandbox config changes are not supported\");\n    }\n\n    return getSandbox<TTags>({\n      storageConfig,\n      sandboxRecord: existingRecord,\n      storage: getStorageInstance(),\n      rpc: agentObj.rpc,\n    });\n  };\n\n  const agentObj = {\n    session: async (\n      sessionId: string,\n      sessionOptions?: SessionOptions<Tools, TTags>\n    ) => {\n      let session = await getStorageInstance().session.get(sessionId);\n\n      /**\n       * normalize sandbox input to a sandbox ID and config\n       */\n      const sandboxInput = sessionOptions?.sandbox ?? options.sandbox;\n      const sandboxId =\n        typeof sandboxInput === \"string\"\n          ? sandboxInput\n          : // biome-ignore lint/style/noNestedTernary: ok\n            session instanceof Error\n            ? `sandbox_${ulid()}`\n            : (session.sandboxId ?? `sandbox_${ulid()}`);\n      const sandboxPromise = sandbox(\n        sandboxId,\n        typeof sandboxInput === \"string\" ? undefined : { config: sandboxInput }\n      );\n\n      const existingSession = session instanceof Error ? null : session;\n      const skillsDir =\n        sessionOptions?.skillsDir ??\n        existingSession?.skillsDir ??\n        options.skillsDir ??\n        null;\n\n      if (session instanceof Error) {\n        if (session instanceof SessionNotFoundError) {\n          const model = sessionOptions?.model ?? options.model ?? null;\n          if (!model) {\n            throw new SessionError({\n              id: sessionId,\n              reason: \"Model is not set\",\n            });\n          }\n          session = await getStorageInstance().session.set({\n            id: sessionId,\n            createdAt: Date.now(),\n            updatedAt: Date.now(),\n            lastMessageId: null,\n            runId: null,\n            tags: sessionOptions?.tags ?? null,\n            system: sessionOptions?.system ?? options.system ?? null,\n            model,\n            sandboxId,\n            skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,\n            hookToken: null,\n            activeTools:\n              sessionOptions?.activeTools ?? options.activeTools ?? null,\n            generation:\n              options.generation || sessionOptions?.generation\n                ? { ...options.generation, ...sessionOptions?.generation }\n                : null,\n          });\n        } else {\n          throw session;\n        }\n      } else {\n        /**\n         * this is an existing session. we compare the options and update the session if necessary.\n         */\n        const updated: Session = {\n          ...session,\n          ...sessionOptions,\n          sandboxId,\n          skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,\n        };\n        if (!equal(updated, session)) {\n          session = await getStorageInstance().session.set(updated);\n          if (session instanceof Error) {\n            throw session;\n          }\n        }\n      }\n\n      /**\n       * Interrupts all pending assistant messages (both streaming and queued).\n       * A message is considered pending if completedAt === null && interruptedAt === null.\n       */\n      const interruptCurrentMessage = async () => {\n        const messagesResult =\n          await getStorageInstance().message.list(sessionId);\n        if (messagesResult instanceof Error) {\n          return messagesResult;\n        }\n\n        const now = Date.now();\n        const pendingAssistantMessages = messagesResult.items.filter(\n          (m) =>\n            m.role === \"assistant\" &&\n            m.completedAt === null &&\n            m.interruptedAt === null\n        );\n\n        const results = await Promise.all(\n          pendingAssistantMessages.map((m) =>\n            getStorageInstance().message.set({ ...m, interruptedAt: now })\n          )\n        );\n\n        for (const result of results) {\n          if (result instanceof Error) {\n            return result;\n          }\n        }\n\n        // Auto-reject any pending approval hooks so the workflow unblocks\n        for (const m of pendingAssistantMessages) {\n          const partsResult = await getStorageInstance().part.listByMessage(\n            m.id\n          );\n          if (partsResult instanceof Error) {\n            continue;\n          }\n          for (const p of partsResult.items) {\n            if (\n              p.part &&\n              \"state\" in p.part &&\n              (p.part as { state: string }).state === \"approval-requested\" &&\n              \"approval\" in p.part\n            ) {\n              const approval = (p.part as { approval?: { id: string } })\n                .approval;\n              if (approval?.id) {\n                await getStorageInstance().part.set({\n                  ...p,\n                  part: {\n                    ...p.part,\n                    state: \"approval-responded\",\n                    approval: {\n                      ...approval,\n                      approved: false,\n                      reason: \"interrupted\",\n                    },\n                  },\n                } as Part);\n                await approvalHook.resume(approval.id, {\n                  approved: false,\n                  reason: \"interrupted\",\n                });\n              }\n            }\n          }\n        }\n\n        return undefined;\n      };\n\n      return {\n        send: async ({\n          input,\n          interruptIfStreaming,\n          context,\n        }: {\n          input: SendInput | SendInput[];\n          interruptIfStreaming?: boolean;\n          context?: TContext;\n        }) => {\n          if (interruptIfStreaming) {\n            const interruptResult = await interruptCurrentMessage();\n            if (interruptResult instanceof Error) {\n              return interruptResult;\n            }\n          }\n          const newMessages: Message[] = [];\n          const newParts: Part[] = [];\n          if (Array.isArray(input)) {\n            for (const i of input) {\n              const { message, parts } = toMessageAndParts({\n                sessionId,\n                input: i,\n                defaultRole: \"user\",\n              });\n\n              newMessages.push(message);\n              newParts.push(...parts);\n            }\n          } else {\n            const { message, parts } = toMessageAndParts({\n              sessionId,\n              input,\n              defaultRole: \"user\",\n            });\n            newMessages.push(message);\n            newParts.push(...parts);\n          }\n          /**\n           * we also pre-create the assistant message\n           */\n          const assistantMessageId = `message_${ulid()}`;\n          const baseTime = Date.now();\n          const assistantMessageCreatedAt = baseTime + newMessages.length;\n          newMessages.push({\n            id: assistantMessageId,\n            sessionId,\n            role: \"assistant\",\n            createdAt: assistantMessageCreatedAt,\n            startedAt: null,\n            completedAt: null,\n            interruptedAt: null,\n            usage: null,\n          });\n\n          const session2 = await getStorageInstance().session.get(sessionId);\n          if (session2 instanceof Error) {\n            throw session2;\n          }\n\n          const agentInput: AgentInput = {\n            storageConfig,\n            sessionId,\n            rpc: agentObj.rpc,\n          };\n          const event: AgentMessageInput = {\n            assistantMessageId,\n            hookToken: crypto.randomUUID(),\n            createdAt: assistantMessageCreatedAt,\n            context: context ?? {},\n          };\n\n          return await errore.tryAsync({\n            try: async () => {\n              await all({\n                async saveMessages() {\n                  await Promise.all(\n                    newMessages.map((m, i) =>\n                      getStorageInstance().message.set({\n                        ...m,\n                        createdAt: baseTime + i,\n                      })\n                    )\n                  );\n                },\n                async saveParts() {\n                  await Promise.all(\n                    newParts.map(getStorageInstance().part.set)\n                  );\n                },\n                async resumeOrStartAgentWorkflow() {\n                  if (session2.runId) {\n                    await agentMessageHook.resume(sessionId, event);\n                  } else {\n                    const startResult = await start(agentWorkflow, [\n                      { input: agentInput, event },\n                    ]);\n                    session2.runId = startResult.runId;\n                  }\n                },\n                async updateSession() {\n                  await this.$.resumeOrStartAgentWorkflow;\n                  const result = await getStorageInstance().session.set({\n                    ...session2,\n                    updatedAt: Date.now(),\n                    lastMessageId: assistantMessageId,\n                    hookToken: event.hookToken,\n                  });\n                  if (result instanceof Error) {\n                    throw result;\n                  }\n                  return result;\n                },\n              });\n            },\n            catch: (e) => {\n              if (e instanceof Error) {\n                throw e;\n              }\n              return new SessionError({\n                id: sessionId,\n                reason: `failed to send: ${String(e)}`,\n                cause: e,\n              });\n            },\n          });\n        },\n\n        stream: async (opts?: { messageId?: string }) => {\n          const session = await getStorageInstance().session.get(sessionId);\n          if (session instanceof Error) {\n            return session;\n          }\n          const messageId = opts?.messageId ?? session.lastMessageId;\n          if (!messageId) {\n            return new SessionError({\n              id: sessionId,\n              reason: \"No message associated with session\",\n            });\n          }\n          if (!session.runId) {\n            return new SessionError({\n              id: sessionId,\n              reason: \"No run associated with session\",\n            });\n          }\n          const run = getRun(session.runId);\n          return run.getReadable<UIMessageChunk>({ namespace: messageId });\n        },\n\n        ui: async () => {\n          const [messagesResult, partsResult] = await Promise.all([\n            getStorageInstance().message.list(sessionId),\n            getStorageInstance().part.listBySession(sessionId),\n          ]);\n\n          if (messagesResult instanceof Error) {\n            return messagesResult;\n          }\n          if (partsResult instanceof Error) {\n            return partsResult;\n          }\n\n          const messages = assembleUIMessages({\n            messages: messagesResult.items,\n            parts: partsResult.items,\n          });\n\n          const lastStartedAssistant = messagesResult.items\n            .filter((m) => m.role === \"assistant\" && m.startedAt !== null)\n            .at(-1);\n          const isStreaming =\n            lastStartedAssistant &&\n            lastStartedAssistant.completedAt === null &&\n            lastStartedAssistant.interruptedAt === null;\n          const streamingMessageId = isStreaming\n            ? lastStartedAssistant.id\n            : null;\n\n          const usage = computeSessionUsage(messagesResult.items);\n\n          type TypedMessage = UIMessage<\n            unknown,\n            UIDataTypes,\n            InferUITools<typeof builtInTools & Tools>\n          >;\n          return {\n            messages: messages as unknown as TypedMessage[],\n            streamingMessageId,\n            usage,\n          };\n        },\n        tag: {\n          list: async () => {\n            const session = await getStorageInstance().session.get(sessionId);\n            if (session instanceof Error) {\n              return session;\n            }\n            return (session.tags ?? {}) as TTags;\n          },\n          get: async <K extends keyof TTags & string>(\n            key: K\n          ): Promise<TTags[K] | undefined | Error> => {\n            const session = await getStorageInstance().session.get(sessionId);\n            if (session instanceof Error) {\n              return session;\n            }\n            return session.tags?.[key] as TTags[K] | undefined;\n          },\n          set: async <K extends keyof TTags & string>(\n            key: K,\n            value: TTags[K]\n          ): Promise<undefined | Error> => {\n            const result = await getStorageInstance().session.tag.set({\n              sessionId,\n              tags: { [key]: value } as Record<string, unknown>,\n            });\n            if (result instanceof Error) {\n              return result;\n            }\n            return undefined;\n          },\n          setMany: async (tags: Partial<TTags>): Promise<undefined | Error> => {\n            const result = await getStorageInstance().session.tag.set({\n              sessionId,\n              tags: tags as Record<string, unknown>,\n            });\n            if (result instanceof Error) {\n              return result;\n            }\n            return undefined;\n          },\n        },\n        sandbox: await sandboxPromise,\n\n        interrupt: interruptCurrentMessage,\n\n        resolveApproval: async ({\n          approvalId,\n          approved,\n          reason,\n        }: {\n          approvalId: string;\n          approved: boolean;\n          reason?: string;\n        }): Promise<undefined | Error> => {\n          const partsResult =\n            await getStorageInstance().part.listBySession(sessionId);\n          if (partsResult instanceof Error) {\n            return partsResult;\n          }\n\n          const targetPart = partsResult.items.find(\n            (p) =>\n              p.part &&\n              \"approval\" in p.part &&\n              (p.part as { approval?: { id: string } }).approval?.id ===\n                approvalId\n          );\n          if (!targetPart) {\n            return new SessionError({\n              id: sessionId,\n              reason: `Approval ${approvalId} not found`,\n            });\n          }\n\n          const updatedPart = {\n            ...targetPart,\n            part: {\n              ...targetPart.part,\n              state: \"approval-responded\" as const,\n              approval: { id: approvalId, approved, reason },\n            },\n          };\n          const setResult = await getStorageInstance().part.set(\n            updatedPart as Part\n          );\n          if (setResult instanceof Error) {\n            return setResult;\n          }\n\n          // Fire the approval hook to resume the suspended workflow.\n          // For sub-tool approvals (from the JavaScript tool), there's no\n          // suspended hook \u2014 polling handles it. Swallow the error.\n          try {\n            await approvalHook.resume(approvalId, { approved, reason });\n          } catch {\n            // No hook registered for this approvalId (e.g. JS sub-tool approval)\n          }\n\n          return undefined;\n        },\n\n        usage: async (): Promise<SessionUsage | Error> => {\n          const messagesResult =\n            await getStorageInstance().message.list(sessionId);\n          if (messagesResult instanceof Error) {\n            return messagesResult;\n          }\n          return computeSessionUsage(messagesResult.items);\n        },\n      };\n    },\n    sandbox,\n    get storage() {\n      return getStorageInstance();\n    },\n\n    /**\n     * RPC handler for agent operations.\n     * Handles tools.list, tools.execute, storage RPC, and hooks.\n     *\n     * Called internally by the `rpc` step function during workflow execution.\n     * Can also be exposed via HTTP for external access if needed.\n     */\n    handler: async (\n      input: Request | RpcPayload,\n      overrides?: AgentRpcOverrides\n    ): Promise<Response | RpcResult> => {\n      const isRequest = input instanceof Request;\n\n      let method: string;\n      let params: unknown;\n      let name: string;\n\n      if (isRequest) {\n        const secret = input.headers.get(\"x-agent-secret\");\n        if (secret !== agentSecret) {\n          return Response.json(\n            { error: { code: \"UNAUTHORIZED\", message: \"Invalid secret\" } },\n            { status: 401 }\n          );\n        }\n\n        let body: AgentRpcRequest;\n        try {\n          body = await input.json();\n        } catch {\n          return Response.json(\n            {\n              error: { code: \"INVALID_REQUEST\", message: \"Invalid JSON body\" },\n            },\n            { status: 400 }\n          );\n        }\n\n        method = body.method;\n        params = body.params;\n        name = input.headers.get(\"x-agent-name\") ?? DEFAULT_NAMESPACE;\n      } else {\n        method = input.method;\n        params = input.params;\n        name = input.name ?? DEFAULT_NAMESPACE;\n      }\n\n      const dispatchContext: DispatchContext = {\n        tools: options.tools as ToolSet | undefined,\n        hooks: options.hooks,\n        needsApproval:\n          options.needsApproval as DispatchContext[\"needsApproval\"],\n        storageConfig,\n        getStorageInstance,\n        getStorageHandlers,\n        rpc: agentObj.rpc,\n        overrides,\n      };\n\n      const result = await dispatch(method, params, dispatchContext, name);\n\n      if (!isRequest) {\n        return result;\n      }\n\n      const status = \"error\" in result ? (result.status ?? 500) : 200;\n      return Response.json(\n        \"error\" in result ? { error: result.error } : { result: result.result },\n        { status }\n      );\n    },\n\n    tools: { ...builtInTools, ...options.tools } as typeof builtInTools & Tools,\n\n    rpc: (() => {\n      throw new Error(\n        \"rpc not configured. Ensure withAgent is set up in next.config.ts\"\n      );\n    }) as (params: RpcPayload) => Promise<RpcResult>,\n  };\n\n  return agentObj;\n};\n", "import type { JSONSchema7, Tool, ToolSet } from \"ai\";\nimport { z } from \"zod\";\nimport type { AgentRpcOverrides, AgentRpcResult, RpcResult } from \"./client\";\nimport { getSandbox } from \"./sandbox\";\nimport type {\n  Storage as AgentStorage,\n  MethodName,\n  RpcFn,\n  RpcRequest,\n  RpcResponse,\n  SandboxRecord,\n  Session,\n  StorageConfig,\n  Handlers as StorageHandlers,\n} from \"./storage\";\nimport { STORAGE_RPC_METHODS } from \"./storage\";\nimport { resolveApiUrl, type ToolContext } from \"./tools\";\n\nexport type ToolMetadata = {\n  name: string;\n  description?: string;\n  inputSchema?: JSONSchema7;\n};\n\nexport type ToolsExecuteParams = {\n  name: string;\n  input: unknown;\n  session: Session;\n  sandboxRecord: SandboxRecord;\n  context: Record<string, unknown>;\n};\n\nexport type HookToolBeforeParams = {\n  name: string;\n  input: unknown;\n  context: ToolContext;\n};\n\nexport type HookToolBeforeResult = {\n  input?: unknown;\n  stop?: boolean;\n};\n\nexport type HookToolAfterParams = {\n  name: string;\n  input: unknown;\n  result: unknown;\n  context: ToolContext;\n};\n\nexport type HookToolAfterResult = {\n  result?: unknown;\n  stop?: boolean;\n};\n\nexport type ToolsNeedsApprovalParams = {\n  toolName: string;\n  input: unknown;\n  toolCallId: string;\n  messages: unknown[];\n};\n\nexport type ToolsNeedsApprovalResult = boolean;\n\ntype AgentHooks = {\n  \"tool.before\"?: (opts: {\n    name: string;\n    input: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { input: unknown }>;\n  \"tool.after\"?: (opts: {\n    name: string;\n    input: unknown;\n    result: unknown;\n    context: ToolContext;\n  }) => Promise<undefined | { result: unknown }>;\n};\n\ntype NeedsApprovalEntry =\n  | boolean\n  | ((\n      input: unknown,\n      options: {\n        toolCallId: string;\n        messages: unknown[];\n        experimental_context: unknown;\n      }\n    ) => boolean | Promise<boolean>);\n\nexport type DispatchContext = {\n  tools: ToolSet | undefined;\n  hooks: AgentHooks | undefined;\n  needsApproval: Record<string, NeedsApprovalEntry> | undefined;\n  storageConfig: StorageConfig;\n  getStorageInstance: () => AgentStorage;\n  getStorageHandlers: (name: string) => Promise<StorageHandlers>;\n  rpc: RpcFn;\n  overrides?: AgentRpcOverrides;\n};\n\n/**\n * Converts an override result to RpcResult, or null to fall through.\n */\nfunction handleOverrideResult<T>(res: AgentRpcResult<T>): RpcResult<T> | null {\n  if (res === null) {\n    return null;\n  }\n  if (res.ok) {\n    return { result: res.result };\n  }\n  return {\n    error: { code: \"HANDLER_ERROR\", message: res.error },\n    status: 400,\n  };\n}\n\n/**\n * Internal dispatch function. Returns RpcResult, not Response.\n * Enables recursive calls for hooks without JSON round-trips.\n */\nexport async function dispatch(\n  method: string,\n  params: unknown,\n  context: DispatchContext,\n  name?: string\n): Promise<RpcResult> {\n  const {\n    tools,\n    hooks,\n    needsApproval,\n    storageConfig,\n    getStorageInstance,\n    getStorageHandlers,\n    rpc,\n    overrides,\n  } = context;\n\n  switch (method) {\n    case \"tools.list\": {\n      const defaultHandler = (): RpcResult<ToolMetadata[]> => {\n        const toolsMap = tools ?? ({} as ToolSet);\n        const result = Object.entries(toolsMap).map(([name, t]) => ({\n          name,\n          description: (t as Tool).description,\n          inputSchema: schemaToJsonSchema((t as Tool).inputSchema),\n        }));\n        return { result };\n      };\n\n      const override = overrides?.[\"tools.list\"];\n\n      try {\n        const overrideResult = await override?.({});\n        if (overrideResult) {\n          const handled = handleOverrideResult(overrideResult);\n          if (handled) {\n            return handled;\n          }\n        }\n        return defaultHandler();\n      } catch (e) {\n        return {\n          error: {\n            code: \"HANDLER_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n\n    case \"tools.needsApproval\": {\n      const p = params as ToolsNeedsApprovalParams;\n\n      const defaultHandler = async (): Promise<RpcResult<boolean>> => {\n        // 1. Per-tool needsApproval on custom tools takes priority\n        const toolsMap = tools ?? ({} as ToolSet);\n        const toolDef = toolsMap[p.toolName] as Tool | undefined;\n        if (toolDef?.needsApproval != null) {\n          if (typeof toolDef.needsApproval === \"boolean\") {\n            return { result: toolDef.needsApproval };\n          }\n          const result = await toolDef.needsApproval(p.input, {\n            toolCallId: p.toolCallId,\n            messages: p.messages as never[],\n            experimental_context: undefined,\n          });\n          return { result };\n        }\n\n        // 2. Agent-level needsApproval map\n        if (!needsApproval) {\n          return { result: false };\n        }\n        const entry = needsApproval[p.toolName];\n        if (entry == null) {\n          return { result: false };\n        }\n        if (typeof entry === \"boolean\") {\n          return { result: entry };\n        }\n        const result = await entry(p.input, {\n          toolCallId: p.toolCallId,\n          messages: p.messages,\n          experimental_context: undefined,\n        });\n        return { result };\n      };\n\n      const override = overrides?.[\"tools.needsApproval\"];\n\n      try {\n        const overrideResult = await override?.(p);\n        if (overrideResult) {\n          const handled = handleOverrideResult(overrideResult);\n          if (handled) {\n            return handled;\n          }\n        }\n        return await defaultHandler();\n      } catch (e) {\n        return {\n          error: {\n            code: \"NEEDS_APPROVAL_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n\n    case \"hook.tool.before\": {\n      const p = params as HookToolBeforeParams;\n\n      const defaultHandler = async (\n        hookParams: HookToolBeforeParams\n      ): Promise<HookToolBeforeResult> => {\n        if (!hooks?.[\"tool.before\"]) {\n          return {};\n        }\n        const hookResult = await hooks[\"tool.before\"](hookParams);\n        return hookResult ?? {};\n      };\n\n      const override = overrides?.[\"hook.tool.before\"];\n\n      try {\n        let currentParams = p;\n        let merged: HookToolBeforeResult = {};\n\n        const overrideResult = await override?.(p);\n        if (overrideResult?.ok) {\n          merged = { ...merged, ...overrideResult.result };\n          if (merged.stop) {\n            return { result: merged };\n          }\n          if (overrideResult.result.input !== undefined) {\n            currentParams = {\n              ...currentParams,\n              input: overrideResult.result.input,\n            };\n          }\n        }\n\n        const defaultResult = await defaultHandler(currentParams);\n        merged = { ...merged, ...defaultResult };\n\n        return { result: merged };\n      } catch (e) {\n        return {\n          error: {\n            code: \"HOOK_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n\n    case \"hook.tool.after\": {\n      const p = params as HookToolAfterParams;\n\n      const defaultHandler = async (\n        hookParams: HookToolAfterParams\n      ): Promise<HookToolAfterResult> => {\n        if (!hooks?.[\"tool.after\"]) {\n          return {};\n        }\n        const hookResult = await hooks[\"tool.after\"](hookParams);\n        return hookResult ?? {};\n      };\n\n      const override = overrides?.[\"hook.tool.after\"];\n\n      try {\n        let currentParams = p;\n        let merged: HookToolAfterResult = {};\n\n        const overrideResult = await override?.(p);\n        if (overrideResult?.ok) {\n          merged = { ...merged, ...overrideResult.result };\n          if (merged.stop) {\n            return { result: merged };\n          }\n          if (overrideResult.result.result !== undefined) {\n            currentParams = {\n              ...currentParams,\n              result: overrideResult.result.result,\n            };\n          }\n        }\n\n        const defaultResult = await defaultHandler(currentParams);\n        merged = { ...merged, ...defaultResult };\n\n        return { result: merged };\n      } catch (e) {\n        return {\n          error: {\n            code: \"HOOK_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n\n    case \"tools.execute\": {\n      const p = params as ToolsExecuteParams;\n\n      const defaultHandler = async (): Promise<RpcResult> => {\n        const toolsMap = tools ?? ({} as ToolSet);\n        const toolDef = toolsMap[p.name as keyof typeof toolsMap];\n        if (!toolDef) {\n          return {\n            error: {\n              code: \"TOOL_NOT_FOUND\",\n              message: `Unknown tool: ${p.name}`,\n            },\n            status: 400,\n          };\n        }\n\n        const execute = (toolDef as Tool).execute;\n        if (!execute) {\n          return {\n            error: {\n              code: \"NO_EXECUTE\",\n              message: `Tool ${p.name} has no execute function`,\n            },\n            status: 400,\n          };\n        }\n\n        const sandboxInstance = getSandbox({\n          sandboxRecord: p.sandboxRecord,\n          storageConfig,\n          storage: getStorageInstance(),\n          rpc,\n        });\n\n        const toolContext: ToolContext = {\n          session: p.session,\n          sandbox: sandboxInstance,\n          storage: getStorageInstance(),\n          context: p.context,\n        };\n\n        let toolInput = p.input;\n\n        const beforeResult = await dispatch(\n          \"hook.tool.before\",\n          {\n            name: p.name,\n            input: toolInput,\n            context: toolContext,\n          },\n          context,\n          name\n        );\n        if (\"error\" in beforeResult) {\n          return beforeResult;\n        }\n        const beforeHook = beforeResult.result as HookToolBeforeResult;\n        if (beforeHook.stop) {\n          return {\n            error: {\n              code: \"HOOK_STOPPED\",\n              message: \"tool.before hook stopped execution\",\n            },\n            status: 400,\n          };\n        }\n        if (beforeHook.input !== undefined) {\n          toolInput = beforeHook.input;\n        }\n\n        let result = await execute(toolInput as never, {\n          experimental_context: toolContext,\n          toolCallId: \"rpc\",\n          messages: [],\n        });\n\n        const afterResult = await dispatch(\n          \"hook.tool.after\",\n          {\n            name: p.name,\n            input: toolInput,\n            result,\n            context: toolContext,\n          },\n          context,\n          name\n        );\n        if (\"error\" in afterResult) {\n          return afterResult;\n        }\n        const afterHook = afterResult.result as HookToolAfterResult;\n        if (afterHook.stop) {\n          return {\n            error: {\n              code: \"HOOK_STOPPED\",\n              message: \"tool.after hook stopped execution\",\n            },\n            status: 400,\n          };\n        }\n        if (afterHook.result !== undefined) {\n          result = afterHook.result;\n        }\n\n        return { result };\n      };\n\n      const override = overrides?.[\"tools.execute\"];\n\n      try {\n        const overrideResult = await override?.(p);\n        if (overrideResult) {\n          const handled = handleOverrideResult(overrideResult);\n          if (handled) {\n            return handled;\n          }\n        }\n        return await defaultHandler();\n      } catch (e) {\n        return {\n          error: {\n            code: \"EXECUTE_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n\n    default: {\n      const methodName = method as MethodName;\n      if (!STORAGE_RPC_METHODS.includes(methodName)) {\n        return {\n          error: {\n            code: \"UNKNOWN_METHOD\",\n            message: `Unknown RPC method: ${method}`,\n          },\n          status: 400,\n        };\n      }\n\n      const defaultHandler = async (): Promise<RpcResult> => {\n        return await handleStorageRequest({\n          config: storageConfig,\n          request: { method, params },\n          name: name ?? storageConfig.name ?? \"default\",\n          getStorageHandlers,\n        });\n      };\n\n      const override = overrides?.[methodName] as\n        | ((params: unknown) => Promise<AgentRpcResult<unknown>>)\n        | undefined;\n\n      try {\n        const overrideResult = await override?.(params);\n        if (overrideResult) {\n          const handled = handleOverrideResult(overrideResult);\n          if (handled) {\n            return handled;\n          }\n        }\n        return await defaultHandler();\n      } catch (e) {\n        return {\n          error: {\n            code: \"STORAGE_ERROR\",\n            message: e instanceof Error ? e.message : String(e),\n          },\n          status: 500,\n        };\n      }\n    }\n  }\n}\n\n/**\n * Routes storage RPC requests based on storage config type.\n */\nasync function handleStorageRequest({\n  config,\n  request,\n  name,\n  getStorageHandlers,\n}: {\n  config: StorageConfig;\n  request: RpcRequest;\n  name: string;\n  getStorageHandlers: (name: string) => Promise<StorageHandlers>;\n}): Promise<RpcResponse> {\n  switch (config.type) {\n    case \"local\": {\n      const handlers = await getStorageHandlers(name);\n      const { handleStorageRpc } = await import(\"./storage/handler\");\n      return handleStorageRpc(request, handlers);\n    }\n    case \"vercel\": {\n      const { getVercelStorageConfig } = await import(\n        \"./storage/bindings/vercel\"\n      );\n      const resolved = await getVercelStorageConfig();\n      return await proxyStorageRequest({\n        url: resolved.url,\n        headers: { ...resolved.headers, \"x-agent-name\": name },\n        request,\n      });\n    }\n    case \"custom\": {\n      return await proxyStorageRequest({\n        url: resolveApiUrl({ api: config.url }),\n        headers: { ...config.headers, \"x-agent-name\": name },\n        request,\n      });\n    }\n    default: {\n      config satisfies never;\n      throw new Error(\n        `Unknown storage type: ${(config as { type: string }).type}`\n      );\n    }\n  }\n}\n\n/**\n * Proxies a storage RPC request to an external URL.\n */\nasync function proxyStorageRequest({\n  url,\n  headers,\n  request,\n}: {\n  url: string;\n  headers?: Record<string, string>;\n  request: RpcRequest;\n}): Promise<RpcResponse> {\n  const response = await fetch(url, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n      ...headers,\n    },\n    body: JSON.stringify(request),\n  });\n\n  if (!response.ok) {\n    return {\n      error: {\n        code: \"PROXY_ERROR\",\n        message: `Storage proxy failed: ${response.status} ${response.statusText}`,\n      },\n    };\n  }\n\n  return response.json() as Promise<RpcResponse>;\n}\n\nfunction schemaToJsonSchema(schema: unknown): JSONSchema7 | undefined {\n  if (!schema) {\n    return undefined;\n  }\n\n  if (\n    typeof schema === \"object\" &&\n    schema !== null &&\n    \"_def\" in schema &&\n    typeof (schema as z.ZodType)._def === \"object\"\n  ) {\n    return z.toJSONSchema(schema as z.ZodType) as JSONSchema7;\n  }\n\n  if (typeof schema === \"object\" && schema !== null) {\n    const s = schema as Record<string, unknown>;\n    if (Symbol.for(\"vercel.ai.schema\") in s && \"jsonSchema\" in s) {\n      return s.jsonSchema as JSONSchema7;\n    }\n  }\n\n  if (\n    typeof schema === \"object\" &&\n    schema !== null &&\n    (\"type\" in schema || \"properties\" in schema)\n  ) {\n    return schema as JSONSchema7;\n  }\n\n  return undefined;\n}\n", "import type { UIMessage } from \"ai\";\nimport { ulid } from \"ulid\";\nimport type { SendInput } from \"../client\";\nimport type { Message, Part } from \"../storage\";\n\nexport function toMessageAndParts({\n  sessionId,\n  id,\n  input,\n  defaultRole,\n}: {\n  sessionId: string;\n  id?: string;\n  input: SendInput;\n  defaultRole: UIMessage[\"role\"];\n}): { message: Message; parts: Part[] } {\n  const messageId = id ?? `message_${ulid()}`;\n  if (typeof input === \"string\") {\n    const now = Date.now();\n    return {\n      message: {\n        id: messageId,\n        sessionId,\n        role: defaultRole,\n        createdAt: now,\n        startedAt: null,\n        completedAt: null,\n        interruptedAt: null,\n        usage: null,\n      },\n      parts: [\n        {\n          sessionId,\n          messageId,\n          id: `part_${ulid()}`,\n          index: 0,\n          part: { type: \"text\", text: input },\n        },\n      ],\n    };\n  }\n  const now = Date.now();\n  return {\n    message: {\n      sessionId,\n      id: messageId,\n      createdAt: now,\n      startedAt: null,\n      completedAt: null,\n      interruptedAt: null,\n      usage: null,\n      role: input.role ?? defaultRole,\n    },\n    parts: input.parts.map((part, index) => ({\n      sessionId,\n      messageId,\n      id: `part_${ulid()}`,\n      index,\n      part,\n    })),\n  };\n}\n"],
  "mappings": "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",
  "names": ["ulid", "name", "result", "handleStorageRpc", "now", "ulid", "session"]
}
