@truefoundry/trueforge-core 0.0.0 → 0.1.0-rc.0

package/dist/core/runtime/DeferredTool.js

@@ -0,0 +1,321 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core/runtime/DeferredTool.ts
+var DeferredTool_exports = {};
+__export(DeferredTool_exports, {
+  DEFERRED_TOOLS_SERVER_ID: () => DEFERRED_TOOLS_SERVER_ID,
+  DeferredTool: () => DeferredTool,
+  GET_TOOL_INFO_NAME: () => GET_TOOL_INFO_NAME,
+  GET_TOOL_OUTPUT_SCHEMA_NAME: () => GET_TOOL_OUTPUT_SCHEMA_NAME,
+  LIST_TOOLS_NAME: () => LIST_TOOLS_NAME
+});
+module.exports = __toCommonJS(DeferredTool_exports);
+var import_dedent = __toESM(require("dedent"), 1);
+var import_zod = require("zod");
+var import_InstructionBuilder = require("../InstructionBuilder.js");
+var import_IMCPServer = require("../mcp/IMCPServer.js");
+var import_LocalToolMCP = require("../mcp/LocalToolMCP.js");
+var import_errorLogFields = require("../util/errorLogFields.js");
+var DEFERRED_TOOLS_SERVER_ID = "deferred-tools";
+var DEFERRED_TOOLS_INSTRUCTION = "deferred-tools-instructions";
+var LIST_TOOLS_NAME = "list_tools";
+var GET_TOOL_INFO_NAME = "get_tool_info";
+var GET_TOOL_OUTPUT_SCHEMA_NAME = "get_tool_output_schema";
+var CALL_TOOL_NAME = "call_tool";
+var MAX_DESCRIPTION_LENGTH = 200;
+var listToolsSchema = import_zod.z.object({
+  mcp_server: import_zod.z.string().describe("Name of the MCP server to list tools for.")
+});
+var getToolInfoSchema = import_zod.z.object({
+  mcp_server: import_zod.z.string().describe("Name of the MCP server."),
+  tool_name: import_zod.z.string().describe("Name of the tool to inspect.")
+});
+var getToolOutputSchemaSchema = import_zod.z.object({
+  mcp_server: import_zod.z.string().describe("Name of the MCP server."),
+  tool_name: import_zod.z.string().describe("Name of the tool to get output schema for.")
+});
+var callToolSchema = import_zod.z.object({
+  mcp_server: import_zod.z.string().describe("Name of the MCP server."),
+  tool_name: import_zod.z.string().describe("Name of the tool to call."),
+  input: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({}).describe("Arguments to pass to the tool.")
+});
+function isResolvedServerTools(result) {
+  return "tools" in result;
+}
+var DeferredTool = class extends import_LocalToolMCP.LocalToolMCP {
+  name = DEFERRED_TOOLS_SERVER_ID;
+  displayName = "DeferredTools";
+  description = "Deferred tool loading for user MCP servers";
+  serverMap;
+  tools;
+  logger;
+  constructor(servers, options) {
+    super({ tracing: options.tracing });
+    this.logger = options.logger.child({ module: "DeferredTool" });
+    this.serverMap = new Map(servers.map((s) => [s.name, s]));
+    this.tools = this.buildTools();
+  }
+  buildInstruction(builder) {
+    const servers = [...this.serverMap.values()];
+    const deferredServers = servers.filter((s) => !s.preload);
+    if (deferredServers.length === 0) return;
+    const deferredList = deferredServers.map((s) => s.description ? `- ${s.name}: "${s.description.slice(0, MAX_DESCRIPTION_LENGTH)}"` : `- ${s.name}`).join("\n");
+    builder.addSection(
+      DEFERRED_TOOLS_INSTRUCTION,
+      import_dedent.default`
+        The following MCP servers have deferred tool loading. Their tools are NOT pre-loaded.
+        ${deferredList}
+
+        The Agent MUST use ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} to discover tools before calling them.`
+    );
+  }
+  getTools() {
+    return this.tools;
+  }
+  async toolCallInfo(params, resolveUnderlyingTool) {
+    if (params.name !== CALL_TOOL_NAME) {
+      return super.toolCallInfo(params, resolveUnderlyingTool);
+    }
+    if (resolveUnderlyingTool === false) {
+      const base = await super.toolCallInfo(params, resolveUnderlyingTool);
+      return { ...base, is_deferred: true };
+    }
+    const parsed = callToolSchema.safeParse(params.arguments);
+    if (!parsed.success) {
+      this.logger.warn(`Failed to parse call_tool arguments`, {
+        tool: params.name,
+        errors: parsed.error.issues
+      });
+      return { ...await super.toolCallInfo(params), is_deferred: true };
+    }
+    const server = this.resolveServer(parsed.data.mcp_server);
+    if (!server) {
+      this.logger.warn(`Server not found for toolCallInfo`, {
+        mcpServer: parsed.data.mcp_server,
+        toolName: parsed.data.tool_name,
+        availableServers: [...this.serverMap.keys()]
+      });
+      return { ...await super.toolCallInfo(params), is_deferred: true };
+    }
+    const underlying = await server.toolCallInfo({
+      name: parsed.data.tool_name,
+      arguments: parsed.data.input
+    });
+    return { ...underlying, is_deferred: true };
+  }
+  resolveServer(name) {
+    return this.serverMap.get(name);
+  }
+  async resolveServerTools(mcpServer) {
+    const server = this.resolveServer(mcpServer);
+    if (!server) {
+      return (0, import_IMCPServer.toolResultResponse)({
+        text: JSON.stringify({ error: `MCP server '${mcpServer}' not found` }),
+        isError: true
+      });
+    }
+    const listResponse = await server.listTools();
+    if ((0, import_IMCPServer.isAuthRequired)(listResponse)) {
+      return listResponse;
+    }
+    const { result, ...metadata } = listResponse;
+    return { server, tools: result.tools, metadata };
+  }
+  buildTools() {
+    return [this.buildListTools(), this.buildGetToolInfo(), this.buildGetToolOutputSchema(), this.buildCallTool()];
+  }
+  buildListTools() {
+    return (0, import_LocalToolMCP.defineTool)({
+      name: LIST_TOOLS_NAME,
+      description: import_dedent.default`
+        List tool names available on an MCP server.
+        Returns tool names only — use ${GET_TOOL_INFO_NAME} to get full details before calling a tool.`,
+      schema: listToolsSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { server, tools, metadata } = resolved;
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: `${server.name}:
+  ${tools.map((t) => t.name).join(", ")}`,
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("list_tools failed", {
+            ...(0, import_errorLogFields.extractErrorLogFields)(error),
+            mcpServer: input.mcp_server
+          });
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({ error: `Failed to list tools for '${input.mcp_server}'.` }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildGetToolInfo() {
+    return (0, import_LocalToolMCP.defineTool)({
+      name: GET_TOOL_INFO_NAME,
+      description: import_dedent.default`
+        Get description, inputSchema and outputSchema for a specific tool on an MCP server.
+        If outputSchema is null, it will NOT be present in ${GET_TOOL_OUTPUT_SCHEMA_NAME} as well.
+        The Agent MUST call ${LIST_TOOLS_NAME} first to know which tools are available.`,
+      schema: getToolInfoSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { tools, metadata } = resolved;
+          const tool = tools.find((t) => t.name === input.tool_name);
+          if (!tool) {
+            return (0, import_IMCPServer.toolResultResponse)({
+              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),
+              overrides: metadata,
+              isError: true
+            });
+          }
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+              outputSchema: tool.outputSchema ?? null
+            }),
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("get_tool_info failed", {
+            ...(0, import_errorLogFields.extractErrorLogFields)(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({
+              error: `Failed to get tool info: ${error instanceof Error ? error.message : "unknown"}`
+            }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildGetToolOutputSchema() {
+    return (0, import_LocalToolMCP.defineTool)({
+      name: GET_TOOL_OUTPUT_SCHEMA_NAME,
+      description: import_dedent.default`
+        Get the outputSchema for a specific tool on an MCP server.
+        The Agent MUST not call ${GET_TOOL_OUTPUT_SCHEMA_NAME} and ${GET_TOOL_INFO_NAME} for the same tool.
+        The Agent MUST either call ${GET_TOOL_OUTPUT_SCHEMA_NAME} or ${GET_TOOL_INFO_NAME} before entering Code Mode.
+        The Agent must NOT assume the structure of a tool's response from its name or description alone.`,
+      schema: getToolOutputSchemaSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { tools, metadata } = resolved;
+          const tool = tools.find((t) => t.name === input.tool_name);
+          if (!tool) {
+            return (0, import_IMCPServer.toolResultResponse)({
+              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),
+              overrides: metadata,
+              isError: true
+            });
+          }
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({
+              outputSchema: tool.outputSchema ?? null
+            }),
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("get_tool_output_schema failed", {
+            ...(0, import_errorLogFields.extractErrorLogFields)(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({
+              error: `Failed to get output schema: ${error instanceof Error ? error.message : "unknown"}`
+            }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildCallTool() {
+    return (0, import_LocalToolMCP.defineTool)({
+      name: CALL_TOOL_NAME,
+      description: import_dedent.default`
+        Call a tool on an MCP server.
+        The Agent MUST call ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} before calling a tool.`,
+      schema: callToolSchema,
+      handler: async (input, approvalDecision) => {
+        const server = this.resolveServer(input.mcp_server);
+        if (!server) {
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({ error: `MCP server '${input.mcp_server}' not found` }),
+            isError: true
+          });
+        }
+        try {
+          const response = await server.callTool({ name: input.tool_name, arguments: input.input }, approvalDecision);
+          if ((0, import_IMCPServer.isAuthRequired)(response)) {
+            return response;
+          }
+          if ((0, import_IMCPServer.isApprovalRequiredResponse)(response)) return response;
+          if (!(0, import_IMCPServer.isCallToolResponseResult)(response)) {
+            throw new Error("Tool call returned an unexpected sub-agent response");
+          }
+          return response;
+        } catch (error) {
+          this.logger.error("call_tool failed", {
+            ...(0, import_errorLogFields.extractErrorLogFields)(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return (0, import_IMCPServer.toolResultResponse)({
+            text: JSON.stringify({ error: `Tool call failed: ${error instanceof Error ? error.message : "unknown"}` }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFERRED_TOOLS_SERVER_ID,
+  DeferredTool,
+  GET_TOOL_INFO_NAME,
+  GET_TOOL_OUTPUT_SCHEMA_NAME,
+  LIST_TOOLS_NAME
+});
+//# sourceMappingURL=DeferredTool.js.map

package/dist/core/runtime/DeferredTool.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/runtime/DeferredTool.ts"],"sourcesContent":["import type { CallToolRequest } from '@modelcontextprotocol/sdk/types.js';\nimport dedent from 'dedent';\nimport type { Logger } from 'winston';\nimport { z } from 'zod';\nimport type { ApprovalDecision } from '../events/schema';\nimport { InstructionBuilder } from '../InstructionBuilder';\nimport type { InternalToolCallInfo } from '../llm/LLMTypes';\nimport {\n  type AgentToolSchema,\n  type CallToolResponse,\n  isApprovalRequiredResponse,\n  isAuthRequired,\n  isCallToolResponseResult,\n  type IToolSet,\n  type ListToolsResolvedResponse,\n  toolResultResponse,\n} from '../mcp/IMCPServer';\nimport { defineTool, LocalToolMCP, type ToolDefinition } from '../mcp/LocalToolMCP';\nimport type { AgentTracing } from '../tracing/AgentTracing';\nimport { extractErrorLogFields } from '../util/errorLogFields';\n\nexport const DEFERRED_TOOLS_SERVER_ID = 'deferred-tools';\nconst DEFERRED_TOOLS_INSTRUCTION = 'deferred-tools-instructions';\nexport const LIST_TOOLS_NAME = 'list_tools';\nexport const GET_TOOL_INFO_NAME = 'get_tool_info';\nexport const GET_TOOL_OUTPUT_SCHEMA_NAME = 'get_tool_output_schema';\nconst CALL_TOOL_NAME = 'call_tool';\nconst MAX_DESCRIPTION_LENGTH = 200;\n\nconst listToolsSchema = z.object({\n  mcp_server: z.string().describe('Name of the MCP server to list tools for.'),\n});\n\nconst getToolInfoSchema = z.object({\n  mcp_server: z.string().describe('Name of the MCP server.'),\n  tool_name: z.string().describe('Name of the tool to inspect.'),\n});\n\nconst getToolOutputSchemaSchema = z.object({\n  mcp_server: z.string().describe('Name of the MCP server.'),\n  tool_name: z.string().describe('Name of the tool to get output schema for.'),\n});\n\nconst callToolSchema = z.object({\n  mcp_server: z.string().describe('Name of the MCP server.'),\n  tool_name: z.string().describe('Name of the tool to call.'),\n  input: z.record(z.string(), z.unknown()).default({}).describe('Arguments to pass to the tool.'),\n});\n\ninterface ResolvedServerTools {\n  server: IToolSet;\n  tools: AgentToolSchema[];\n  metadata: Omit<ListToolsResolvedResponse, 'result'>;\n}\n\nfunction isResolvedServerTools(result: CallToolResponse | ResolvedServerTools): result is ResolvedServerTools {\n  return 'tools' in result;\n}\n\nexport class DeferredTool extends LocalToolMCP {\n  readonly name = DEFERRED_TOOLS_SERVER_ID;\n  readonly displayName = 'DeferredTools';\n  override readonly description = 'Deferred tool loading for user MCP servers';\n\n  private readonly serverMap: Map<string, IToolSet>;\n  private readonly tools: ToolDefinition[];\n  private readonly logger: Logger;\n\n  constructor(\n    servers: readonly IToolSet[],\n    options: {\n      tracing: AgentTracing;\n      logger: Logger;\n    },\n  ) {\n    super({ tracing: options.tracing });\n    this.logger = options.logger.child({ module: 'DeferredTool' });\n    this.serverMap = new Map(servers.map(s => [s.name, s]));\n    this.tools = this.buildTools();\n  }\n\n  buildInstruction(builder: InstructionBuilder): void {\n    const servers = [...this.serverMap.values()];\n\n    // Membership follows `preload` only (origin/main). Selective `preload_tools` /\n    // `hasPreloadedTools` must not hide a server from deferred discovery instructions.\n    const deferredServers = servers.filter(s => !s.preload);\n\n    if (deferredServers.length === 0) return;\n\n    const deferredList = deferredServers\n      .map(s => (s.description ? `- ${s.name}: \"${s.description.slice(0, MAX_DESCRIPTION_LENGTH)}\"` : `- ${s.name}`))\n      .join('\\n');\n\n    builder.addSection(\n      DEFERRED_TOOLS_INSTRUCTION,\n      dedent`\n        The following MCP servers have deferred tool loading. Their tools are NOT pre-loaded.\n        ${deferredList}\n\n        The Agent MUST use ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} to discover tools before calling them.`,\n    );\n  }\n\n  protected getTools(): ToolDefinition[] {\n    return this.tools;\n  }\n\n  override async toolCallInfo(\n    params: CallToolRequest['params'],\n    resolveUnderlyingTool?: boolean,\n  ): Promise<InternalToolCallInfo> {\n    if (params.name !== CALL_TOOL_NAME) {\n      return super.toolCallInfo(params, resolveUnderlyingTool);\n    }\n    if (resolveUnderlyingTool === false) {\n      const base = await super.toolCallInfo(params, resolveUnderlyingTool);\n      return { ...base, is_deferred: true };\n    }\n    const parsed = callToolSchema.safeParse(params.arguments);\n    if (!parsed.success) {\n      this.logger.warn(`Failed to parse call_tool arguments`, {\n        tool: params.name,\n        errors: parsed.error.issues,\n      });\n      return { ...(await super.toolCallInfo(params)), is_deferred: true };\n    }\n    const server = this.resolveServer(parsed.data.mcp_server);\n    if (!server) {\n      this.logger.warn(`Server not found for toolCallInfo`, {\n        mcpServer: parsed.data.mcp_server,\n        toolName: parsed.data.tool_name,\n        availableServers: [...this.serverMap.keys()],\n      });\n      return { ...(await super.toolCallInfo(params)), is_deferred: true };\n    }\n    const underlying = await server.toolCallInfo({\n      name: parsed.data.tool_name,\n      arguments: parsed.data.input,\n    });\n    return { ...underlying, is_deferred: true };\n  }\n\n  private resolveServer(name: string): IToolSet | undefined {\n    return this.serverMap.get(name);\n  }\n\n  private async resolveServerTools(mcpServer: string): Promise<CallToolResponse | ResolvedServerTools> {\n    const server = this.resolveServer(mcpServer);\n    if (!server) {\n      return toolResultResponse({\n        text: JSON.stringify({ error: `MCP server '${mcpServer}' not found` }),\n        isError: true,\n      });\n    }\n\n    const listResponse = await server.listTools();\n    if (isAuthRequired(listResponse)) {\n      return listResponse;\n    }\n    const { result, ...metadata } = listResponse;\n    return { server, tools: result.tools, metadata };\n  }\n\n  private buildTools(): ToolDefinition[] {\n    return [this.buildListTools(), this.buildGetToolInfo(), this.buildGetToolOutputSchema(), this.buildCallTool()];\n  }\n\n  private buildListTools(): ToolDefinition {\n    return defineTool({\n      name: LIST_TOOLS_NAME,\n      description: dedent`\n        List tool names available on an MCP server.\n        Returns tool names only — use ${GET_TOOL_INFO_NAME} to get full details before calling a tool.`,\n      schema: listToolsSchema,\n      handler: async (input: { mcp_server: string }) => {\n        try {\n          const resolved = await this.resolveServerTools(input.mcp_server);\n          if (!isResolvedServerTools(resolved)) return resolved;\n          const { server, tools, metadata } = resolved;\n          return toolResultResponse({\n            text: `${server.name}:\\n  ${tools.map(t => t.name).join(', ')}`,\n            overrides: metadata,\n          });\n        } catch (error) {\n          this.logger.error('list_tools failed', {\n            ...extractErrorLogFields(error),\n            mcpServer: input.mcp_server,\n          });\n          return toolResultResponse({\n            text: JSON.stringify({ error: `Failed to list tools for '${input.mcp_server}'.` }),\n            isError: true,\n          });\n        }\n      },\n    });\n  }\n\n  private buildGetToolInfo(): ToolDefinition {\n    return defineTool({\n      name: GET_TOOL_INFO_NAME,\n      description: dedent`\n        Get description, inputSchema and outputSchema for a specific tool on an MCP server.\n        If outputSchema is null, it will NOT be present in ${GET_TOOL_OUTPUT_SCHEMA_NAME} as well.\n        The Agent MUST call ${LIST_TOOLS_NAME} first to know which tools are available.`,\n      schema: getToolInfoSchema,\n      handler: async (input: { mcp_server: string; tool_name: string }) => {\n        try {\n          const resolved = await this.resolveServerTools(input.mcp_server);\n          if (!isResolvedServerTools(resolved)) return resolved;\n          const { tools, metadata } = resolved;\n          const tool = tools.find(t => t.name === input.tool_name);\n          if (!tool) {\n            return toolResultResponse({\n              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),\n              overrides: metadata,\n              isError: true,\n            });\n          }\n\n          return toolResultResponse({\n            text: JSON.stringify({\n              description: tool.description,\n              inputSchema: tool.inputSchema,\n              outputSchema: tool.outputSchema ?? null,\n            }),\n            overrides: metadata,\n          });\n        } catch (error) {\n          this.logger.error('get_tool_info failed', {\n            ...extractErrorLogFields(error),\n            mcpServer: input.mcp_server,\n            toolName: input.tool_name,\n          });\n          return toolResultResponse({\n            text: JSON.stringify({\n              error: `Failed to get tool info: ${error instanceof Error ? error.message : 'unknown'}`,\n            }),\n            isError: true,\n          });\n        }\n      },\n    });\n  }\n\n  private buildGetToolOutputSchema(): ToolDefinition {\n    return defineTool({\n      name: GET_TOOL_OUTPUT_SCHEMA_NAME,\n      description: dedent`\n        Get the outputSchema for a specific tool on an MCP server.\n        The Agent MUST not call ${GET_TOOL_OUTPUT_SCHEMA_NAME} and ${GET_TOOL_INFO_NAME} for the same tool.\n        The Agent MUST either call ${GET_TOOL_OUTPUT_SCHEMA_NAME} or ${GET_TOOL_INFO_NAME} before entering Code Mode.\n        The Agent must NOT assume the structure of a tool's response from its name or description alone.`,\n      schema: getToolOutputSchemaSchema,\n      handler: async (input: { mcp_server: string; tool_name: string }) => {\n        try {\n          const resolved = await this.resolveServerTools(input.mcp_server);\n          if (!isResolvedServerTools(resolved)) return resolved;\n          const { tools, metadata } = resolved;\n          const tool = tools.find(t => t.name === input.tool_name);\n          if (!tool) {\n            return toolResultResponse({\n              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),\n              overrides: metadata,\n              isError: true,\n            });\n          }\n\n          return toolResultResponse({\n            text: JSON.stringify({\n              outputSchema: tool.outputSchema ?? null,\n            }),\n            overrides: metadata,\n          });\n        } catch (error) {\n          this.logger.error('get_tool_output_schema failed', {\n            ...extractErrorLogFields(error),\n            mcpServer: input.mcp_server,\n            toolName: input.tool_name,\n          });\n          return toolResultResponse({\n            text: JSON.stringify({\n              error: `Failed to get output schema: ${error instanceof Error ? error.message : 'unknown'}`,\n            }),\n            isError: true,\n          });\n        }\n      },\n    });\n  }\n\n  private buildCallTool(): ToolDefinition {\n    return defineTool({\n      name: CALL_TOOL_NAME,\n      description: dedent`\n        Call a tool on an MCP server.\n        The Agent MUST call ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} before calling a tool.`,\n      schema: callToolSchema,\n      handler: async (\n        input: { mcp_server: string; tool_name: string; input: Record<string, unknown> },\n        approvalDecision?: ApprovalDecision,\n      ) => {\n        const server = this.resolveServer(input.mcp_server);\n        if (!server) {\n          return toolResultResponse({\n            text: JSON.stringify({ error: `MCP server '${input.mcp_server}' not found` }),\n            isError: true,\n          });\n        }\n\n        try {\n          const response = await server.callTool({ name: input.tool_name, arguments: input.input }, approvalDecision);\n\n          if (isAuthRequired(response)) {\n            return response;\n          }\n\n          if (isApprovalRequiredResponse(response)) return response;\n\n          if (!isCallToolResponseResult(response)) {\n            throw new Error('Tool call returned an unexpected sub-agent response');\n          }\n\n          return response;\n        } catch (error) {\n          this.logger.error('call_tool failed', {\n            ...extractErrorLogFields(error),\n            mcpServer: input.mcp_server,\n            toolName: input.tool_name,\n          });\n          return toolResultResponse({\n            text: JSON.stringify({ error: `Tool call failed: ${error instanceof Error ? error.message : 'unknown'}` }),\n            isError: true,\n          });\n        }\n      },\n    });\n  }\n}\n"],"mappings":"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","names":["dedent"]}

package/dist/core/runtime/DeferredTool.mjs

@@ -0,0 +1,287 @@
+// src/core/runtime/DeferredTool.ts
+import dedent from "dedent";
+import { z } from "zod";
+import "../InstructionBuilder.mjs";
+import {
+  isApprovalRequiredResponse,
+  isAuthRequired,
+  isCallToolResponseResult,
+  toolResultResponse
+} from "../mcp/IMCPServer.mjs";
+import { defineTool, LocalToolMCP } from "../mcp/LocalToolMCP.mjs";
+import { extractErrorLogFields } from "../util/errorLogFields.mjs";
+var DEFERRED_TOOLS_SERVER_ID = "deferred-tools";
+var DEFERRED_TOOLS_INSTRUCTION = "deferred-tools-instructions";
+var LIST_TOOLS_NAME = "list_tools";
+var GET_TOOL_INFO_NAME = "get_tool_info";
+var GET_TOOL_OUTPUT_SCHEMA_NAME = "get_tool_output_schema";
+var CALL_TOOL_NAME = "call_tool";
+var MAX_DESCRIPTION_LENGTH = 200;
+var listToolsSchema = z.object({
+  mcp_server: z.string().describe("Name of the MCP server to list tools for.")
+});
+var getToolInfoSchema = z.object({
+  mcp_server: z.string().describe("Name of the MCP server."),
+  tool_name: z.string().describe("Name of the tool to inspect.")
+});
+var getToolOutputSchemaSchema = z.object({
+  mcp_server: z.string().describe("Name of the MCP server."),
+  tool_name: z.string().describe("Name of the tool to get output schema for.")
+});
+var callToolSchema = z.object({
+  mcp_server: z.string().describe("Name of the MCP server."),
+  tool_name: z.string().describe("Name of the tool to call."),
+  input: z.record(z.string(), z.unknown()).default({}).describe("Arguments to pass to the tool.")
+});
+function isResolvedServerTools(result) {
+  return "tools" in result;
+}
+var DeferredTool = class extends LocalToolMCP {
+  name = DEFERRED_TOOLS_SERVER_ID;
+  displayName = "DeferredTools";
+  description = "Deferred tool loading for user MCP servers";
+  serverMap;
+  tools;
+  logger;
+  constructor(servers, options) {
+    super({ tracing: options.tracing });
+    this.logger = options.logger.child({ module: "DeferredTool" });
+    this.serverMap = new Map(servers.map((s) => [s.name, s]));
+    this.tools = this.buildTools();
+  }
+  buildInstruction(builder) {
+    const servers = [...this.serverMap.values()];
+    const deferredServers = servers.filter((s) => !s.preload);
+    if (deferredServers.length === 0) return;
+    const deferredList = deferredServers.map((s) => s.description ? `- ${s.name}: "${s.description.slice(0, MAX_DESCRIPTION_LENGTH)}"` : `- ${s.name}`).join("\n");
+    builder.addSection(
+      DEFERRED_TOOLS_INSTRUCTION,
+      dedent`
+        The following MCP servers have deferred tool loading. Their tools are NOT pre-loaded.
+        ${deferredList}
+
+        The Agent MUST use ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} to discover tools before calling them.`
+    );
+  }
+  getTools() {
+    return this.tools;
+  }
+  async toolCallInfo(params, resolveUnderlyingTool) {
+    if (params.name !== CALL_TOOL_NAME) {
+      return super.toolCallInfo(params, resolveUnderlyingTool);
+    }
+    if (resolveUnderlyingTool === false) {
+      const base = await super.toolCallInfo(params, resolveUnderlyingTool);
+      return { ...base, is_deferred: true };
+    }
+    const parsed = callToolSchema.safeParse(params.arguments);
+    if (!parsed.success) {
+      this.logger.warn(`Failed to parse call_tool arguments`, {
+        tool: params.name,
+        errors: parsed.error.issues
+      });
+      return { ...await super.toolCallInfo(params), is_deferred: true };
+    }
+    const server = this.resolveServer(parsed.data.mcp_server);
+    if (!server) {
+      this.logger.warn(`Server not found for toolCallInfo`, {
+        mcpServer: parsed.data.mcp_server,
+        toolName: parsed.data.tool_name,
+        availableServers: [...this.serverMap.keys()]
+      });
+      return { ...await super.toolCallInfo(params), is_deferred: true };
+    }
+    const underlying = await server.toolCallInfo({
+      name: parsed.data.tool_name,
+      arguments: parsed.data.input
+    });
+    return { ...underlying, is_deferred: true };
+  }
+  resolveServer(name) {
+    return this.serverMap.get(name);
+  }
+  async resolveServerTools(mcpServer) {
+    const server = this.resolveServer(mcpServer);
+    if (!server) {
+      return toolResultResponse({
+        text: JSON.stringify({ error: `MCP server '${mcpServer}' not found` }),
+        isError: true
+      });
+    }
+    const listResponse = await server.listTools();
+    if (isAuthRequired(listResponse)) {
+      return listResponse;
+    }
+    const { result, ...metadata } = listResponse;
+    return { server, tools: result.tools, metadata };
+  }
+  buildTools() {
+    return [this.buildListTools(), this.buildGetToolInfo(), this.buildGetToolOutputSchema(), this.buildCallTool()];
+  }
+  buildListTools() {
+    return defineTool({
+      name: LIST_TOOLS_NAME,
+      description: dedent`
+        List tool names available on an MCP server.
+        Returns tool names only — use ${GET_TOOL_INFO_NAME} to get full details before calling a tool.`,
+      schema: listToolsSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { server, tools, metadata } = resolved;
+          return toolResultResponse({
+            text: `${server.name}:
+  ${tools.map((t) => t.name).join(", ")}`,
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("list_tools failed", {
+            ...extractErrorLogFields(error),
+            mcpServer: input.mcp_server
+          });
+          return toolResultResponse({
+            text: JSON.stringify({ error: `Failed to list tools for '${input.mcp_server}'.` }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildGetToolInfo() {
+    return defineTool({
+      name: GET_TOOL_INFO_NAME,
+      description: dedent`
+        Get description, inputSchema and outputSchema for a specific tool on an MCP server.
+        If outputSchema is null, it will NOT be present in ${GET_TOOL_OUTPUT_SCHEMA_NAME} as well.
+        The Agent MUST call ${LIST_TOOLS_NAME} first to know which tools are available.`,
+      schema: getToolInfoSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { tools, metadata } = resolved;
+          const tool = tools.find((t) => t.name === input.tool_name);
+          if (!tool) {
+            return toolResultResponse({
+              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),
+              overrides: metadata,
+              isError: true
+            });
+          }
+          return toolResultResponse({
+            text: JSON.stringify({
+              description: tool.description,
+              inputSchema: tool.inputSchema,
+              outputSchema: tool.outputSchema ?? null
+            }),
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("get_tool_info failed", {
+            ...extractErrorLogFields(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return toolResultResponse({
+            text: JSON.stringify({
+              error: `Failed to get tool info: ${error instanceof Error ? error.message : "unknown"}`
+            }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildGetToolOutputSchema() {
+    return defineTool({
+      name: GET_TOOL_OUTPUT_SCHEMA_NAME,
+      description: dedent`
+        Get the outputSchema for a specific tool on an MCP server.
+        The Agent MUST not call ${GET_TOOL_OUTPUT_SCHEMA_NAME} and ${GET_TOOL_INFO_NAME} for the same tool.
+        The Agent MUST either call ${GET_TOOL_OUTPUT_SCHEMA_NAME} or ${GET_TOOL_INFO_NAME} before entering Code Mode.
+        The Agent must NOT assume the structure of a tool's response from its name or description alone.`,
+      schema: getToolOutputSchemaSchema,
+      handler: async (input) => {
+        try {
+          const resolved = await this.resolveServerTools(input.mcp_server);
+          if (!isResolvedServerTools(resolved)) return resolved;
+          const { tools, metadata } = resolved;
+          const tool = tools.find((t) => t.name === input.tool_name);
+          if (!tool) {
+            return toolResultResponse({
+              text: JSON.stringify({ error: `Tool '${input.tool_name}' not found on server '${input.mcp_server}'` }),
+              overrides: metadata,
+              isError: true
+            });
+          }
+          return toolResultResponse({
+            text: JSON.stringify({
+              outputSchema: tool.outputSchema ?? null
+            }),
+            overrides: metadata
+          });
+        } catch (error) {
+          this.logger.error("get_tool_output_schema failed", {
+            ...extractErrorLogFields(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return toolResultResponse({
+            text: JSON.stringify({
+              error: `Failed to get output schema: ${error instanceof Error ? error.message : "unknown"}`
+            }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+  buildCallTool() {
+    return defineTool({
+      name: CALL_TOOL_NAME,
+      description: dedent`
+        Call a tool on an MCP server.
+        The Agent MUST call ${LIST_TOOLS_NAME} and ${GET_TOOL_INFO_NAME} before calling a tool.`,
+      schema: callToolSchema,
+      handler: async (input, approvalDecision) => {
+        const server = this.resolveServer(input.mcp_server);
+        if (!server) {
+          return toolResultResponse({
+            text: JSON.stringify({ error: `MCP server '${input.mcp_server}' not found` }),
+            isError: true
+          });
+        }
+        try {
+          const response = await server.callTool({ name: input.tool_name, arguments: input.input }, approvalDecision);
+          if (isAuthRequired(response)) {
+            return response;
+          }
+          if (isApprovalRequiredResponse(response)) return response;
+          if (!isCallToolResponseResult(response)) {
+            throw new Error("Tool call returned an unexpected sub-agent response");
+          }
+          return response;
+        } catch (error) {
+          this.logger.error("call_tool failed", {
+            ...extractErrorLogFields(error),
+            mcpServer: input.mcp_server,
+            toolName: input.tool_name
+          });
+          return toolResultResponse({
+            text: JSON.stringify({ error: `Tool call failed: ${error instanceof Error ? error.message : "unknown"}` }),
+            isError: true
+          });
+        }
+      }
+    });
+  }
+};
+export {
+  DEFERRED_TOOLS_SERVER_ID,
+  DeferredTool,
+  GET_TOOL_INFO_NAME,
+  GET_TOOL_OUTPUT_SCHEMA_NAME,
+  LIST_TOOLS_NAME
+};
+//# sourceMappingURL=DeferredTool.mjs.map