@agentfield/sdk 0.1.45 → 0.1.46-rc.2

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import express from 'express';
 import http from 'node:http';
+import * as _ai_sdk_provider from '@ai-sdk/provider';
 import { z } from 'zod';
+import { ToolSet } from 'ai';
 
 type ZodSchema<T> = z.Schema<T, z.ZodTypeDef, any>;
 interface AIRequestOptions {
@@ -34,6 +36,11 @@ declare class AIClient {
     stream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
     embed(value: string, options?: AIEmbeddingOptions): Promise<number[]>;
     embedMany(values: string[], options?: AIEmbeddingOptions): Promise<number[][]>;
+    /**
+     * Build and return the AI model instance for a given set of options.
+     * Exposed for use by the tool-calling loop.
+     */
+    getModel(options?: AIRequestOptions): _ai_sdk_provider.LanguageModelV2;
     private buildModel;
     private buildEmbeddingModel;
     private getRateLimiter;
@@ -415,6 +422,89 @@ declare class DidInterface {
     exportAuditTrail(filters?: AuditTrailFilters): Promise<AuditTrailExport>;
 }
 
+/**
+ * Tool calling support for AgentField agents.
+ *
+ * Converts discovered capabilities into Vercel AI SDK tool definitions and provides
+ * an automatic tool-call execution loop that dispatches calls via agent.call().
+ */
+
+interface ToolCallConfig {
+    /** Maximum number of LLM turns in the tool-call loop (default: 10). */
+    maxTurns?: number;
+    /** Maximum total tool calls allowed (default: 25). */
+    maxToolCalls?: number;
+    /** Maximum candidate tools to present to the LLM. */
+    maxCandidateTools?: number;
+    /** Maximum tools to hydrate with full schemas (lazy mode). */
+    maxHydratedTools?: number;
+    /** Schema hydration mode: "eager" includes full schemas, "lazy" sends metadata first. */
+    schemaHydration?: 'eager' | 'lazy';
+    /** Whether to broaden discovery if no tools match (default: false). */
+    fallbackBroadening?: boolean;
+    /** Filter by tags during discovery. */
+    tags?: string[];
+    /** Filter by agent IDs during discovery. */
+    agentIds?: string[];
+    /** Filter by health status (default: "healthy"). */
+    healthStatus?: string;
+}
+interface ToolCallRecord {
+    toolName: string;
+    arguments: Record<string, any>;
+    result?: any;
+    error?: string;
+    latencyMs: number;
+    turn: number;
+}
+interface ToolCallTrace {
+    calls: ToolCallRecord[];
+    totalTurns: number;
+    totalToolCalls: number;
+    finalResponse?: string;
+}
+/**
+ * Options for tool-calling in ctx.ai().
+ *
+ * Accepts multiple forms:
+ * - "discover": auto-discover all tools from control plane
+ * - ToolCallConfig: discover with filtering/progressive options
+ * - DiscoveryResult: use pre-fetched discovery results
+ * - AgentCapability[]: convert capability list directly
+ * - ToolSet: raw Vercel AI SDK tool map
+ */
+type ToolsOption = 'discover' | ToolCallConfig | DiscoveryResult | AgentCapability[] | (ReasonerCapability | SkillCapability)[] | ToolSet;
+interface AIToolRequestOptions extends AIRequestOptions {
+    /** Tool definitions for LLM tool calling. */
+    tools?: ToolsOption;
+    /** Maximum LLM turns in the tool-call loop. */
+    maxTurns?: number;
+    /** Maximum total tool calls allowed. */
+    maxToolCalls?: number;
+}
+/**
+ * Convert a single ReasonerCapability or SkillCapability to a Vercel AI SDK tool.
+ */
+declare function capabilityToTool(cap: ReasonerCapability | SkillCapability, agent: Agent): ToolSet[string];
+/**
+ * Convert a single capability to a metadata-only tool (no full schema).
+ * Used for progressive/lazy discovery.
+ */
+declare function capabilityToMetadataTool(cap: ReasonerCapability | SkillCapability, agent: Agent): ToolSet[string];
+/**
+ * Convert a list of capabilities into a Vercel AI SDK tool map.
+ */
+declare function capabilitiesToTools(capabilities: (AgentCapability | ReasonerCapability | SkillCapability)[], agent: Agent, metadataOnly?: boolean): ToolSet;
+declare function buildToolConfig(toolsParam: ToolsOption, agent: Agent): Promise<{
+    tools: ToolSet;
+    config: ToolCallConfig;
+    needsLazyHydration: boolean;
+}>;
+declare function executeToolCallLoop(agent: Agent, prompt: string, toolMap: ToolSet, config: ToolCallConfig, needsLazyHydration: boolean, buildModel: () => any, options?: AIRequestOptions): Promise<{
+    text: string;
+    trace: ToolCallTrace;
+}>;
+
 declare class ReasonerContext<TInput = any> {
     readonly input: TInput;
     readonly executionId: string;
@@ -455,7 +545,19 @@ declare class ReasonerContext<TInput = any> {
     ai<T>(prompt: string, options: AIRequestOptions & {
         schema: ZodSchema<T>;
     }): Promise<T>;
-    ai(prompt: string, options?: AIRequestOptions): Promise<string>;
+    ai(prompt: string, options?: AIToolRequestOptions): Promise<string>;
+    /**
+     * AI call with automatic tool calling via discover -> ai -> call loop.
+     *
+     * Discovers available capabilities, presents them as tools to the LLM,
+     * dispatches tool calls via agent.call(), and iterates until a final response.
+     *
+     * @returns Object with `text` (final response) and `trace` (observability data).
+     */
+    aiWithTools(prompt: string, options?: AIToolRequestOptions): Promise<{
+        text: string;
+        trace: ToolCallTrace;
+    }>;
     aiStream(prompt: string, options?: AIRequestOptions): Promise<AIStream>;
     call(target: string, input: any): Promise<any>;
     discover(options?: DiscoveryOptions): Promise<DiscoveryResult>;
@@ -1186,4 +1288,4 @@ declare class ApprovalClient {
     waitForApproval(executionId: string, opts?: WaitForApprovalOptions): Promise<ApprovalStatusResponse>;
 }
 
-export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalRequestResponse, type ApprovalStatusResponse, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, MCPClient, MCPClientRegistry, type MCPConfig, type MCPHealthSummary, type MCPServerConfig, type MCPTool, MCPToolRegistrar, type MCPToolRegistrarOptions, type MCPToolRegistration, type MemoryChangeEvent, MemoryClient, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, RateLimitError, type RateLimiterOptions, type RawResult, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, type VectorSearchOptions, type VectorSearchResult, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, buildProvider, createHarnessResult, createMetrics, createRawResult, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
+export { ACTIVE_STATUSES, AIClient, type AIConfig, type AIEmbeddingOptions, type AIRequestOptions, type AIStream, type AIToolRequestOptions, Agent, type AgentCapability, type AgentConfig, type AgentHandler, AgentRouter, type AgentRouterOptions, type AgentState, ApprovalClient, type ApprovalRequestResponse, type ApprovalStatusResponse, type AuditTrailExport, type AuditTrailFilters, type Awaitable, CANONICAL_STATUSES, type CompactCapability, type CompactDiscoveryResponse, DIDAuthenticator, type DIDIdentity, type DIDIdentityPackage, type DIDRegistrationRequest, type DIDRegistrationResponse, type DeploymentType, DidClient, DidInterface, DidManager, type DiscoveryFormat, type DiscoveryOptions, type DiscoveryPagination, type DiscoveryResponse, type DiscoveryResult, ExecutionContext, type ExecutionCredential, type ExecutionMetadata, ExecutionStatus, type ExecutionStatusValue, type GenerateCredentialOptions, type GenerateCredentialParams, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, type HarnessConfig, type HarnessOptions, type HarnessProvider, type HarnessResult, HarnessRunner, type HealthStatus, MCPClient, MCPClientRegistry, type MCPConfig, type MCPHealthSummary, type MCPServerConfig, type MCPTool, MCPToolRegistrar, type MCPToolRegistrarOptions, type MCPToolRegistration, type MemoryChangeEvent, MemoryClient, type MemoryConfig, MemoryEventClient, type MemoryEventHandler, MemoryInterface, type MemoryRequestMetadata, type MemoryRequestOptions, type MemoryScope, type MemoryWatchHandler, type Metrics, RateLimitError, type RateLimiterOptions, type RawResult, type ReasonerCapability, ReasonerContext, type ReasonerDefinition, type ReasonerHandler, type ReasonerOptions, type RequestApprovalPayload, SUPPORTED_PROVIDERS, type ServerlessAdapter, type ServerlessEvent, type ServerlessResponse, type SkillCapability, SkillContext, type SkillDefinition, type SkillHandler, type SkillOptions, StatelessRateLimiter, TERMINAL_STATUSES, type ToolCallConfig, type ToolCallRecord, type ToolCallTrace, type ToolsOption, type VectorSearchOptions, type VectorSearchResult, type WaitForApprovalOptions, type WorkflowCredential, type WorkflowMetadata, type WorkflowProgressOptions, WorkflowReporter, type ZodSchema, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createHarnessResult, createMetrics, createRawResult, executeToolCallLoop, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };

package/dist/index.js

@@ -6,7 +6,7 @@ import express from 'express';
 import rateLimit from 'express-rate-limit';
 import crypto2, { randomUUID, createHash } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
-import { generateObject, generateText, streamText, embed, embedMany } from 'ai';
+import { tool, jsonSchema, generateText, stepCountIs, generateObject, streamText, embed, embedMany } from 'ai';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
@@ -99,8 +99,8 @@ function isLargeSchema(schemaJson) {
   return estimateTokens(schemaJson) > LARGE_SCHEMA_TOKEN_THRESHOLD;
 }
 function buildPromptSuffix(schema, cwd) {
-  const jsonSchema = schemaToJsonSchema(schema);
-  const schemaJson = JSON.stringify(jsonSchema, null, 2);
+  const jsonSchema2 = schemaToJsonSchema(schema);
+  const schemaJson = JSON.stringify(jsonSchema2, null, 2);
   const outputPath = getOutputPath(cwd);
   if (isLargeSchema(schemaJson)) {
     const schemaPath = writeSchemaFile(schemaJson, cwd);
@@ -883,6 +883,299 @@ var ExecutionContext = class {
     return store.getStore();
   }
 };
+var DEFAULT_MAX_TURNS = 10;
+var DEFAULT_MAX_TOOL_CALLS = 25;
+var DEFAULT_HEALTH_STATUS = void 0;
+function invocationTargetToCallTarget(invocationTarget) {
+  if (invocationTarget.includes(":skill:")) {
+    const parts = invocationTarget.split(":skill:");
+    return `${parts[0]}.${parts[1]}`;
+  }
+  if (invocationTarget.includes(":")) {
+    const idx = invocationTarget.indexOf(":");
+    return `${invocationTarget.substring(0, idx)}.${invocationTarget.substring(idx + 1)}`;
+  }
+  return invocationTarget;
+}
+function makeExecute(agent, invocationTarget) {
+  const callTarget = invocationTargetToCallTarget(invocationTarget);
+  return async (args) => agent.call(callTarget, args);
+}
+function sanitizeToolName(invocationTarget) {
+  return invocationTarget.replace(/:/g, "__");
+}
+function unsanitizeToolName(sanitizedName) {
+  return sanitizedName.replace(/__/g, ":");
+}
+function capabilityToTool(cap, agent) {
+  const rawSchema = cap.inputSchema ?? { type: "object", properties: {} };
+  const schema = rawSchema.type ? rawSchema : { type: "object", properties: rawSchema };
+  return tool({
+    description: cap.description ?? `Call ${cap.invocationTarget}`,
+    inputSchema: jsonSchema(schema),
+    execute: makeExecute(agent, cap.invocationTarget)
+  });
+}
+function capabilityToMetadataTool(cap, agent) {
+  return tool({
+    description: cap.description ?? `Call ${cap.invocationTarget}`,
+    inputSchema: jsonSchema({ type: "object", properties: {} }),
+    execute: makeExecute(agent, cap.invocationTarget)
+  });
+}
+function capabilitiesToTools(capabilities, agent, metadataOnly = false) {
+  const tools = {};
+  const convert = metadataOnly ? capabilityToMetadataTool : capabilityToTool;
+  for (const cap of capabilities) {
+    if ("reasoners" in cap && "skills" in cap) {
+      const agentCap = cap;
+      for (const r of agentCap.reasoners) {
+        tools[sanitizeToolName(r.invocationTarget)] = convert(r, agent);
+      }
+      for (const s of agentCap.skills) {
+        tools[sanitizeToolName(s.invocationTarget)] = convert(s, agent);
+      }
+    } else {
+      const c = cap;
+      tools[sanitizeToolName(c.invocationTarget)] = convert(c, agent);
+    }
+  }
+  return tools;
+}
+function limitToolSet(tools, max) {
+  const entries = Object.entries(tools);
+  if (entries.length <= max) return tools;
+  const limited = {};
+  for (let i = 0; i < max; i++) {
+    limited[entries[i][0]] = entries[i][1];
+  }
+  return limited;
+}
+async function discoverTools(agent, config, hydrateSchemas = true) {
+  const discoveryOpts = {
+    tags: config.tags,
+    agentIds: config.agentIds,
+    includeInputSchema: hydrateSchemas,
+    includeOutputSchema: false,
+    includeDescriptions: true,
+    healthStatus: config.healthStatus ?? DEFAULT_HEALTH_STATUS
+  };
+  const result = await agent.discover(discoveryOpts);
+  if (!result.json) return { tools: {}, capabilities: [] };
+  const caps = result.json.capabilities;
+  let tools = capabilitiesToTools(caps, agent, !hydrateSchemas);
+  if (config.maxCandidateTools) {
+    tools = limitToolSet(tools, config.maxCandidateTools);
+  }
+  return { tools, capabilities: caps };
+}
+async function hydrateSelectedTools(agent, config, selectedNames) {
+  const discoveryOpts = {
+    tags: config.tags,
+    agentIds: config.agentIds,
+    includeInputSchema: true,
+    includeOutputSchema: false,
+    includeDescriptions: true,
+    healthStatus: config.healthStatus ?? DEFAULT_HEALTH_STATUS
+  };
+  const result = await agent.discover(discoveryOpts);
+  if (!result.json) return {};
+  const selectedSet = new Set(selectedNames.map(unsanitizeToolName));
+  const tools = {};
+  for (const cap of result.json.capabilities) {
+    for (const r of cap.reasoners) {
+      if (selectedSet.has(r.invocationTarget)) {
+        tools[sanitizeToolName(r.invocationTarget)] = capabilityToTool(r, agent);
+      }
+    }
+    for (const s of cap.skills) {
+      if (selectedSet.has(s.invocationTarget)) {
+        tools[sanitizeToolName(s.invocationTarget)] = capabilityToTool(s, agent);
+      }
+    }
+  }
+  if (config.maxHydratedTools) {
+    return limitToolSet(tools, config.maxHydratedTools);
+  }
+  return tools;
+}
+function isToolCallConfig(obj) {
+  const keys = [
+    "maxTurns",
+    "maxToolCalls",
+    "tags",
+    "schemaHydration",
+    "agentIds",
+    "healthStatus",
+    "fallbackBroadening",
+    "maxCandidateTools",
+    "maxHydratedTools"
+  ];
+  return typeof obj === "object" && !Array.isArray(obj) && keys.some((k) => k in obj);
+}
+function isDiscoveryResult(obj) {
+  return typeof obj === "object" && !Array.isArray(obj) && "raw" in obj && "format" in obj;
+}
+async function buildToolConfig(toolsParam, agent) {
+  const baseConfig = {
+    maxTurns: DEFAULT_MAX_TURNS,
+    maxToolCalls: DEFAULT_MAX_TOOL_CALLS,
+    schemaHydration: "eager",
+    fallbackBroadening: false,
+    healthStatus: DEFAULT_HEALTH_STATUS
+  };
+  if (toolsParam === "discover") {
+    const { tools } = await discoverTools(agent, baseConfig);
+    return { tools, config: baseConfig, needsLazyHydration: false };
+  }
+  if (isToolCallConfig(toolsParam)) {
+    const config = { ...baseConfig, ...toolsParam };
+    const isLazy = config.schemaHydration === "lazy";
+    const { tools } = await discoverTools(agent, config, !isLazy);
+    return { tools, config, needsLazyHydration: isLazy };
+  }
+  if (isDiscoveryResult(toolsParam)) {
+    if (toolsParam.json) {
+      const tools = capabilitiesToTools(toolsParam.json.capabilities, agent);
+      return { tools, config: baseConfig, needsLazyHydration: false };
+    }
+    return { tools: {}, config: baseConfig, needsLazyHydration: false };
+  }
+  if (Array.isArray(toolsParam)) {
+    const tools = capabilitiesToTools(toolsParam, agent);
+    return { tools, config: baseConfig, needsLazyHydration: false };
+  }
+  if (typeof toolsParam === "object") {
+    return { tools: toolsParam, config: baseConfig, needsLazyHydration: false };
+  }
+  throw new Error(
+    `Invalid tools parameter: expected "discover", ToolCallConfig, DiscoveryResult, capability array, or tool map, got ${typeof toolsParam}`
+  );
+}
+function wrapToolsWithObservability(toolMap, agent, trace, maxToolCalls, getCurrentTurn) {
+  let totalCalls = 0;
+  const observableTools = {};
+  for (const [name, t] of Object.entries(toolMap)) {
+    const originalTool = t;
+    observableTools[name] = tool({
+      description: originalTool.description ?? "",
+      inputSchema: originalTool.inputSchema,
+      execute: async (args) => {
+        totalCalls++;
+        trace.totalToolCalls = totalCalls;
+        if (totalCalls > maxToolCalls) {
+          const record2 = {
+            toolName: name,
+            arguments: args,
+            error: "Tool call limit reached",
+            latencyMs: 0,
+            turn: getCurrentTurn()
+          };
+          trace.calls.push(record2);
+          return { error: "Tool call limit reached. Please provide a final response." };
+        }
+        const record = {
+          toolName: name,
+          arguments: args,
+          latencyMs: 0,
+          turn: getCurrentTurn()
+        };
+        const invocationTarget = unsanitizeToolName(name);
+        const callTarget = invocationTargetToCallTarget(invocationTarget);
+        const start = Date.now();
+        try {
+          const result = await agent.call(callTarget, args);
+          record.result = result;
+          record.latencyMs = Date.now() - start;
+          trace.calls.push(record);
+          return result;
+        } catch (err) {
+          record.error = err.message ?? String(err);
+          record.latencyMs = Date.now() - start;
+          trace.calls.push(record);
+          return { error: record.error, tool: name };
+        }
+      }
+    });
+  }
+  return { tools: observableTools, getTotalCalls: () => totalCalls };
+}
+async function executeToolCallLoop(agent, prompt, toolMap, config, needsLazyHydration, buildModel, options = {}) {
+  const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+  const maxToolCalls = config.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS;
+  const trace = {
+    calls: [],
+    totalTurns: 0,
+    totalToolCalls: 0
+  };
+  let activeTools = toolMap;
+  if (needsLazyHydration) {
+    const selectionTools = {};
+    for (const [name, t] of Object.entries(toolMap)) {
+      const orig = t;
+      selectionTools[name] = tool({
+        description: orig.description ?? "",
+        inputSchema: orig.inputSchema
+        // No execute — AI SDK will stop after LLM selects tools
+      });
+    }
+    const selectionResult = await generateText({
+      model: buildModel(),
+      prompt,
+      system: options.system,
+      temperature: options.temperature,
+      maxOutputTokens: options.maxTokens,
+      tools: selectionTools,
+      stopWhen: stepCountIs(1)
+      // Stop after LLM's first response (tool selection)
+    });
+    const selectedNames = /* @__PURE__ */ new Set();
+    for (const step of selectionResult.steps) {
+      for (const tc of step.toolCalls) {
+        selectedNames.add(tc.toolName);
+      }
+    }
+    if (selectedNames.size > 0) {
+      const hydratedTools = await hydrateSelectedTools(
+        agent,
+        config,
+        Array.from(selectedNames)
+      );
+      if (Object.keys(hydratedTools).length > 0) {
+        activeTools = hydratedTools;
+      }
+    } else {
+      trace.totalTurns = selectionResult.steps.length;
+      trace.finalResponse = selectionResult.text;
+      return { text: selectionResult.text, trace };
+    }
+  }
+  let currentTurn = 0;
+  const { tools: observableTools } = wrapToolsWithObservability(
+    activeTools,
+    agent,
+    trace,
+    maxToolCalls,
+    () => currentTurn
+  );
+  const model = buildModel();
+  const result = await generateText({
+    model,
+    prompt,
+    system: options.system,
+    temperature: options.temperature,
+    maxOutputTokens: options.maxTokens,
+    tools: observableTools,
+    stopWhen: stepCountIs(maxTurns),
+    onStepFinish: () => {
+      currentTurn++;
+      trace.totalTurns = currentTurn;
+    }
+  });
+  trace.finalResponse = result.text;
+  trace.totalTurns = result.steps.length;
+  return { text: result.text, trace };
+}
 
 // src/context/ReasonerContext.ts
 var ReasonerContext = class {
@@ -923,8 +1216,37 @@ var ReasonerContext = class {
     this.did = params.did;
   }
   ai(prompt, options) {
+    if (options?.tools) {
+      return this.aiWithTools(prompt, options);
+    }
     return this.aiClient.generate(prompt, options);
   }
+  /**
+   * AI call with automatic tool calling via discover -> ai -> call loop.
+   *
+   * Discovers available capabilities, presents them as tools to the LLM,
+   * dispatches tool calls via agent.call(), and iterates until a final response.
+   *
+   * @returns Object with `text` (final response) and `trace` (observability data).
+   */
+  async aiWithTools(prompt, options = {}) {
+    const toolsParam = options.tools ?? "discover";
+    const { tools, config, needsLazyHydration } = await buildToolConfig(toolsParam, this.agent);
+    const mergedConfig = {
+      ...config,
+      maxTurns: options.maxTurns ?? config.maxTurns ?? 10,
+      maxToolCalls: options.maxToolCalls ?? config.maxToolCalls ?? 25
+    };
+    return executeToolCallLoop(
+      this.agent,
+      prompt,
+      tools,
+      mergedConfig,
+      needsLazyHydration,
+      () => this.aiClient.getModel(options),
+      options
+    );
+  }
   aiStream(prompt, options) {
     return this.aiClient.stream(prompt, options);
   }
@@ -1288,6 +1610,13 @@ var AIClient = class {
     );
     return result.embeddings;
   }
+  /**
+   * Build and return the AI model instance for a given set of options.
+   * Exposed for use by the tool-calling loop.
+   */
+  getModel(options = {}) {
+    return this.buildModel(options);
+  }
   buildModel(options) {
     const provider = options.provider ?? this.config.provider ?? "openai";
     const modelName = options.model ?? this.config.model ?? "gpt-4o";
@@ -1346,7 +1675,7 @@ var AIClient = class {
           apiKey: this.config.apiKey,
           baseURL: this.config.baseUrl ?? "https://openrouter.ai/api/v1"
         });
-        return openrouter(modelName);
+        return openrouter.chat(modelName);
       }
       case "ollama": {
         const ollama = createOpenAI({
@@ -1354,7 +1683,7 @@ var AIClient = class {
           // Ollama doesn't need real key
           baseURL: this.config.baseUrl ?? "http://localhost:11434/v1"
         });
-        return ollama(modelName);
+        return ollama.chat(modelName);
       }
       case "openai":
       default: {
@@ -2535,16 +2864,16 @@ function toJsonSchema(schema) {
     return {};
   }
   if (isZodSchema(schema)) {
-    const jsonSchema = zodToJsonSchema(schema, {
+    const jsonSchema2 = zodToJsonSchema(schema, {
       target: "openApi3",
       $refStrategy: "none"
       // Inline all definitions instead of using $ref
     });
-    if (typeof jsonSchema === "object" && jsonSchema !== null) {
-      const { $schema, ...rest } = jsonSchema;
+    if (typeof jsonSchema2 === "object" && jsonSchema2 !== null) {
+      const { $schema, ...rest } = jsonSchema2;
       return rest;
     }
-    return jsonSchema;
+    return jsonSchema2;
   }
   if (typeof schema === "object") {
     return schema;
@@ -2671,11 +3000,11 @@ var MCPClient = class {
     return this.lastHealthy;
   }
   normalizeTools(tools) {
-    return (tools ?? []).map((tool) => ({
-      name: tool?.name ?? "unknown",
-      description: tool?.description,
-      inputSchema: tool?.inputSchema ?? tool?.input_schema,
-      input_schema: tool?.input_schema
+    return (tools ?? []).map((tool2) => ({
+      name: tool2?.name ?? "unknown",
+      description: tool2?.description,
+      inputSchema: tool2?.inputSchema ?? tool2?.input_schema,
+      input_schema: tool2?.input_schema
     }));
   }
 };
@@ -2757,9 +3086,9 @@ var MCPToolRegistrar = class {
         continue;
       }
       const tools = await client.listTools();
-      for (const tool of tools) {
-        if (!tool?.name) continue;
-        const skillName = this.buildSkillName(client.alias, tool.name);
+      for (const tool2 of tools) {
+        if (!tool2?.name) continue;
+        const skillName = this.buildSkillName(client.alias, tool2.name);
         if (this.registered.has(skillName) || this.agent.skills.get(skillName)) {
           continue;
         }
@@ -2767,22 +3096,22 @@ var MCPToolRegistrar = class {
           skillName,
           async (ctx) => {
             const args = ctx.input && typeof ctx.input === "object" ? ctx.input : {};
-            const result = await client.callTool(tool.name, args);
+            const result = await client.callTool(tool2.name, args);
             return {
               status: "success",
               result,
               server: client.alias,
-              tool: tool.name
+              tool: tool2.name
             };
           },
           {
-            description: tool.description ?? `MCP tool ${tool.name} from ${client.alias}`,
-            inputSchema: tool.inputSchema ?? tool.input_schema ?? {},
+            description: tool2.description ?? `MCP tool ${tool2.name} from ${client.alias}`,
+            inputSchema: tool2.inputSchema ?? tool2.input_schema ?? {},
             tags: this.buildTags(client.alias)
           }
         );
         this.registered.add(skillName);
-        registrations.push({ server: client.alias, skillName, tool });
+        registrations.push({ server: client.alias, skillName, tool: tool2 });
         if (this.devMode) {
           console.info(`Registered MCP skill ${skillName}`);
         }
@@ -4202,6 +4531,6 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionStatus, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, WorkflowReporter, buildProvider, createHarnessResult, createMetrics, createRawResult, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
+export { ACTIVE_STATUSES, AIClient, Agent, AgentRouter, ApprovalClient, CANONICAL_STATUSES, DIDAuthenticator, DidClient, DidInterface, DidManager, ExecutionContext, ExecutionStatus, HEADER_CALLER_DID, HEADER_DID_NONCE, HEADER_DID_SIGNATURE, HEADER_DID_TIMESTAMP, HarnessRunner, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SUPPORTED_PROVIDERS, SkillContext, StatelessRateLimiter, TERMINAL_STATUSES, WorkflowReporter, buildProvider, buildToolConfig, capabilitiesToTools, capabilityToMetadataTool, capabilityToTool, createHarnessResult, createMetrics, createRawResult, executeToolCallLoop, getCurrentContext, getCurrentSkillContext, isActive, isTerminal, normalizeStatus };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map