@mcpc-tech/core 0.3.11 → 0.3.13

package/index.mjs

@@ -7059,10 +7059,10 @@ var stringbool = (...args) => _stringbool({
   String: ZodString
 }, ...args);
 function json(params) {
-  const jsonSchema2 = lazy(() => {
-    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema2), record(string2(), jsonSchema2)]);
+  const jsonSchema3 = lazy(() => {
+    return union([string2(params), number2(), boolean2(), _null3(), array(jsonSchema3), record(string2(), jsonSchema3)]);
   });
-  return jsonSchema2;
+  return jsonSchema3;
 }
 function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
@@ -14879,17 +14879,17 @@ var Client = class extends Protocol {
     this._cachedToolOutputValidators.clear();
     this._cachedKnownTaskTools.clear();
     this._cachedRequiredTaskTools.clear();
-    for (const tool of tools) {
-      if (tool.outputSchema) {
-        const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
-        this._cachedToolOutputValidators.set(tool.name, toolValidator);
+    for (const tool2 of tools) {
+      if (tool2.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool2.outputSchema);
+        this._cachedToolOutputValidators.set(tool2.name, toolValidator);
       }
-      const taskSupport = tool.execution?.taskSupport;
+      const taskSupport = tool2.execution?.taskSupport;
       if (taskSupport === "required" || taskSupport === "optional") {
-        this._cachedKnownTaskTools.add(tool.name);
+        this._cachedKnownTaskTools.add(tool2.name);
       }
       if (taskSupport === "required") {
-        this._cachedRequiredTaskTools.add(tool.name);
+        this._cachedRequiredTaskTools.add(tool2.name);
       }
     }
   }
@@ -17248,14 +17248,14 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
       acquiredKeys.push(defKey);
       allClients[serverId] = client;
       const { tools } = await client.listTools();
-      tools.forEach((tool) => {
-        const toolNameWithScope = `${name}.${tool.name}`;
-        const internalToolName = tool.name;
+      tools.forEach((tool2) => {
+        const toolNameWithScope = `${name}.${tool2.name}`;
+        const internalToolName = tool2.name;
         const rawToolId = `${serverId}_${internalToolName}`;
         const toolId = sanitizePropertyKey(rawToolId);
         if (filterIn && !filterIn({
           action: internalToolName,
-          tool,
+          tool: tool2,
           mcpName: name,
           toolNameWithScope,
           internalToolName,
@@ -17270,7 +17270,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
           timeout: def.toolCallTimeout
         });
         allTools[toolId] = {
-          ...tool,
+          ...tool2,
           execute,
           _originalName: toolNameWithScope
         };
@@ -17333,13 +17333,13 @@ var createConfigPlugin = () => ({
   name: "built-in-config",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const config2 = server.findToolConfig?.(context2.toolName);
     if (config2?.description) {
-      tool.description = config2.description;
+      tool2.description = config2.description;
     }
-    return tool;
+    return tool2;
   }
 });
 var config_plugin_default = createConfigPlugin();
@@ -17349,10 +17349,10 @@ var createToolNameMappingPlugin = () => ({
   name: "built-in-tool-name-mapping",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const toolName = context2.toolName;
-    const originalName = tool._originalName || toolName;
+    const originalName = tool2._originalName || toolName;
     const dotNotation = originalName.replace(/_/g, ".");
     const underscoreNotation = originalName.replace(/\./g, "_");
     if (dotNotation !== originalName && server.toolNameMapping) {
@@ -17364,7 +17364,7 @@ var createToolNameMappingPlugin = () => ({
     if (originalName !== toolName && server.toolNameMapping) {
       server.toolNameMapping.set(originalName, toolName);
     }
-    return tool;
+    return tool2;
   }
 });
 var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
@@ -17857,13 +17857,13 @@ var PromptUtils = {
    * Generate tool list for descriptions
    */
   generateToolList: (tools) => {
-    return tools.filter((tool) => !tool.hide).map((tool) => `<tool name="${tool.name}"${tool.description ? ` description="${tool.description}"` : ""}/>`).join("\n");
+    return tools.filter((tool2) => !tool2.hide).map((tool2) => `<tool name="${tool2.name}"${tool2.description ? ` description="${tool2.description}"` : ""}/>`).join("\n");
   },
   /**
    * Generate hidden tool list for descriptions
    */
   generateHiddenToolList: (tools) => {
-    return tools.filter((tool) => tool.hide).map((tool) => `<tool name="${tool.name}" hide/>`).join("\n");
+    return tools.filter((tool2) => tool2.hide).map((tool2) => `<tool name="${tool2.name}" hide/>`).join("\n");
   },
   /**
    * Format workflow steps for display
@@ -19648,12 +19648,12 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
   }
   buildDepGroups() {
     const depGroups = {};
-    this.toolNameToDetailList.forEach(([toolName, tool]) => {
-      if (tool?.inputSchema) {
+    this.toolNameToDetailList.forEach(([toolName, tool2]) => {
+      if (tool2?.inputSchema) {
         depGroups[toolName] = {
           type: "object",
-          description: tool.description || `Tool: ${toolName}`,
-          ...tool.inputSchema
+          description: tool2.description || `Tool: ${toolName}`,
+          ...tool2.inputSchema
         };
       } else {
         const toolSchema = this.server.getHiddenToolSchema(toolName);
@@ -19710,10 +19710,10 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
   }
   buildSystemPrompt(userRequest, agenticSchema, context2) {
     const toolList = this.allToolNames.map((name) => {
-      const tool = this.toolNameToDetailList.find(([toolName]) => toolName === name);
+      const tool2 = this.toolNameToDetailList.find(([toolName]) => toolName === name);
       const toolSchema = this.server.getHiddenToolSchema(name);
-      if (tool && tool[1]) {
-        return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
+      if (tool2 && tool2[1]) {
+        return `- ${name}: ${tool2[1].description || `Tool: ${name}`}`;
       } else if (toolSchema) {
         return `- ${name}: ${toolSchema.description}`;
       }
@@ -19740,7 +19740,7 @@ ${JSON.stringify(context2, null, 2)}`;
 ## Current Task
 You will now use agentic sampling to complete the following task: "${userRequest}"${contextInfo}
 
-When you need to use a tool, specify the tool name in 'action' and provide tool-specific parameters as additional properties.`;
+When you need to use a tool, specify the tool name in 'useTool' and provide tool-specific parameters as additional properties.`;
     return this.formatPromptForMode({
       prompt: basePrompt + taskPrompt,
       schema: agenticSchema
@@ -19920,6 +19920,763 @@ var createWorkflowSamplingModePlugin = () => ({
 });
 var mode_workflow_sampling_plugin_default = createWorkflowSamplingModePlugin();
 
+// __mcpc__core_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
+function convertAISDKToMCPMessages(prompt) {
+  const messages = [];
+  for (const msg of prompt) {
+    if (msg.role === "system") continue;
+    const role = msg.role === "assistant" ? "assistant" : "user";
+    const textParts = msg.content.filter((c) => c.type === "text");
+    const toolCalls = msg.content.filter((c) => c.type === "tool-call");
+    const toolResults = msg.content.filter((c) => c.type === "tool-result");
+    const parts = [];
+    if (textParts.length > 0) {
+      parts.push(textParts.map((c) => c.text).join("\n"));
+    }
+    if (toolCalls.length > 0) {
+      const calls = toolCalls.map((c) => {
+        const call = c;
+        const toolArgs = call.args ?? call.input ?? {};
+        return `<use_tool tool="${call.toolName}">
+${JSON.stringify(toolArgs)}
+</use_tool>`;
+      });
+      parts.push(calls.join("\n"));
+    }
+    if (toolResults.length > 0) {
+      const results = toolResults.map((c) => {
+        const result = c;
+        const resultValue = result.result ?? result.output ?? "undefined";
+        const output = JSON.stringify(resultValue);
+        return `Tool "${result.toolName}" result:
+${output}`;
+      });
+      parts.push(results.join("\n\n"));
+    }
+    const text = parts.join("\n\n");
+    if (text) {
+      messages.push({
+        role,
+        content: {
+          type: "text",
+          text
+        }
+      });
+    }
+  }
+  return messages;
+}
+function convertMCPStopReasonToAISDK(stopReason) {
+  if (stopReason === "endTurn" || stopReason === "stopSequence") {
+    return "stop";
+  }
+  if (stopReason === "maxTokens") return "length";
+  return stopReason ?? "unknown";
+}
+
+// __mcpc__core_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var MCPSamplingLanguageModel = class {
+  specificationVersion = "v2";
+  provider;
+  modelId;
+  supportedUrls = {};
+  server;
+  modelPreferences;
+  constructor(config2) {
+    this.server = config2.server;
+    this.modelId = "";
+    this.provider = "mcp-client";
+    this.modelPreferences = config2.modelPreferences;
+  }
+  /**
+   * Generate a response using MCP's createMessage capability
+   */
+  async doGenerate(options) {
+    const messages = this.convertMessages(options.prompt);
+    let systemPrompt;
+    for (const msg of options.prompt) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+        break;
+      }
+    }
+    const useNativeTools = this.supportsSamplingTools();
+    systemPrompt = this.injectResponseFormatInstructions(systemPrompt, options.responseFormat, useNativeTools);
+    systemPrompt = this.injectToolInstructions(systemPrompt, options.tools, useNativeTools);
+    const createMessageParams = {
+      systemPrompt,
+      messages,
+      maxTokens: options.maxOutputTokens ?? 55e3,
+      modelPreferences: this.modelPreferences
+    };
+    if (useNativeTools && options.tools && options.tools.length > 0) {
+      createMessageParams.tools = this.convertAISDKToolsToMCP(options.tools);
+      createMessageParams.toolChoice = {
+        mode: "auto"
+      };
+    }
+    const result = await this.server.createMessage(createMessageParams);
+    const content = [];
+    if (useNativeTools) {
+      const contentArray = Array.isArray(result.content) ? result.content : [
+        result.content
+      ];
+      for (const block of contentArray) {
+        if (block.type === "text" && "text" in block) {
+          content.push({
+            type: "text",
+            text: block.text
+          });
+        } else if (block.type === "tool_use" && "id" in block && "name" in block) {
+          const toolInput = block.input || {};
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: JSON.stringify(toolInput)
+          });
+        }
+      }
+    } else {
+      if (result.content.type === "text" && result.content.text) {
+        const { text, toolCalls } = this.extractToolCalls(result.content.text, options.tools);
+        if (text.trim()) {
+          const textContent = {
+            type: "text",
+            text
+          };
+          content.push(textContent);
+        }
+        content.push(...toolCalls);
+      }
+    }
+    const finishReason = this.mapStopReason(result.stopReason);
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: 0
+      },
+      request: {
+        body: JSON.stringify({
+          systemPrompt,
+          messages
+        })
+      },
+      response: {
+        modelId: result.model
+      },
+      warnings: []
+    };
+  }
+  /**
+   * Stream a response using MCP's createMessage capability
+   *
+   * Since MCP doesn't support native streaming, we generate the full response
+   * and emit it as stream events following AI SDK's protocol.
+   */
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    const stream = new ReadableStream({
+      start(controller) {
+        if (result.response?.modelId) {
+          controller.enqueue({
+            type: "response-metadata",
+            modelId: result.response.modelId,
+            ...result.response.headers && {
+              headers: result.response.headers
+            }
+          });
+        }
+        let textIndex = 0;
+        for (const part of result.content) {
+          if (part.type === "text") {
+            const id = `text-${++textIndex}`;
+            controller.enqueue({
+              type: "text-start",
+              id
+            });
+            controller.enqueue({
+              type: "text-delta",
+              id,
+              delta: part.text
+            });
+            controller.enqueue({
+              type: "text-end",
+              id
+            });
+          } else if (part.type === "tool-call") {
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            });
+          }
+        }
+        controller.enqueue({
+          type: "finish",
+          finishReason: result.finishReason,
+          usage: result.usage
+        });
+        controller.close();
+      }
+    });
+    return {
+      stream,
+      request: result.request,
+      warnings: result.warnings
+    };
+  }
+  /**
+   * Convert AI SDK messages to MCP sampling format
+   */
+  convertMessages(prompt) {
+    return convertAISDKToMCPMessages(prompt);
+  }
+  /**
+   * Map MCP stop reason to AI SDK finish reason
+   */
+  mapStopReason(stopReason) {
+    return convertMCPStopReasonToAISDK(stopReason);
+  }
+  /**
+   * Check if client supports native tool use in sampling
+   */
+  supportsSamplingTools() {
+    const capabilities = this.server.getClientCapabilities();
+    return !!capabilities?.sampling?.tools;
+  }
+  /**
+   * Convert AI SDK tools to MCP Tool format
+   */
+  convertAISDKToolsToMCP(tools) {
+    if (!tools || tools.length === 0) return [];
+    return tools.filter((tool2) => tool2.type === "function").map((tool2) => {
+      const toolAny = tool2;
+      return {
+        name: tool2.name,
+        description: toolAny.description || `Tool: ${tool2.name}`,
+        inputSchema: {
+          type: "object",
+          ...toolAny.inputSchema || toolAny.parameters
+        }
+      };
+    });
+  }
+  /**
+   * Inject response format instructions into system prompt
+   *
+   * Only injects formatting instructions in JSON fallback mode.
+   * In native tools mode, structured output is handled by the provider.
+   */
+  injectResponseFormatInstructions(systemPrompt, responseFormat, useNativeTools) {
+    if (!responseFormat) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      return systemPrompt;
+    }
+    let enhanced = systemPrompt || "";
+    if (responseFormat.type === "json") {
+      const jsonPrompt = `
+
+IMPORTANT: You MUST respond with valid JSON only. Do not include any text before or after the JSON.
+- Your response must be a valid JSON object
+- Do not wrap the JSON in markdown code blocks
+- Do not include explanations or comments
+- Ensure all JSON is properly formatted and parseable`;
+      enhanced = enhanced ? `${enhanced}${jsonPrompt}` : jsonPrompt.trim();
+      if (responseFormat.schema) {
+        const schemaInfo = `
+- Follow this JSON schema structure: ${JSON.stringify(responseFormat.schema)}`;
+        enhanced += schemaInfo;
+      }
+    }
+    return enhanced || void 0;
+  }
+  /**
+   * Inject tool definitions into system prompt
+   *
+   * WORKAROUND: MCP sampling currently doesn't support native tools parameter.
+   * This method injects tool descriptions and usage instructions into the system prompt.
+   *
+   * TODO: Remove this workaround when MCP protocol adds native support for:
+   * - tools parameter in createMessage
+   * - Tool calling and function execution
+   * - Structured tool responses
+   */
+  injectToolInstructions(systemPrompt, tools, useNativeTools) {
+    if (!tools || tools.length === 0) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      return systemPrompt;
+    }
+    let enhanced = systemPrompt || "";
+    const toolsPrompt = `
+
+AVAILABLE TOOLS:
+You have access to the following tools. To use a tool, respond with this XML format:
+<use_tool tool="tool_name">
+{"param1": "value1", "param2": "value2"}
+</use_tool>
+
+Follow the JSON schema definition for each tool's parameters.
+You can use multiple tools in one response. You can include text before tool calls, but do NOT include text after tool calls - wait for the tool results first.
+
+Tools:`;
+    const toolDescriptions = tools.map((tool2) => {
+      if (tool2.type === "function") {
+        const toolAny = tool2;
+        const description = toolAny.description || "No description provided";
+        const schema = toolAny.inputSchema || toolAny.parameters;
+        const params = schema ? `
+  JSON Schema: ${JSON.stringify(schema, null, 2)}` : "";
+        return `
+- ${tool2.name}: ${description}${params}`;
+      } else if (tool2.type === "provider-defined") {
+        return `
+- ${tool2.name}: ${tool2.id || "No description provided"}`;
+      }
+      return "";
+    }).filter(Boolean).join("");
+    enhanced = enhanced ? `${enhanced}${toolsPrompt}${toolDescriptions}` : `${toolsPrompt}${toolDescriptions}`.trim();
+    return enhanced || void 0;
+  }
+  /**
+   * Extract tool calls from LLM response text
+   *
+   * Parses XML-style tool call tags from the response:
+   * <use_tool tool="tool_name">{"arg": "value"}</use_tool>
+   */
+  extractToolCalls(responseText, tools) {
+    if (!tools || tools.length === 0) {
+      return {
+        text: responseText,
+        toolCalls: []
+      };
+    }
+    const toolCalls = [];
+    const toolCallRegex = /<use_tool\s+tool="([^"]+)">([\s\S]*?)<\/use_tool>/g;
+    let match;
+    let lastIndex = 0;
+    const textParts = [];
+    let callIndex = 0;
+    while ((match = toolCallRegex.exec(responseText)) !== null) {
+      textParts.push(responseText.slice(lastIndex, match.index));
+      const toolName = match[1];
+      const argsText = match[2].trim?.();
+      toolCalls.push({
+        type: "tool-call",
+        toolCallId: `call_${Date.now()}_${callIndex++}`,
+        toolName,
+        input: argsText
+      });
+      lastIndex = match.index + match[0].length;
+    }
+    textParts.push(responseText.slice(lastIndex));
+    const text = textParts.join("").trim();
+    return {
+      text,
+      toolCalls
+    };
+  }
+};
+
+// __mcpc__core_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/provider.js
+var MCPSamplingProvider = class {
+  config;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Create a language model instance for a specific MCP tool/agent
+   *
+   * @param options - Optional configuration overrides
+   * @returns A LanguageModelV2 instance
+   */
+  languageModel(options) {
+    return new MCPSamplingLanguageModel({
+      server: this.config.server,
+      modelPreferences: options?.modelPreferences
+    });
+  }
+  /**
+   * Shorthand for creating a language model
+   */
+  call(options) {
+    return this.languageModel(options);
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/ai/base-ai-executor.js
+import { trace as trace2 } from "@opentelemetry/api";
+import { jsonSchema as jsonSchema2, stepCountIs, streamText, tool } from "ai";
+var BaseAIExecutor = class {
+  config;
+  tracer;
+  logger;
+  constructor(config2, server) {
+    this.config = {
+      maxSteps: 50,
+      tracingEnabled: true,
+      ...config2
+    };
+    this.tracer = trace2.getTracer(`mcpc.ai.${config2.name}`);
+    this.logger = createLogger(`mcpc.ai.${config2.name}`, server);
+  }
+  execute(args) {
+    if (this.config.tracingEnabled) {
+      return this.executeWithTracing(args);
+    }
+    return this.executeCore(args);
+  }
+  executeWithTracing(args) {
+    return this.tracer.startActiveSpan(`mcpc.ai.${this.config.name}`, async (span) => {
+      try {
+        span.setAttributes({
+          "mcpc.executor": this.config.name,
+          "mcpc.type": this.getExecutorType()
+        });
+        const result = await this.executeCore(args, span);
+        span.setAttributes({
+          "mcpc.error": !!result.isError
+        });
+        return result;
+      } catch (error2) {
+        span.recordException(error2);
+        throw error2;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  async executeCore(args, span) {
+    try {
+      const result = streamText({
+        model: this.getModel(),
+        system: this.buildSystemPrompt(args),
+        messages: [
+          {
+            role: "user",
+            content: args.userRequest
+          }
+        ],
+        tools: this.buildTools(),
+        stopWhen: stepCountIs(this.config.maxSteps),
+        experimental_telemetry: this.config.tracingEnabled ? {
+          isEnabled: true,
+          functionId: `mcpc.${this.config.name}`,
+          tracer: this.tracer
+        } : void 0,
+        onStepFinish: (step) => {
+          if (span) {
+            span.addEvent("step", {
+              tools: step.toolCalls?.length ?? 0,
+              reason: step.finishReason ?? ""
+            });
+          }
+        }
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: await result.text || `Completed in ${(await result.steps)?.length ?? "unknown"} step(s).`
+          }
+        ],
+        isError: false
+      };
+    } catch (error2) {
+      this.logger.error({
+        message: "Execution error",
+        error: error2
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error2 instanceof Error ? error2.message : String(error2)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  buildSystemPrompt(args) {
+    return `Agent \`${this.config.name}\` that completes tasks by calling tools.
+
+<manual>
+${this.config.description}
+</manual>
+
+<rules>
+${this.getRules()}
+</rules>
+
+<tools>
+${this.getToolListDescription()}
+</tools>${args.context ? this.formatContext(args.context) : ""}`;
+  }
+  getRules() {
+    return `1. Use tools to complete the user's request
+2. Review results after each tool call
+3. Adapt your approach based on outcomes
+4. Continue until task is complete
+5. When complete, provide a summary WITHOUT calling more tools`;
+  }
+  getToolListDescription() {
+    return "Tools will be provided by AI SDK";
+  }
+  formatContext(context2) {
+    return `
+
+<context>
+${JSON.stringify(context2, null, 2)}
+</context>`;
+  }
+  convertToAISDKTool(name, toolDetail, execute) {
+    return tool({
+      description: toolDetail.description || `Tool: ${name}`,
+      inputSchema: jsonSchema2(toolDetail.inputSchema || {
+        type: "object"
+      }),
+      execute
+    });
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/ai/ai-sampling-executor.js
+var AISamplingExecutor = class extends BaseAIExecutor {
+  server;
+  tools;
+  providerOptions;
+  model = null;
+  constructor(config2) {
+    super(config2, "callTool" in config2.server ? config2.server : void 0);
+    this.server = config2.server;
+    this.tools = config2.tools;
+    this.providerOptions = config2.providerOptions;
+  }
+  initProvider() {
+    if (!this.model) {
+      const provider = new MCPSamplingProvider({
+        server: this.server
+      });
+      this.model = provider.languageModel(this.providerOptions);
+    }
+    return this.model;
+  }
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
+  }
+  getExecutorType() {
+    return "mcp";
+  }
+  getToolListDescription() {
+    return this.tools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
+  }
+  buildTools() {
+    const aiTools = {};
+    for (const [name, detail] of this.tools) {
+      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
+        const result = await this.callTool(name, input);
+        return this.formatResult(result);
+      });
+    }
+    return aiTools;
+  }
+  async callTool(name, input) {
+    if ("callTool" in this.server) {
+      return await this.server.callTool(name, input);
+    }
+    const detail = this.tools.find(([n]) => n === name)?.[1];
+    if (detail?.execute) return await detail.execute(input);
+    throw new Error(`Cannot call tool "${name}"`);
+  }
+  formatResult(result) {
+    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
+    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
+  }
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/ai/ai-sampling-registrar.js
+function registerAISamplingTool(server, params) {
+  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AISamplingExecutor({
+    name,
+    description,
+    server,
+    tools: toolNameToDetailList,
+    providerOptions,
+    maxSteps,
+    tracingEnabled
+  });
+  const toolDescription = CompiledPrompts.samplingToolDescription({
+    toolName: name,
+    description,
+    toolList: allToolNames.map((n) => `- ${n}`).join("\n")
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
+    const userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    return executor.execute({
+      userRequest,
+      context: args.context
+    });
+  });
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-ai-sampling-plugin.js
+var createAISamplingModePlugin = () => ({
+  name: "mode-ai-sampling",
+  version: "1.0.0",
+  apply: "ai_sampling",
+  registerAgentTool: (context2) => {
+    const opts = context2.options;
+    registerAISamplingTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      toolNameToDetailList: context2.toolNameToDetailList,
+      providerOptions: opts.providerOptions,
+      maxSteps: opts.maxSteps,
+      tracingEnabled: opts.tracingEnabled
+    });
+  }
+});
+var mode_ai_sampling_plugin_default = createAISamplingModePlugin();
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/ai/ai-acp-executor.js
+import { createACPProvider } from "@mcpc-tech/acp-ai-provider";
+var AIACPExecutor = class extends BaseAIExecutor {
+  acpSettings;
+  clientTools;
+  provider = null;
+  model = null;
+  constructor(config2) {
+    super(config2);
+    this.acpSettings = config2.acpSettings;
+    this.clientTools = config2.clientTools ?? [];
+  }
+  initProvider() {
+    if (!this.model) {
+      this.provider = createACPProvider(this.acpSettings);
+      this.model = this.provider.languageModel();
+    }
+    return this.model;
+  }
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
+  }
+  getExecutorType() {
+    return "acp";
+  }
+  getToolListDescription() {
+    if (this.clientTools.length === 0) {
+      return "Tools will be provided by AI SDK";
+    }
+    return this.clientTools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
+  }
+  buildTools() {
+    const aiTools = {};
+    for (const [name, detail] of this.clientTools) {
+      if (!detail.execute) continue;
+      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
+        const result = await detail.execute(input);
+        return this.formatResult(result);
+      });
+    }
+    return aiTools;
+  }
+  formatResult(result) {
+    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
+    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
+  }
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
+  }
+  cleanup() {
+    if (this.provider && typeof this.provider.cleanup === "function") {
+      this.provider.cleanup();
+    }
+    this.model = null;
+    this.provider = null;
+  }
+};
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/executors/ai/ai-acp-registrar.js
+function registerAIACPTool(server, params) {
+  const { name, description, allToolNames, depGroups, acpSettings, clientTools = [], maxSteps = 50, tracingEnabled = false } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AIACPExecutor({
+    name,
+    description,
+    acpSettings,
+    clientTools,
+    maxSteps,
+    tracingEnabled
+  });
+  const toolDescription = CompiledPrompts.samplingToolDescription({
+    toolName: name,
+    description,
+    toolList: allToolNames.length > 0 ? allToolNames.map((n) => `- ${n}`).join("\n") : "Agent has its own tools"
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
+    const userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    return executor.execute({
+      userRequest,
+      context: args.context
+    });
+  });
+  return executor;
+}
+
+// __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/mode-ai-acp-plugin.js
+var createAIACPModePlugin = () => ({
+  name: "mode-ai-acp",
+  version: "1.0.0",
+  apply: "ai_acp",
+  registerAgentTool: (context2) => {
+    const opts = context2.options;
+    if (!opts.acpSettings) {
+      throw new Error("ai_acp mode requires acpSettings in options");
+    }
+    registerAIACPTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      acpSettings: opts.acpSettings,
+      clientTools: opts.clientTools,
+      maxSteps: opts.maxSteps,
+      tracingEnabled: opts.tracingEnabled
+    });
+  }
+});
+var mode_ai_acp_plugin_default = createAIACPModePlugin();
+
 // __mcpc__core_latest/node_modules/@mcpc/core/src/plugins/built-in/index.js
 function getBuiltInPlugins() {
   return [
@@ -19929,6 +20686,8 @@ function getBuiltInPlugins() {
     mode_workflow_plugin_default,
     mode_agentic_sampling_plugin_default,
     mode_workflow_sampling_plugin_default,
+    mode_ai_sampling_plugin_default,
+    mode_ai_acp_plugin_default,
     logging_plugin_default
   ];
 }
@@ -20216,13 +20975,13 @@ var PluginManager = class {
   /**
    * Apply transformTool hooks to a tool during composition
    */
-  async applyTransformToolHooks(tool, context2) {
+  async applyTransformToolHooks(tool2, context2) {
     const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
     if (transformPlugins.length === 0) {
-      return tool;
+      return tool2;
     }
     const sortedPlugins = sortPluginsByOrder(transformPlugins);
-    let currentTool = tool;
+    let currentTool = tool2;
     for (const plugin of sortedPlugins) {
       if (plugin.transformTool) {
         try {
@@ -20470,12 +21229,12 @@ var ToolManager = class {
    * Get tool schema if it's hidden (for internal access)
    */
   getHiddenToolSchema(name) {
-    const tool = this.toolRegistry.get(name);
+    const tool2 = this.toolRegistry.get(name);
     const config2 = this.toolConfigs.get(name);
-    if (tool && config2?.visibility?.hidden && tool.schema) {
+    if (tool2 && config2?.visibility?.hidden && tool2.schema) {
       return {
-        description: tool.description,
-        schema: tool.schema
+        description: tool2.description,
+        schema: tool2.schema
       };
     }
     return void 0;
@@ -20504,18 +21263,18 @@ var ToolManager = class {
    */
   getRegisteredToolsAsComposed() {
     const composedTools = {};
-    for (const [name, tool] of this.toolRegistry.entries()) {
+    for (const [name, tool2] of this.toolRegistry.entries()) {
       if (this.toolConfigs.get(name)?.visibility?.public === true) {
         continue;
       }
       composedTools[name] = {
         name,
-        description: tool.description,
-        inputSchema: jsonSchema(tool.schema || {
+        description: tool2.description,
+        inputSchema: jsonSchema(tool2.schema || {
           type: "object",
           properties: {}
         }),
-        execute: tool.callback
+        execute: tool2.callback
       };
     }
     return composedTools;
@@ -20585,18 +21344,18 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
 function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
   const depGroups = {};
   const toolManager = server.toolManager;
-  toolNameToDetailList.forEach(([toolName, tool]) => {
+  toolNameToDetailList.forEach(([toolName, tool2]) => {
     const resolvedName = toolManager.resolveToolName(toolName);
     if (hiddenToolNames.includes(resolvedName ?? "") || publicToolNames.includes(resolvedName ?? "")) {
       return;
     }
-    if (!tool) {
+    if (!tool2) {
       const allToolNames = [
         ...toolNameToDetailList.map(([n]) => n)
       ];
       throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
     }
-    const baseSchema = tool.inputSchema.jsonSchema ?? tool.inputSchema ?? {
+    const baseSchema = tool2.inputSchema.jsonSchema ?? tool2.inputSchema ?? {
       type: "object",
       properties: {},
       required: []
@@ -20607,7 +21366,7 @@ function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicTool
     const sanitizedKey = sanitizePropertyKey(toolName);
     depGroups[sanitizedKey] = {
       type: "object",
-      description: tool.description,
+      description: tool2.description,
       properties: updatedProperties,
       required: [
         ...baseRequired
@@ -20883,9 +21642,9 @@ var ComposableMCPServer = class extends Server {
     const requestedToolNames = /* @__PURE__ */ new Set();
     const availableToolNames = /* @__PURE__ */ new Set();
     const allPlaceholderUsages = [];
-    tagToResults.tool.forEach((tool) => {
-      if (tool.attribs.name) {
-        const originalName = tool.attribs.name;
+    tagToResults.tool.forEach((tool2) => {
+      if (tool2.attribs.name) {
+        const originalName = tool2.attribs.name;
         const toolName = sanitizePropertyKey(originalName);
         if (toolName.endsWith(`_${ALL_TOOLS_PLACEHOLDER2}`) || toolName === ALL_TOOLS_PLACEHOLDER2) {
           allPlaceholderUsages.push(originalName);
@@ -20911,24 +21670,24 @@ var ComposableMCPServer = class extends Server {
         }
         return true;
       }
-      return tagToResults.tool.find((tool) => {
-        const selectAll = tool.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool.attribs.name === `${mcpName}`;
+      return tagToResults.tool.find((tool2) => {
+        const selectAll = tool2.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool2.attribs.name === `${mcpName}`;
         if (selectAll) {
           return true;
         }
-        return tool.attribs.name === toolNameWithScope || tool.attribs.name === toolId;
+        return tool2.attribs.name === toolNameWithScope || tool2.attribs.name === toolId;
       });
     });
-    Object.entries(tools).forEach(([toolId, tool]) => {
-      this.toolManager.registerTool(toolId, tool.description || "", tool.inputSchema, tool.execute);
+    Object.entries(tools).forEach(([toolId, tool2]) => {
+      this.toolManager.registerTool(toolId, tool2.description || "", tool2.inputSchema, tool2.execute);
     });
     const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
     const allTools = {
       ...tools
     };
-    Object.entries(registeredTools).forEach(([toolName, tool]) => {
+    Object.entries(registeredTools).forEach(([toolName, tool2]) => {
       if (!allTools[toolName]) {
-        allTools[toolName] = tool;
+        allTools[toolName] = tool2;
       }
       availableToolNames.add(toolName);
     });
@@ -20972,11 +21731,11 @@ var ComposableMCPServer = class extends Server {
     const hiddenToolNames = this.getHiddenToolNames();
     const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
     publicToolNames.forEach((toolId) => {
-      const tool = allTools[toolId];
-      if (!tool) {
+      const tool2 = allTools[toolId];
+      if (!tool2) {
         throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
       }
-      this.tool(toolId, tool.description || "", jsonSchema(tool.inputSchema), tool.execute, {
+      this.tool(toolId, tool2.description || "", jsonSchema(tool2.inputSchema), tool2.execute, {
         internal: false
       });
     });
@@ -21041,13 +21800,13 @@ if (isSCF()) {
 
 // __mcpc__core_latest/node_modules/@mcpc/core/src/ai-sdk-adapter.js
 function convertToAISDKTools(server, helpers) {
-  const { tool, jsonSchema: jsonSchema2 } = helpers;
+  const { tool: tool2, jsonSchema: jsonSchema3 } = helpers;
   const mcpcTools = server.getPublicTools();
   return Object.fromEntries(mcpcTools.map((mcpcTool) => [
     mcpcTool.name,
-    tool({
+    tool2({
       description: mcpcTool.description || "No description",
-      inputSchema: jsonSchema2(mcpcTool.inputSchema),
+      inputSchema: jsonSchema3(mcpcTool.inputSchema),
       execute: async (input) => {
         return await server.callTool(mcpcTool.name, input);
       }