experimental-agent 0.0.0

package/dist/index.mjs

@@ -0,0 +1,421 @@
+import "./chunk-36X6L7SK.mjs";
+import {
+  getSandbox
+} from "./chunk-JQPR6M7D.mjs";
+import {
+  agentMessageHook,
+  agentWorkflow,
+  assembleUIMessages,
+  normalizeSkillsDirs
+} from "./chunk-MR4UWCJT.mjs";
+import {
+  handleStorageRpc
+} from "./chunk-2YI7MQGZ.mjs";
+import {
+  MessageNotFoundError,
+  SandboxError,
+  SandboxNotFoundError,
+  SessionError,
+  SessionNotFoundError,
+  StorageError,
+  getStorage
+} from "./chunk-DPPQO7DA.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 { getRun, start } from "workflow/api";
+
+// src/mcp/index.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 mcp(opts) {
+  return opts;
+}
+
+// src/utils/message.ts
+function toMessageAndParts({
+  sessionId,
+  id,
+  input,
+  generateId,
+  defaultRole
+}) {
+  const messageId = id ?? generateId("message");
+  if (typeof input === "string") {
+    return {
+      message: {
+        id: messageId,
+        sessionId,
+        role: defaultRole,
+        createdAt: Date.now(),
+        completedAt: Date.now(),
+        mcpContext: null
+      },
+      parts: [
+        {
+          sessionId,
+          messageId,
+          id: generateId("part"),
+          index: 0,
+          part: { type: "text", text: input }
+        }
+      ]
+    };
+  }
+  return {
+    message: {
+      sessionId,
+      id: messageId,
+      createdAt: Date.now(),
+      completedAt: Date.now(),
+      mcpContext: null,
+      role: input.role ?? defaultRole
+    },
+    parts: input.parts.map((part, index) => ({
+      sessionId,
+      messageId,
+      id: generateId("part"),
+      index,
+      part
+    }))
+  };
+}
+
+// src/client.ts
+var agent = (options) => {
+  const storageConfig = options.storage ?? { type: "vercel" };
+  const storage = getStorage(storageConfig);
+  const generateId = options.generateId ?? ((resource) => `${resource}_${ulid()}`);
+  const sandbox = async (sandboxId, config) => {
+    const existingRecord = await storage.sandbox.get(sandboxId);
+    if (existingRecord instanceof Error) {
+      if (!(existingRecord instanceof SandboxNotFoundError)) {
+        throw existingRecord;
+      }
+      const sandboxRecord = await storage.sandbox.set({
+        id: sandboxId,
+        acquiringLockAt: null,
+        acquiringLockId: null,
+        createdAt: Date.now(),
+        lastActivityAt: Date.now(),
+        config: config ?? { type: "vercel" }
+      });
+      if (sandboxRecord instanceof Error) {
+        throw sandboxRecord;
+      }
+      return getSandbox({ storageConfig, sandboxRecord });
+    }
+    const newConfig = config ?? existingRecord.config;
+    if (!equal(existingRecord.config, newConfig)) {
+      throw new SandboxError({
+        reason: "sandbox config changes are not supported"
+      });
+    }
+    return getSandbox({ storageConfig, sandboxRecord: existingRecord });
+  };
+  return {
+    session: async (sessionId, sessionOptions) => {
+      let session = await storage.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")
+      );
+      const sandboxPromise = sandbox(
+        sandboxId,
+        typeof sandboxInput === "string" ? void 0 : sandboxInput
+      );
+      const mcpConfig = options.mcp || sessionOptions?.mcp ? { ...options.mcp, ...sessionOptions?.mcp } : null;
+      const skillsDir = sessionOptions?.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({
+              id: sessionId,
+              reason: "Model is not set"
+            });
+          }
+          session = await storage.session.set({
+            id: sessionId,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            lastMessageId: null,
+            runId: null,
+            tags: sessionOptions?.tags ?? null,
+            instructions,
+            model,
+            mcp: mcpConfig ? serializeMcpConfig(mcpConfig) : null,
+            sandboxId,
+            skillsDir: skillsDir ? normalizeSkillsDirs(skillsDir) : null,
+            hookToken: null
+          });
+        } else {
+          throw session;
+        }
+      } else {
+        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);
+          if (session instanceof Error) {
+            throw session;
+          }
+        }
+      }
+      return {
+        send: async ({
+          input,
+          mcpContext
+        }) => {
+          const newMessages = [];
+          const newParts = [];
+          if (Array.isArray(input)) {
+            for (const i of input) {
+              const { message, parts } = toMessageAndParts({
+                sessionId,
+                input: i,
+                defaultRole: "user",
+                generateId: () => generateId("message")
+              });
+              newMessages.push(message);
+              newParts.push(...parts);
+            }
+          } else {
+            const { message, parts } = toMessageAndParts({
+              sessionId,
+              input,
+              defaultRole: "user",
+              generateId: () => generateId("message")
+            });
+            newMessages.push(message);
+            newParts.push(...parts);
+          }
+          const assistantMessageId = generateId("message");
+          newMessages.push({
+            id: assistantMessageId,
+            sessionId,
+            role: "assistant",
+            createdAt: Date.now(),
+            completedAt: null,
+            mcpContext
+          });
+          const now = Date.now();
+          const session2 = await storage.session.get(sessionId);
+          if (session2 instanceof Error) {
+            throw session2;
+          }
+          const agentInput = {
+            storageConfig,
+            sessionId
+          };
+          const event = {
+            assistantMessageId,
+            hookToken: crypto.randomUUID()
+          };
+          return await errore.tryAsync({
+            try: async () => {
+              await all({
+                async saveMessages() {
+                  await Promise.all(newMessages.map(storage.message.set));
+                },
+                async saveParts() {
+                  await Promise.all(newParts.map(storage.part.set));
+                },
+                async resumeOrStartAgentWorkflow() {
+                  if (session2.runId) {
+                    await agentMessageHook.resume(sessionId, event);
+                  } else {
+                    const startResult = await start(agentWorkflow, [
+                      { input: agentInput, event }
+                    ]);
+                    session2.runId = startResult.runId;
+                  }
+                },
+                async updateSession() {
+                  await this.$.resumeOrStartAgentWorkflow;
+                  const result = await storage.session.set({
+                    ...session2,
+                    updatedAt: now,
+                    lastMessageId: assistantMessageId,
+                    hookToken: event.hookToken
+                  });
+                  if (result instanceof Error) {
+                    throw result;
+                  }
+                  return result;
+                }
+              });
+            },
+            catch: (e) => {
+              if (e instanceof Error) {
+                throw e;
+              }
+              return new SessionError({
+                id: sessionId,
+                reason: `failed to send: ${String(e)}`,
+                cause: e
+              });
+            }
+          });
+        },
+        stream: async (opts) => {
+          const session2 = await storage.session.get(sessionId);
+          if (session2 instanceof Error) {
+            return session2;
+          }
+          const messageId = opts?.messageId ?? session2.lastMessageId;
+          if (!messageId) {
+            return new SessionError({
+              id: sessionId,
+              reason: "No message associated with session"
+            });
+          }
+          if (!session2.runId) {
+            return new SessionError({
+              id: sessionId,
+              reason: "No run associated with session"
+            });
+          }
+          const run = getRun(session2.runId);
+          return run.getReadable({ namespace: messageId });
+        },
+        ui: async () => {
+          const [messagesResult, partsResult] = await Promise.all([
+            storage.message.list(sessionId),
+            storage.part.listBySession(sessionId)
+          ]);
+          if (messagesResult instanceof Error) {
+            return messagesResult;
+          }
+          if (partsResult instanceof Error) {
+            return partsResult;
+          }
+          const messages = assembleUIMessages({
+            messages: messagesResult.items,
+            parts: partsResult.items
+          });
+          const lastMessage = messagesResult.items.at(-1);
+          const isStreaming = lastMessage?.role === "assistant" && lastMessage.completedAt === null;
+          const streamingMessageId = isStreaming ? lastMessage.id : null;
+          return { messages, streamingMessageId };
+        },
+        tag: {
+          list: async () => {
+            const session2 = await storage.session.get(sessionId);
+            if (session2 instanceof Error) {
+              return session2;
+            }
+            return session2.tags ?? {};
+          },
+          get: async (key) => {
+            const session2 = await storage.session.get(sessionId);
+            if (session2 instanceof Error) {
+              return session2;
+            }
+            return session2.tags?.[key];
+          },
+          set: async (key, value) => {
+            const result = await storage.session.tag.set({
+              sessionId,
+              tags: { [key]: value }
+            });
+            if (result instanceof Error) {
+              return result;
+            }
+            return void 0;
+          },
+          setMany: async (tags) => {
+            const result = await storage.session.tag.set({
+              sessionId,
+              tags
+            });
+            if (result instanceof Error) {
+              return result;
+            }
+            return void 0;
+          }
+        },
+        sandbox: await sandboxPromise
+      };
+    },
+    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" }
+        };
+      }
+      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)
+          }
+        };
+      }
+    }
+  };
+};
+export {
+  MessageNotFoundError,
+  SandboxError,
+  SandboxNotFoundError,
+  SessionNotFoundError,
+  StorageError,
+  agent,
+  handleStorageRpc,
+  mcp
+};
+//# 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\ntype 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 (sandboxId: string, config?: SandboxConfig) => {\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        acquiringLockAt: null,\n        acquiringLockId: null,\n        createdAt: Date.now(),\n        lastActivityAt: Date.now(),\n        config: config ?? { type: \"vercel\" },\n      });\n      if (sandboxRecord instanceof Error) {\n        throw sandboxRecord;\n      }\n      return getSandbox({ storageConfig, sandboxRecord });\n    }\n\n    const newConfig = 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({ 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 : sandboxInput\n      );\n\n      const mcpConfig =\n        options.mcp || sessionOptions?.mcp\n          ? { ...options.mcp, ...sessionOptions?.mcp }\n          : null;\n      const skillsDir = sessionOptions?.skillsDir ?? options.skillsDir ?? 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      return {\n        send: async ({\n          input,\n          mcpContext,\n        }: {\n          input: SendInput | SendInput[];\n          mcpContext?: McpSendOptions<TMcp & TMcpOverride>;\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            mcpContext,\n          });\n\n          const now = Date.now();\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                  await Promise.all(newMessages.map(storage.message.set));\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: 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          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    },\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        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      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": "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",
  "names": ["mcp", "session"]
}


