@contractspec/lib.ai-agent 5.0.4 → 6.0.0

package/dist/tools/index.js

@@ -2260,15 +2260,124 @@ function jsonSchemaToZodSafe(schema) {
 }
 var init_json_schema_to_zod = () => {};
 
+// src/tools/operation-tool-handler.ts
+function toolCtxToHandlerCtx(ctx) {
+  return {
+    traceId: ctx.metadata?.traceId,
+    organizationId: ctx.tenantId ?? null,
+    userId: ctx.actorId ?? null,
+    actor: ctx.actorId ? "user" : "anonymous",
+    channel: "agent",
+    roles: []
+  };
+}
+function createOperationToolHandler(registry, operationRef) {
+  return async (input, context) => {
+    const handlerCtx = toolCtxToHandlerCtx(context);
+    const result = await registry.execute(operationRef.key, operationRef.version, input ?? {}, handlerCtx);
+    return result;
+  };
+}
+
+// src/tools/subagent-tool.ts
+import { readUIMessageStream, tool } from "ai";
+import { z as z2 } from "zod";
+function toReadableStream(iterable) {
+  if (iterable instanceof ReadableStream) {
+    return iterable;
+  }
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of iterable) {
+          controller.enqueue(chunk);
+        }
+      } finally {
+        controller.close();
+      }
+    }
+  });
+}
+function createSubagentTool(options) {
+  const {
+    subagent,
+    description = "Research a topic or question in depth.",
+    taskParam = "task",
+    toModelSummary = true,
+    passConversationHistory = false
+  } = options;
+  const inputSchema = z2.object({
+    [taskParam]: z2.string().describe("The research task to complete")
+  });
+  const execute = async function* (input, options2) {
+    const task = String(input[taskParam] ?? input.task ?? "");
+    const { abortSignal, messages } = options2 ?? {};
+    if (passConversationHistory && messages && messages.length > 0 && typeof subagent.generate === "function") {
+      const result2 = await subagent.generate({
+        messages: [...messages, { role: "user", content: task }],
+        abortSignal
+      });
+      yield { parts: [{ type: "text", text: result2.text }] };
+      return;
+    }
+    const result = await subagent.stream({
+      prompt: task,
+      abortSignal
+    });
+    const uiStream = result.toUIMessageStream();
+    const stream = toReadableStream(uiStream);
+    for await (const message of readUIMessageStream({
+      stream
+    })) {
+      yield message;
+    }
+  };
+  const toolOptions = {
+    description,
+    inputSchema,
+    execute,
+    ...toModelSummary && {
+      toModelOutput: ({
+        output
+      }) => {
+        const parts = output?.parts;
+        if (!Array.isArray(parts)) {
+          return { type: "text", value: "Task completed." };
+        }
+        const lastTextPart = [...parts].reverse().find((p) => p?.type === "text");
+        return {
+          type: "text",
+          value: lastTextPart?.text ?? "Task completed."
+        };
+      }
+    }
+  };
+  return tool(toolOptions);
+}
+var init_subagent_tool = () => {};
+
 // src/tools/tool-adapter.ts
