@contractspec/lib.ai-agent 5.0.4 → 6.0.0

package/dist/node/agent/unified-agent.js

@@ -2156,6 +2156,17 @@ function defineAgent(spec) {
       }));
     }
     toolNames.add(tool.name);
+    if (tool.subagentRef && tool.operationRef) {
+      throw new Error(`Agent ${spec.meta.key} tool "${tool.name}" cannot have both subagentRef and operationRef. Use one.`);
+    }
+    const outputRefCount = [
+      tool.outputPresentation,
+      tool.outputForm,
+      tool.outputDataView
+    ].filter(Boolean).length;
+    if (outputRefCount > 1) {
+      throw new Error(`Agent ${spec.meta.key} tool "${tool.name}" has multiple output refs (outputPresentation, outputForm, outputDataView). Use at most one.`);
+    }
   }
   return Object.freeze(spec);
 }
@@ -2299,15 +2310,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) {
@@ -2318,19 +2438,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();
@@ -2338,27 +2459,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;
@@ -2420,11 +2597,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));
@@ -2433,15 +2611,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;
@@ -2481,6 +2659,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
@@ -2511,8 +2716,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;
 }
@@ -2618,12 +2823,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) {
@@ -3146,7 +3351,7 @@ import {
   stepCountIs
 } from "ai";
 import { randomUUID } from "node:crypto";
-import * as z3 from "zod";
+import * as z4 from "zod";
 
 class ContractSpecAgent {
   version = "agent-v1";
@@ -3175,12 +3380,19 @@ class ContractSpecAgent {
     }
     try {
       const instructions = await injectStaticKnowledge(effectiveConfig.spec.instructions, effectiveConfig.spec.knowledge ?? [], effectiveConfig.knowledgeRetriever);
-      const specTools = specToolsToAISDKTools(effectiveConfig.spec.tools, effectiveConfig.toolHandlers, { agentId: agentKey(effectiveConfig.spec.meta) });
+      const specTools = specToolsToAISDKTools(effectiveConfig.spec.tools, effectiveConfig.toolHandlers, { agentId: agentKey(effectiveConfig.spec.meta) }, {
+        operationRegistry: effectiveConfig.operationRegistry,
+        subagentRegistry: effectiveConfig.subagentRegistry
+      });
       const knowledgeTool = effectiveConfig.knowledgeRetriever ? createKnowledgeQueryTool(effectiveConfig.knowledgeRetriever, effectiveConfig.spec.knowledge ?? []) : null;
+      const memoryTool = effectiveConfig.spec.memoryTools?.provider === "anthropic" && effectiveConfig.agentMemoryStore ? createAnthropicMemoryTool(effectiveConfig.agentMemoryStore) : null;
       const reservedToolNames = new Set(Object.keys(specTools));
       if (knowledgeTool) {
         reservedToolNames.add("query_knowledge");
       }
+      if (memoryTool) {
+        reservedToolNames.add("memory");
+      }
       const conflictingMcpTools = Object.keys(mcpToolset?.tools ?? {}).filter((toolName) => reservedToolNames.has(toolName));
       if (conflictingMcpTools.length > 0) {
         throw new Error(`MCP tools conflict with agent tools: ${conflictingMcpTools.join(", ")}. Configure MCP toolPrefix values to avoid collisions.`);
@@ -3188,6 +3400,7 @@ class ContractSpecAgent {
       const tools = {
         ...specTools,
         ...knowledgeTool ? { query_knowledge: knowledgeTool } : {},
+        ...memoryTool ? { memory: memoryTool } : {},
         ...mcpToolset?.tools ?? {},
         ...effectiveConfig.additionalTools ?? {}
       };
@@ -3219,7 +3432,7 @@ class ContractSpecAgent {
       stepIndex: 0,
       stepStartedAt: new Date
     });
-    if (this.config.sessionStore) {
+    if (this.config.sessionStore && !params.messages?.length) {
       const existing = await this.config.sessionStore.get(sessionId);
       if (!existing) {
         await this.config.sessionStore.create({
@@ -3237,14 +3450,9 @@ class ContractSpecAgent {
       }
       await this.config.sessionStore.appendMessage(sessionId, {
         role: "user",
-        content: params.prompt
+        content: params.prompt ?? ""
       });
     }
-    const prompt = params.systemOverride ? `${this.instructions}
-
-${params.systemOverride}
-
-${params.prompt}` : params.prompt;
     const model = await this.resolveModelForCall({
       sessionId,
       traceId,
@@ -3252,18 +3460,33 @@ ${params.prompt}` : params.prompt;
     });
     const effectiveMaxSteps = resolveMaxSteps(params.maxSteps, this.spec.maxSteps);
     const inner = this.createInnerAgent(model, effectiveMaxSteps);
+    const generateOptions = {
+      abortSignal: params.signal,
+      options: {
+        tenantId: params.options?.tenantId,
+        actorId: params.options?.actorId,
+        sessionId,
+        metadata: params.options?.metadata
+      }
+    };
     let result;
     try {
-      result = await inner.generate({
-        prompt,
-        abortSignal: params.signal,
-        options: {
-          tenantId: params.options?.tenantId,
-          actorId: params.options?.actorId,
-          sessionId,
-          metadata: params.options?.metadata
-        }
-      });
+      if (params.messages && params.messages.length > 0) {
+        result = await inner.generate({
+          messages: params.messages,
+          ...generateOptions
+        });
+      } else {
+        const prompt = params.systemOverride && params.prompt ? `${this.instructions}
+
+${params.systemOverride}
+
+${params.prompt}` : params.prompt ?? "";
+        result = await inner.generate({
+          prompt,
+          ...generateOptions
+        });
+      }
     } catch (error) {
       if (this.config.sessionStore) {
         await this.config.sessionStore.update(sessionId, {
@@ -3323,11 +3546,11 @@ ${params.prompt}` : params.prompt;
       stepIndex: 0,
       stepStartedAt: new Date
     });
-    const prompt = params.systemOverride ? `${this.instructions}
+    const prompt = params.systemOverride && params.prompt ? `${this.instructions}
 
 ${params.systemOverride}
 
-${params.prompt}` : params.prompt;
+${params.prompt}` : params.prompt ?? "";
     const model = await this.resolveModelForCall({
       sessionId,
       traceId,
@@ -3351,7 +3574,7 @@ ${params.prompt}` : params.prompt;
       }
       await this.config.sessionStore.appendMessage(sessionId, {
         role: "user",
-        content: params.prompt
+        content: prompt
       });
       await this.config.sessionStore.update(sessionId, { status: "running" });
     }
@@ -3482,14 +3705,15 @@ var init_contract_spec_agent = __esm(() => {
   init_spec();
   init_tool_adapter();
   init_knowledge_tool();
+  init_memory_tools();
   init_mcp_client();
   init_injector();
   init_adapter();
-  ContractSpecCallOptionsSchema = z3.object({
-    tenantId: z3.string().optional(),
-    actorId: z3.string().optional(),
-    sessionId: z3.string().optional(),
-    metadata: z3.record(z3.string(), z3.unknown()).optional()
+  ContractSpecCallOptionsSchema = z4.object({
+    tenantId: z4.string().optional(),
+    actorId: z4.string().optional(),
+    sessionId: z4.string().optional(),
+    metadata: z4.record(z4.string(), z4.unknown()).optional()
   });
 });
 
@@ -3534,12 +3758,12 @@ var init_types = __esm(() => {
 });
 
 // src/providers/claude-agent-sdk/tool-bridge.ts
-function specToolToClaudeAgentTool(tool3, handler, context) {
+function specToolToClaudeAgentTool(tool4, handler, context) {
   return {
-    name: tool3.name,
-    description: tool3.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool3.name }),
-    input_schema: normalizeSchema(tool3.schema),
-    requires_confirmation: tool3.requiresApproval ?? !tool3.automationSafe,
+    name: tool4.name,
+    description: tool4.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool4.name }),
+    input_schema: normalizeSchema(tool4.schema),
+    requires_confirmation: tool4.requiresApproval ?? !tool4.automationSafe,
     execute: async (input) => {
       const fullContext = {
         agentId: context.agentId ?? "unknown",
@@ -3554,14 +3778,14 @@ function specToolToClaudeAgentTool(tool3, handler, context) {
   };
 }
 function specToolsToClaudeAgentTools(tools, handlers, context) {
-  return tools.filter((tool3) => handlers.has(tool3.name)).map((tool3) => {
-    const handler = handlers.get(tool3.name);
+  return tools.filter((tool4) => handlers.has(tool4.name)).map((tool4) => {
+    const handler = handlers.get(tool4.name);
     if (!handler) {
       throw new Error(createAgentI18n().t("error.handlerNotFoundForTool", {
-        name: tool3.name
+        name: tool4.name
       }));
     }
-    return specToolToClaudeAgentTool(tool3, handler, context);
+    return specToolToClaudeAgentTool(tool4, handler, context);
   });
 }
 function claudeAgentToolToSpecTool(claudeTool, execute) {
@@ -3587,12 +3811,12 @@ function claudeAgentToolsToSpecTools(claudeTools) {
   }
   return { configs, handlers };
 }
-function specToolToExternalTool(tool3, handler, context) {
+function specToolToExternalTool(tool4, handler, context) {
   return {
-    name: tool3.name,
-    description: tool3.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool3.name }),
-    inputSchema: tool3.schema ?? { type: "object" },
-    requiresApproval: tool3.requiresApproval ?? !tool3.automationSafe,
+    name: tool4.name,
+    description: tool4.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool4.name }),
+    inputSchema: tool4.schema ?? { type: "object" },
+    requiresApproval: tool4.requiresApproval ?? !tool4.automationSafe,
     execute: handler ? async (input) => {
       const fullContext = {
         agentId: context?.agentId ?? "unknown",
@@ -3793,8 +4017,8 @@ class ClaudeAgentSDKProvider {
     let mcpToolset = null;
     try {
       const toolSet = {};
-      for (const tool3 of spec.tools) {
-        toolSet[tool3.name] = specToolToExternalTool(tool3);
+      for (const tool4 of spec.tools) {
+        toolSet[tool4.name] = specToolToExternalTool(tool4);
       }
       if ((this.config.mcpServers?.length ?? 0) > 0) {
         mcpToolset = await createMcpToolsets(this.config.mcpServers ?? [], {
@@ -4008,20 +4232,20 @@ ${params.systemOverride}` : context.spec.instructions;
     }
     return toolsForSdk;
   }
-  mcpToolToExternalTool(toolName, tool3) {
+  mcpToolToExternalTool(toolName, tool4) {
     return {
       name: toolName,
-      description: tool3.description ?? createAgentI18n(this.config.locale).t("tool.fallbackDescription", {
+      description: tool4.description ?? createAgentI18n(this.config.locale).t("tool.fallbackDescription", {
         name: toolName
       }),
-      inputSchema: this.normalizeExternalInputSchema(tool3.inputSchema),
+      inputSchema: this.normalizeExternalInputSchema(tool4.inputSchema),
       execute: async (input) => {
-        if (!tool3.execute) {
+        if (!tool4.execute) {
           throw new Error(createAgentI18n(this.config.locale).t("error.toolNoExecuteHandler", {
             name: toolName
           }));
         }
-        return tool3.execute(input, {
+        return tool4.execute(input, {
           toolCallId: `mcp-${randomUUID2()}`,
           messages: []
         });
@@ -4061,8 +4285,8 @@ ${params.systemOverride}` : context.spec.instructions;
     return typeof value === "object" && value !== null;
   }
   async executeTool(toolCall, context, _params) {
-    const tool3 = context.tools[toolCall.toolName];
-    if (!tool3?.execute) {
+    const tool4 = context.tools[toolCall.toolName];
+    if (!tool4?.execute) {
       return {
         toolCallId: toolCall.toolCallId,
         toolName: toolCall.toolName,
@@ -4072,7 +4296,7 @@ ${params.systemOverride}` : context.spec.instructions;
       };
     }
     try {
-      const output = await tool3.execute(toolCall.args);
+      const output = await tool4.execute(toolCall.args);
       return {
         toolCallId: toolCall.toolCallId,
         toolName: toolCall.toolName,
@@ -4149,22 +4373,22 @@ var init_claude_agent_sdk = __esm(() => {
 });
 
 // src/providers/opencode-sdk/tool-bridge.ts
-function specToolToOpenCodeTool(tool3) {
+function specToolToOpenCodeTool(tool4) {
   return {
-    name: tool3.name,
-    description: tool3.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool3.name }),
-    parameters: normalizeToOpenCodeParameters(tool3.schema),
-    permission: getPermissionLevel(tool3)
+    name: tool4.name,
+    description: tool4.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool4.name }),
+    parameters: normalizeToOpenCodeParameters(tool4.schema),
+    permission: getPermissionLevel(tool4)
   };
 }
 function specToolsToOpenCodeTools(tools) {
   return tools.map(specToolToOpenCodeTool);
 }
-function getPermissionLevel(tool3) {
-  if (tool3.requiresApproval) {
+function getPermissionLevel(tool4) {
+  if (tool4.requiresApproval) {
     return "ask";
   }
-  if (tool3.automationSafe === false) {
+  if (tool4.automationSafe === false) {
     return "ask";
   }
   return "allow";
@@ -4181,12 +4405,12 @@ function openCodeToolToSpecTool(openCodeTool) {
 function openCodeToolsToSpecTools(openCodeTools) {
   return openCodeTools.map(openCodeToolToSpecTool);
 }
-function specToolToExternalToolForOpenCode(tool3, handler, context) {
+function specToolToExternalToolForOpenCode(tool4, handler, context) {
   return {
-    name: tool3.name,
-    description: tool3.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool3.name }),
-    inputSchema: tool3.schema ?? { type: "object" },
-    requiresApproval: tool3.requiresApproval ?? !tool3.automationSafe,
+    name: tool4.name,
+    description: tool4.description ?? createAgentI18n().t("tool.fallbackDescription", { name: tool4.name }),
+    inputSchema: tool4.schema ?? { type: "object" },
+    requiresApproval: tool4.requiresApproval ?? !tool4.automationSafe,
     execute: handler ? async (input) => {
       const fullContext = {
         agentId: context?.agentId ?? "unknown",
@@ -4236,9 +4460,9 @@ function convertToOpenCodeParameter(schema) {
 }
 function createToolHandlerMap(tools) {
   const handlers = new Map;
-  for (const [name, tool3] of Object.entries(tools)) {
-    if (tool3.execute) {
-      handlers.set(name, tool3.execute);
+  for (const [name, tool4] of Object.entries(tools)) {
+    if (tool4.execute) {
+      handlers.set(name, tool4.execute);
     }
   }
   return handlers;
@@ -4274,7 +4498,7 @@ var init_tool_bridge2 = __esm(() => {
 
 // src/providers/opencode-sdk/agent-bridge.ts
 function inferAgentType(spec) {
-  const hasCodeTools = spec.tools.some((tool3) => [
+  const hasCodeTools = spec.tools.some((tool4) => [
     "write_file",
     "edit_file",
     "create_file",
@@ -4283,7 +4507,7 @@ function inferAgentType(spec) {
     "execute",
     "run_command",
     "terminal"
-  ].includes(tool3.name.toLowerCase()));
+  ].includes(tool4.name.toLowerCase()));
   const instructionsLower = spec.instructions.toLowerCase();
   const hasPlanningKeywords = /\b(plan|design|architect|strategy|analyze|review|assess|evaluate)\b/.test(instructionsLower);
   const hasExplorationKeywords = /\b(search|find|explore|discover|locate|grep|pattern)\b/.test(instructionsLower);
@@ -4318,13 +4542,13 @@ function specToOpenCodeConfig(spec, options) {
 }
 function buildPermissions(spec) {
   const permissions = {};
-  for (const tool3 of spec.tools) {
-    if (tool3.requiresApproval) {
-      permissions[tool3.name] = "ask";
-    } else if (tool3.automationSafe === false) {
-      permissions[tool3.name] = "ask";
+  for (const tool4 of spec.tools) {
+    if (tool4.requiresApproval) {
+      permissions[tool4.name] = "ask";
+    } else if (tool4.automationSafe === false) {
+      permissions[tool4.name] = "ask";
     } else {
-      permissions[tool3.name] = "allow";
+      permissions[tool4.name] = "allow";
     }
   }
   return permissions;
@@ -4360,9 +4584,9 @@ function buildMarkdownBody(spec) {
   if (spec.tools.length > 0) {
     lines.push(i18n.t("export.tools"));
     lines.push("");
-    for (const tool3 of spec.tools) {
-      const permission = tool3.requiresApproval ? i18n.t("export.bridge.requiresApproval") : tool3.automationSafe === false ? i18n.t("export.bridge.askMode") : "";
-      lines.push(`- **${tool3.name}**: ${tool3.description ?? i18n.t("export.noDescription")} ${permission}`.trim());
+    for (const tool4 of spec.tools) {
+      const permission = tool4.requiresApproval ? i18n.t("export.bridge.requiresApproval") : tool4.automationSafe === false ? i18n.t("export.bridge.askMode") : "";
+      lines.push(`- **${tool4.name}**: ${tool4.description ?? i18n.t("export.noDescription")} ${permission}`.trim());
     }
     lines.push("");
   }
@@ -4397,8 +4621,8 @@ function serializeOpenCodeMarkdown(markdown) {
   }
   if (markdown.frontmatter.tools && markdown.frontmatter.tools.length > 0) {
     lines.push(`tools:`);
-    for (const tool3 of markdown.frontmatter.tools) {
-      lines.push(`  - ${tool3}`);
+    for (const tool4 of markdown.frontmatter.tools) {
+      lines.push(`  - ${tool4}`);
     }
   }
   lines.push("---");
@@ -4419,12 +4643,12 @@ function openCodeConfigToSpec(config) {
     },
     description: config.description,
     instructions: config.instructions ?? "",
-    tools: config.tools?.map((tool3) => ({
-      name: tool3.name,
-      description: tool3.description,
-      schema: tool3.parameters,
-      requiresApproval: tool3.permission === "ask",
-      automationSafe: tool3.permission === "allow"
+    tools: config.tools?.map((tool4) => ({
+      name: tool4.name,
+      description: tool4.description,
+      schema: tool4.parameters,
+      requiresApproval: tool4.permission === "ask",
+      automationSafe: tool4.permission === "allow"
     })) ?? [],
     maxSteps: config.config?.max_steps ?? 10
   };
@@ -4481,8 +4705,8 @@ class OpenCodeSDKProvider {
         model: this.config.model
       });
       const toolSet = {};
-      for (const tool3 of spec.tools) {
-        toolSet[tool3.name] = specToolToExternalToolForOpenCode(tool3);
+      for (const tool4 of spec.tools) {
+        toolSet[tool4.name] = specToolToExternalToolForOpenCode(tool4);
       }
       const instructions = await injectStaticKnowledge(spec.instructions, spec.knowledge ?? [], undefined);
       const contextId = `opencode-${agentKey(spec.meta)}-${Date.now()}`;
@@ -4914,8 +5138,8 @@ class UnifiedAgent {
       const { createProvider } = await import("@contractspec/lib.ai-providers/factory");
       model = createProvider(backendConfig.provider).getModel();
     } else {
-      const { anthropic } = await import("@ai-sdk/anthropic");
-      model = anthropic(backendConfig?.model ?? "claude-3-5-sonnet-20240620");
+      const { anthropic: anthropic2 } = await import("@ai-sdk/anthropic");
+      model = anthropic2(backendConfig?.model ?? "claude-3-5-sonnet-20240620");
     }
     return this.applyModelSettings(model, {
       temperature: backendConfig?.temperature,