package/dist/lifecycle-workflow-steps-6BLGTYVB.mjs

@@ -0,0 +1,20 @@
+// src/sandbox/lifecycle-workflow-steps.ts
+async function snapshotSandboxStep(input) {
+  "use step";
+  const { getStorage } = await import("./storage-QSTSE2ZB.mjs");
+  const { getSandbox } = await import("./client-FCFZYOOB.mjs");
+  const storage = getStorage(input.storageConfig);
+  const sandboxRecord = await storage.sandbox.get(input.id);
+  if (sandboxRecord instanceof Error) {
+    return sandboxRecord;
+  }
+  const sandbox = getSandbox({
+    sandboxRecord,
+    storageConfig: input.storageConfig
+  });
+  await sandbox.lifecycle?.snapshot();
+}
+export {
+  snapshotSandboxStep
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL3NhbmRib3gvbGlmZWN5Y2xlLXdvcmtmbG93LXN0ZXBzLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJpbXBvcnQgdHlwZSB7IFNhbmRib3hMaWZlY3ljbGVJbnB1dCB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzbmFwc2hvdFNhbmRib3hTdGVwKGlucHV0OiBTYW5kYm94TGlmZWN5Y2xlSW5wdXQpIHtcbiAgXCJ1c2Ugc3RlcFwiO1xuXG4gIGNvbnN0IHsgZ2V0U3RvcmFnZSB9ID0gYXdhaXQgaW1wb3J0KFwiLi4vc3RvcmFnZVwiKTtcbiAgY29uc3QgeyBnZXRTYW5kYm94IH0gPSBhd2FpdCBpbXBvcnQoXCIuL2NsaWVudFwiKTtcblxuICBjb25zdCBzdG9yYWdlID0gZ2V0U3RvcmFnZShpbnB1dC5zdG9yYWdlQ29uZmlnKTtcbiAgY29uc3Qgc2FuZGJveFJlY29yZCA9IGF3YWl0IHN0b3JhZ2Uuc2FuZGJveC5nZXQoaW5wdXQuaWQpO1xuICBpZiAoc2FuZGJveFJlY29yZCBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgcmV0dXJuIHNhbmRib3hSZWNvcmQ7XG4gIH1cblxuICBjb25zdCBzYW5kYm94ID0gZ2V0U2FuZGJveCh7XG4gICAgc2FuZGJveFJlY29yZCxcbiAgICBzdG9yYWdlQ29uZmlnOiBpbnB1dC5zdG9yYWdlQ29uZmlnLFxuICB9KTtcblxuICBhd2FpdCBzYW5kYm94LmxpZmVjeWNsZT8uc25hcHNob3QoKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7QUFFQSxlQUFzQixvQkFBb0IsT0FBOEI7QUFDdEU7QUFFQSxRQUFNLEVBQUUsV0FBVyxJQUFJLE1BQU0sT0FBTyx3QkFBWTtBQUNoRCxRQUFNLEVBQUUsV0FBVyxJQUFJLE1BQU0sT0FBTyx1QkFBVTtBQUU5QyxRQUFNLFVBQVUsV0FBVyxNQUFNLGFBQWE7QUFDOUMsUUFBTSxnQkFBZ0IsTUFBTSxRQUFRLFFBQVEsSUFBSSxNQUFNLEVBQUU7QUFDeEQsTUFBSSx5QkFBeUIsT0FBTztBQUNsQyxXQUFPO0FBQUEsRUFDVDtBQUVBLFFBQU0sVUFBVSxXQUFXO0FBQUEsSUFDekI7QUFBQSxJQUNBLGVBQWUsTUFBTTtBQUFBLEVBQ3ZCLENBQUM7QUFFRCxRQUFNLFFBQVEsV0FBVyxTQUFTO0FBQ3BDOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lifecycle-workflow.d.mts

@@ -0,0 +1,17 @@
+import * as workflow from 'workflow';
+import { e as SandboxConfig } from './types-vRxN1Qz1.mjs';
+import { c as SandboxLifecycleInput } from './types-Lwut_0_u.mjs';
+import 'ai';
+import 'zod';
+import 'errore';
+
+type SandboxActivitySignal = {
+    type: "activity";
+    newConfig: SandboxConfig;
+};
+declare const sandboxActivityHook: workflow.TypedHook<SandboxActivitySignal, SandboxActivitySignal>;
+declare function sandboxLifecycleWorkflow({ input, }: {
+    input: SandboxLifecycleInput;
+}): Promise<void>;
+
+export { type SandboxActivitySignal, SandboxLifecycleInput, sandboxActivityHook, sandboxLifecycleWorkflow };

package/dist/lifecycle-workflow.d.ts

@@ -0,0 +1,17 @@
+import * as workflow from 'workflow';
+import { e as SandboxConfig } from './types-vRxN1Qz1.js';
+import { c as SandboxLifecycleInput } from './types-ctZeJ3iQ.js';
+import 'ai';
+import 'zod';
+import 'errore';
+
+type SandboxActivitySignal = {
+    type: "activity";
+    newConfig: SandboxConfig;
+};
+declare const sandboxActivityHook: workflow.TypedHook<SandboxActivitySignal, SandboxActivitySignal>;
+declare function sandboxLifecycleWorkflow({ input, }: {
+    input: SandboxLifecycleInput;
+}): Promise<void>;
+
+export { type SandboxActivitySignal, SandboxLifecycleInput, sandboxActivityHook, sandboxLifecycleWorkflow };