-import { tool } from "ai";
-function specToolToAISDKTool(specTool, handler, context = {}) {
+import { tool as tool2 } from "ai";
+function isAsyncGenerator(value) {
+  return typeof value === "object" && value !== null && typeof value.next === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function specToolToAISDKTool(specTool, handler, context = {}, effectiveInputSchema, operationSpec) {
   let lastInvocationAt;
-  return tool({
+  const inputSchema = effectiveInputSchema ?? jsonSchemaToZodSafe(specTool.schema);
+  const buildContext = (signal) => ({
+    agentId: context.agentId ?? "unknown",
+    sessionId: context.sessionId ?? "unknown",
+    tenantId: context.tenantId,
+    actorId: context.actorId,
+    locale: context.locale,
+    metadata: context.metadata,
+    signal
+  });
+  return tool2({
     description: specTool.description ?? specTool.name,
-    inputSchema: jsonSchemaToZodSafe(specTool.schema),
+    inputSchema,
     needsApproval: specTool.requiresApproval ?? !specTool.automationSafe,
-    execute: async (input) => {
+    execute: async function* (input, options) {
       const now = Date.now();
       const cooldownMs = normalizeDuration(specTool.cooldownMs);
       if (cooldownMs && lastInvocationAt !== undefined) {
@@ -2279,19 +2388,20 @@ function specToolToAISDKTool(specTool, handler, context = {}) {
         }
       }
       const timeoutMs = normalizeDuration(specTool.timeoutMs);
-      const { signal, dispose } = createTimeoutSignal(context.signal, timeoutMs);
+      const signal = options?.abortSignal ?? context.signal;
+      const { signal: timeoutSignal, dispose } = createTimeoutSignal(signal, timeoutMs);
       try {
-        const execution = handler(input, {
-          agentId: context.agentId ?? "unknown",
-          sessionId: context.sessionId ?? "unknown",
-          tenantId: context.tenantId,
-          actorId: context.actorId,
-          locale: context.locale,
-          metadata: context.metadata,
-          signal
-        });
-        const result = timeoutMs ? await withTimeout(execution, timeoutMs, specTool.name) : await execution;
-        return typeof result === "string" ? result : JSON.stringify(result);
+        const execution = handler(input, buildContext(timeoutSignal));
+        if (isAsyncGenerator(execution)) {
+          for await (const raw of execution) {
+            const wrapped = wrapToolOutputForRendering(specTool, raw, operationSpec);
+            yield typeof wrapped === "string" ? wrapped : wrapped;
+          }
+        } else {
+          const raw = timeoutMs ? await withTimeout(Promise.resolve(execution), timeoutMs, specTool.name) : await Promise.resolve(execution);
+          const wrapped = wrapToolOutputForRendering(specTool, raw, operationSpec);
+          yield typeof wrapped === "string" ? wrapped : wrapped;
+        }
       } finally {
         dispose();
         lastInvocationAt = Date.now();
@@ -2299,27 +2409,83 @@ function specToolToAISDKTool(specTool, handler, context = {}) {
     }
   });
 }
-function specToolsToAISDKTools(specTools, handlers, context = {}) {
+function specToolsToAISDKTools(specTools, handlers, context = {}, options) {
   const tools = {};
   for (const specTool of specTools) {
-    const handler = handlers.get(specTool.name);
-    if (!handler) {
-      throw new Error(createAgentI18n(context.locale).t("error.missingToolHandler", {
-        name: specTool.name
-      }));
+    if (specTool.subagentRef && options?.subagentRegistry) {
+      const subagent = options.subagentRegistry.get(specTool.subagentRef.agentId);
+      if (!subagent) {
+        throw new Error(`Subagent not found: ${specTool.subagentRef.agentId}. Register it in subagentRegistry.`);
+      }
+      if (specTool.requiresApproval === true || specTool.automationSafe === false) {
+        console.warn(`[ContractSpec] Subagent tool "${specTool.name}" cannot use needsApproval. ` + `requiresApproval and automationSafe are ignored for subagent tools (AI SDK limitation). ` + `See https://ai-sdk.dev/docs/agents/subagents#no-tool-approvals-in-subagents`);
+      }
+      tools[specTool.name] = createSubagentTool({
+        subagent,
+        description: specTool.description ?? specTool.name,
+        toModelSummary: specTool.subagentRef.toModelSummary ?? true,
+        passConversationHistory: specTool.subagentRef.passConversationHistory
+      });
+      continue;
     }
-    tools[specTool.name] = specToolToAISDKTool(specTool, handler, context);
+    let handler;
+    let effectiveInputSchema;
+    let op;
+    if (specTool.operationRef && options?.operationRegistry) {
+      op = options.operationRegistry.get(specTool.operationRef.key, specTool.operationRef.version);
+      if (!op) {
+        throw new Error(`Operation not found: ${specTool.operationRef.key}${specTool.operationRef.version ? `.v${specTool.operationRef.version}` : ""}`);
+      }
+      handler = createOperationToolHandler(options.operationRegistry, specTool.operationRef);
+      effectiveInputSchema = op.io.input?.getZod?.();
+    } else {
+      const manualHandler = handlers.get(specTool.name);
+      if (!manualHandler) {
+        if (specTool.subagentRef) {
+          throw new Error(`Subagent tool "${specTool.name}" requires subagentRegistry. Pass subagentRegistry in ContractSpecAgentConfig.`);
+        }
+        throw new Error(createAgentI18n(context.locale).t("error.missingToolHandler", {
+          name: specTool.name
+        }));
+      }
+      handler = manualHandler;
+    }
+    tools[specTool.name] = specToolToAISDKTool(specTool, handler, context, effectiveInputSchema, op);
   }
   return tools;
 }
 function createToolHandler(handler) {
-  return async (input, context) => {
+  return (input, context) => {
     return handler(input, context);
   };
 }
 function buildToolHandlers(handlersObj) {
   return new Map(Object.entries(handlersObj));
 }
+function wrapToolOutputForRendering(specTool, result, operationSpec) {
+  const presentation = specTool.outputPresentation ?? operationSpec?.outputPresentation;
+  const form = specTool.outputForm ?? operationSpec?.outputForm;
+  const dataView = specTool.outputDataView ?? operationSpec?.outputDataView;
+  if (presentation) {
+    return {
+      presentationKey: presentation.key,
+      data: result
+    };
+  }
+  if (form) {
+    return {
+      formKey: form.key,
+      defaultValues: typeof result === "object" && result !== null ? result : {}
+    };
+  }
+  if (dataView) {
+    return {
+      dataViewKey: dataView.key,
+      items: Array.isArray(result) ? result : result != null ? [result] : []
+    };
+  }
+  return result;
+}
 function normalizeDuration(value) {
   if (value === undefined) {
     return;
@@ -2381,11 +2547,12 @@ function createToolExecutionError(message, code, retryAfterMs) {
 var init_tool_adapter = __esm(() => {
   init_json_schema_to_zod();
   init_i18n();
+  init_subagent_tool();
 });
 
 // src/tools/knowledge-tool.ts
-import { tool as tool2 } from "ai";
-import * as z2 from "zod";
+import { tool as tool3 } from "ai";
+import * as z3 from "zod";
 function createKnowledgeQueryTool(retriever, knowledgeRefs, locale) {
   const i18n = createAgentI18n(locale);
   const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
@@ -2394,15 +2561,15 @@ function createKnowledgeQueryTool(retriever, knowledgeRefs, locale) {
   }
   const spaceDescriptions = knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? i18n.t("tool.knowledge.spaceDefault")}`).join(`
 `);
-  return tool2({
+  return tool3({
     description: `${i18n.t("tool.knowledge.description")}
 
 ${i18n.t("tool.knowledge.availableSpaces")}
 ${spaceDescriptions}`,
-    inputSchema: z2.object({
-      query: z2.string().describe(i18n.t("tool.knowledge.param.query")),
-      spaceKey: z2.enum(optionalSpaces).optional().describe(i18n.t("tool.knowledge.param.spaceKey")),
-      topK: z2.number().optional().default(5).describe(i18n.t("tool.knowledge.param.topK"))
+    inputSchema: z3.object({
+      query: z3.string().describe(i18n.t("tool.knowledge.param.query")),
+      spaceKey: z3.enum(optionalSpaces).optional().describe(i18n.t("tool.knowledge.param.spaceKey")),
+      topK: z3.number().optional().default(5).describe(i18n.t("tool.knowledge.param.topK"))
     }),
     execute: async ({ query, spaceKey, topK }) => {
       const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
@@ -2442,6 +2609,33 @@ var init_knowledge_tool = __esm(() => {
   init_i18n();
 });
 
+// src/tools/memory-tools.ts
+import { anthropic } from "@ai-sdk/anthropic";
+function createAnthropicMemoryTool(store) {
+  const memory = anthropic.tools.memory_20250818({
+    execute: async (action) => {
+      switch (action.command) {
+        case "view":
+          return store.view(action.path ?? "/memories", action.view_range);
+        case "create":
+          return store.create(action.path ?? "/memories/untitled", action.file_text ?? "");
+        case "str_replace":
+          return store.strReplace(action.path ?? "/memories", action.old_str ?? "", action.new_str ?? "");
+        case "insert":
+          return store.insert(action.path ?? "/memories", action.insert_line ?? 0, action.insert_text ?? "");
+        case "delete":
+          return store.delete(action.path ?? "/memories");
+        case "rename":
+          return store.rename(action.old_path ?? "/memories", action.new_path ?? "/memories");
+        default:
+          return `Unknown command: ${action.command}`;
+      }
+    }
+  });
+  return memory;
+}
+var init_memory_tools = () => {};
+
 // src/tools/mcp-client-helpers.ts
 import {
   Experimental_StdioMCPTransport as StdioClientTransport
@@ -2472,8 +2666,8 @@ function prefixToolNames(config, tools) {
     return tools;
   }
   const prefixedTools = {};
-  for (const [toolName, tool3] of Object.entries(tools)) {
-    prefixedTools[`${prefix}_${toolName}`] = tool3;
+  for (const [toolName, tool4] of Object.entries(tools)) {
+    prefixedTools[`${prefix}_${toolName}`] = tool4;
   }
   return prefixedTools;
 }
@@ -2579,12 +2773,12 @@ async function createMcpToolsets(configs, options = {}) {
       for (const [serverName, toolNames] of Object.entries(result.serverToolNames)) {
         serverToolNames[serverName] = toolNames;
       }
-      for (const [toolName, tool3] of Object.entries(result.tools)) {
+      for (const [toolName, tool4] of Object.entries(result.tools)) {
         const hasCollision = combinedTools[toolName] !== undefined;
         if (hasCollision && collisionStrategy === "error") {
           throw new Error(`Duplicate MCP tool name "${toolName}" detected. Use "toolPrefix" or set onNameCollision to "overwrite".`);
         }
-        combinedTools[toolName] = tool3;
+        combinedTools[toolName] = tool4;
       }
     }
   } catch (error) {
@@ -2607,11 +2801,231 @@ var init_mcp_client = __esm(() => {
   init_mcp_client_helpers();
 });
 
+// src/tools/agent-memory-store.ts
+function validateMemoryPath(path) {
+  const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+  if (!normalized.startsWith("/memories") || normalized.includes("..") || normalized === "/memories/.." || normalized.startsWith("/memories/../")) {
+    throw new Error(`Invalid memory path: ${path}. Path must be under /memories and cannot contain traversal sequences.`);
+  }
+}
+
+// src/tools/in-memory-agent-memory-store.ts
+function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}K`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}
+
+class InMemoryAgentMemoryStore {
+  store = new Map;
+  async view(path, viewRange) {
+    validateMemoryPath(path);
+    const normalized = path.replace(/\/+/g, "/").replace(/\/$/, "") || "/memories";
+    if (this.isDirectory(normalized)) {
+      return this.listDirectory(normalized);
+    }
+    const content = this.store.get(normalized);
+    if (content === undefined) {
+      return `The path ${path} does not exist. Please provide a valid path.`;
+    }
+    const lines = content.split(`
+`);
+    if (lines.length > 999999) {
+      return `File ${path} exceeds maximum line limit of 999,999 lines.`;
+    }
+    const [start, end] = viewRange ?? [1, lines.length];
+    const from = Math.max(0, start - 1);
+    const to = Math.min(lines.length, end);
+    const selected = lines.slice(from, to);
+    const numbered = selected.map((line, i) => {
+      const num = from + i + 1;
+      return `${String(num).padStart(6)}	${line}`;
+    }).join(`
+`);
+    return `Here's the content of ${path} with line numbers:
+${numbered}`;
+  }
+  async create(path, fileText) {
+    validateMemoryPath(path);
+    const normalized = path.replace(/\/+/g, "/");
+    if (this.store.has(normalized)) {
+      return `Error: File ${path} already exists`;
+    }
+    this.ensureParentDir(normalized);
+    this.store.set(normalized, fileText);
+    return `File created successfully at: ${path}`;
+  }
+  async strReplace(path, oldStr, newStr) {
+    validateMemoryPath(path);
+    const normalized = path.replace(/\/+/g, "/");
+    const content = this.store.get(normalized);
+    if (content === undefined) {
+      return `Error: The path ${path} does not exist. Please provide a valid path.`;
+    }
+    const count = (content.match(new RegExp(escapeRegex(oldStr), "g")) ?? []).length;
+    if (count > 1) {
+      const lines = content.split(`
+`);
+      const lineNums = [];
+      lines.forEach((line, i) => {
+        if (line.includes(oldStr))
+          lineNums.push(i + 1);
+      });
+      return `No replacement was performed. Multiple occurrences of old_str \`${oldStr}\` in lines: ${lineNums.join(", ")}. Please ensure it is unique`;
+    }
+    if (count === 0) {
+      return `No replacement was performed, old_str \`${oldStr}\` did not appear verbatim in ${path}.`;
+    }
+    const newContent = content.replace(oldStr, newStr);
+    this.store.set(normalized, newContent);
+    const snippet = newContent.split(`
+`).slice(0, 5);
+    const numbered = snippet.map((line, i) => `${String(i + 1).padStart(6)}	${line}`).join(`
+`);
+    return `The memory file has been edited.
+${numbered}`;
+  }
+  async insert(path, insertLine, insertText) {
+    validateMemoryPath(path);
+    const normalized = path.replace(/\/+/g, "/");
+    const content = this.store.get(normalized);
+    if (content === undefined) {
+      return `Error: The path ${path} does not exist`;
+    }
+    const lines = content.split(`
+`);
+    const n = lines.length;
+    if (insertLine < 0 || insertLine > n) {
+      return `Error: Invalid \`insert_line\` parameter: ${insertLine}. It should be within the range of lines of the file: [0, ${n}]`;
+    }
+    lines.splice(insertLine, 0, insertText.replace(/\n$/, ""));
+    this.store.set(normalized, lines.join(`
+`));
+    return `The file ${path} has been edited.`;
+  }
+  async delete(path) {
+    validateMemoryPath(path);
+    const normalized = path.replace(/\/+/g, "/");
+    if (this.isDirectory(normalized)) {
+      const prefix = normalized === "/memories" ? "/memories/" : `${normalized}/`;
+      for (const key of this.store.keys()) {
+        if (key.startsWith(prefix) || key === normalized) {
+          this.store.delete(key);
+        }
+      }
+    } else {
+      if (!this.store.has(normalized)) {
+        return `Error: The path ${path} does not exist`;
+      }
+      this.store.delete(normalized);
+    }
+    return `Successfully deleted ${path}`;
+  }
+  async rename(oldPath, newPath) {
+    validateMemoryPath(oldPath);
+    validateMemoryPath(newPath);
+    const oldNorm = oldPath.replace(/\/+/g, "/");
+    const newNorm = newPath.replace(/\/+/g, "/");
+    if (this.store.has(newNorm) || this.hasAnyChild(newNorm)) {
+      return `Error: The destination ${newPath} already exists`;
+    }
+    if (this.isDirectory(oldNorm)) {
+      const oldPrefix = `${oldNorm}/`;
+      const entries = Array.from(this.store.entries()).filter(([k]) => k.startsWith(oldPrefix) || k === oldNorm);
+      const newPrefix = `${newNorm}/`;
+      for (const [k, v] of entries) {
+        this.store.delete(k);
+        const newKey = k === oldNorm ? newNorm : newPrefix + k.slice(oldPrefix.length);
+        this.store.set(newKey, v);
+      }
+    } else {
+      const content = this.store.get(oldNorm);
+      if (content === undefined) {
+        return `Error: The path ${oldPath} does not exist`;
+      }
+      this.store.delete(oldNorm);
+      this.ensureParentDir(newNorm);
+      this.store.set(newNorm, content);
+    }
+    return `Successfully renamed ${oldPath} to ${newPath}`;
+  }
+  isDirectory(path) {
+    if (path === "/memories")
+      return true;
+    for (const key of this.store.keys()) {
+      if (key.startsWith(path + "/"))
+        return true;
+    }
+    return false;
+  }
+  hasAnyChild(path) {
+    const prefix = path.endsWith("/") ? path : `${path}/`;
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix))
+        return true;
+    }
+    return false;
+  }
+  ensureParentDir(path) {
+    const parts = path.split("/").filter(Boolean);
+    parts.pop();
+    for (let i = 1;i <= parts.length; i++) {
+      const p = "/" + parts.slice(0, i).join("/");
+      if (!this.store.has(p)) {
+        this.store.set(p, "");
+      }
+    }
+  }
+  listDirectory(path) {
+    const prefix = path === "/memories" ? "/memories/" : `${path}/`;
+    const seen = new Set;
+    const entries = [];
+    if (path === "/memories") {
+      entries.push({
+        path: "/memories",
+        size: Array.from(this.store.keys()).filter((k) => k.startsWith("/memories/")).reduce((acc, k) => acc + (this.store.get(k)?.length ?? 0), 0)
+      });
+    }
+    for (const key of this.store.keys()) {
+      if (!key.startsWith(prefix) && key !== path)
+        continue;
+      const rel = key.slice(prefix.length);
+      const first = rel.split("/")[0];
+      if (!first || first.startsWith(".") || first === "node_modules")
+        continue;
+      const fullPath = path === "/memories" ? `/memories/${first}` : `${path}/${first}`;
+      if (seen.has(fullPath))
+        continue;
+      seen.add(fullPath);
+      let size = 0;
+      if (this.store.has(key)) {
+        size = (this.store.get(key) ?? "").length;
+      } else {
+        for (const k of this.store.keys()) {
+          if (k.startsWith(fullPath + "/") || k === fullPath) {
+            size += (this.store.get(k) ?? "").length;
+          }
+        }
+      }
+      entries.push({ path: fullPath, size });
+    }
+    const lines = entries.slice(0, 50).map((e) => `${formatSize(e.size)}	${e.path}`).join(`
+`);
+    return `Here're the files and directories up to 2 levels deep in ${path}, excluding hidden items and node_modules:
+${lines}`;
+  }
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // src/tools/mcp-server.ts
 init_json_schema_to_zod();
 init_i18n();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z3 from "zod";
+import * as z4 from "zod";
 import { sanitizeMcpName } from "@contractspec/lib.contracts-spec/jsonschema";
 function agentToMcpServer(agent, spec) {
   const i18n = createAgentI18n(spec.locale);
@@ -2621,9 +3035,9 @@ function agentToMcpServer(agent, spec) {
   });
   server.registerTool(sanitizeMcpName(spec.meta.key), {
     description: spec.description ?? i18n.t("tool.mcp.agentDescription", { key: spec.meta.key }),
-    inputSchema: z3.object({
-      message: z3.string().describe(i18n.t("tool.mcp.param.message")),
-      sessionId: z3.string().optional().describe(i18n.t("tool.mcp.param.sessionId"))
+    inputSchema: z4.object({
+      message: z4.string().describe(i18n.t("tool.mcp.param.message")),
+      sessionId: z4.string().optional().describe(i18n.t("tool.mcp.param.sessionId"))
     })
   }, async (args) => {
     const { message, sessionId } = args;
@@ -2641,7 +3055,7 @@ function agentToMcpServer(agent, spec) {
     };
   });
   for (const toolConfig of spec.tools) {
-    const inputSchema = toolConfig.schema ? jsonSchemaToZodSafe(toolConfig.schema) : z3.object({});
+    const inputSchema = toolConfig.schema ? jsonSchemaToZodSafe(toolConfig.schema) : z4.object({});
     server.registerTool(sanitizeMcpName(`${spec.meta.key}.${toolConfig.name}`), {
       description: toolConfig.description ?? i18n.t("tool.mcp.toolDescription", { name: toolConfig.name }),
       inputSchema
@@ -2671,15 +3085,22 @@ function createAgentMcpServer(config) {
 // src/tools/index.ts
 init_tool_adapter();
 init_knowledge_tool();
+init_subagent_tool();
 init_mcp_client();
+init_memory_tools();
 export {
+  validateMemoryPath,
   specToolsToAISDKTools,
   specToolToAISDKTool,
   mcpServerToTools,
   createToolHandler,
+  createSubagentTool,
+  createOperationToolHandler,
   createMcpToolsets,
   createKnowledgeQueryTool,
+  createAnthropicMemoryTool,
   createAgentMcpServer,
   buildToolHandlers,
-  agentToMcpServer
+  agentToMcpServer,
+  InMemoryAgentMemoryStore
 };

package/dist/tools/mcp-client.browser.d.ts

@@ -2,26 +2,26 @@
  * Browser-safe stub for mcp-client. MCP stdio/process spawning cannot run in browser.
  * Use this when bundling for client; the real implementation runs only on Node.
  */
-import type { Tool } from "ai";
-export type McpTransportType = "stdio" | "sse" | "http";
+import type { Tool } from 'ai';
+export type McpTransportType = 'stdio' | 'sse' | 'http';
 interface McpClientBaseConfig {
     name: string;
     toolPrefix?: string;
     clientName?: string;
     clientVersion?: string;
-    authMethod?: "api-key" | "oauth2" | "bearer";
+    authMethod?: 'api-key' | 'oauth2' | 'bearer';
     authHeaders?: Record<string, string>;
     apiVersion?: string;
 }
 export interface McpStdioClientConfig extends McpClientBaseConfig {
-    transport?: "stdio";
+    transport?: 'stdio';
     command: string;
     args?: string[];
     env?: Record<string, string>;
     cwd?: string;
 }
 export interface McpRemoteClientConfig extends McpClientBaseConfig {
-    transport: "sse" | "http";
+    transport: 'sse' | 'http';
     url: string;
     headers?: Record<string, string>;
     authProvider?: unknown;
@@ -35,7 +35,7 @@ export interface McpClientResult {
     serverToolNames: Record<string, string[]>;
 }
 export interface CreateMcpToolsetsOptions {
-    onNameCollision?: "overwrite" | "error";
+    onNameCollision?: 'overwrite' | 'error';
 }
 /**
  * Browser stub: MCP tools require Node (child_process). Returns empty tools.