@mcpc-tech/cli 0.1.29 → 0.1.30

package/bin/mcpc.cjs

@@ -502,7 +502,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
-    function spawn3(command, args, options) {
+    function spawn2(command, args, options) {
       const parsed = parse(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -514,8 +514,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn3;
-    module2.exports.spawn = spawn3;
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -5085,17 +5085,17 @@ var Client = class extends Protocol {
     this._cachedToolOutputValidators.clear();
     this._cachedKnownTaskTools.clear();
     this._cachedRequiredTaskTools.clear();
-    for (const tool3 of tools) {
-      if (tool3.outputSchema) {
-        const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
-        this._cachedToolOutputValidators.set(tool3.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 = tool3.execution?.taskSupport;
+      const taskSupport = tool2.execution?.taskSupport;
       if (taskSupport === "required" || taskSupport === "optional") {
-        this._cachedKnownTaskTools.add(tool3.name);
+        this._cachedKnownTaskTools.add(tool2.name);
       }
       if (taskSupport === "required") {
-        this._cachedRequiredTaskTools.add(tool3.name);
+        this._cachedRequiredTaskTools.add(tool2.name);
       }
     }
   }
@@ -7420,14 +7420,14 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
       acquiredKeys.push(defKey);
       allClients[serverId] = client;
       const { tools } = await client.listTools();
-      tools.forEach((tool3) => {
-        const toolNameWithScope = `${name}.${tool3.name}`;
-        const internalToolName = tool3.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: tool3,
+          tool: tool2,
           mcpName: name,
           toolNameWithScope,
           internalToolName,
@@ -7442,7 +7442,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
           timeout: def.toolCallTimeout
         });
         allTools[toolId] = {
-          ...tool3,
+          ...tool2,
           execute,
           _originalName: toolNameWithScope
         };
@@ -7505,13 +7505,13 @@ var createConfigPlugin = () => ({
   name: "built-in-config",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool3, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const config = server.findToolConfig?.(context2.toolName);
     if (config?.description) {
-      tool3.description = config.description;
+      tool2.description = config.description;
     }
-    return tool3;
+    return tool2;
   }
 });
 var config_plugin_default = createConfigPlugin();
@@ -7521,10 +7521,10 @@ var createToolNameMappingPlugin = () => ({
   name: "built-in-tool-name-mapping",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool3, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const toolName = context2.toolName;
-    const originalName = tool3._originalName || toolName;
+    const originalName = tool2._originalName || toolName;
     const dotNotation = originalName.replace(/_/g, ".");
     const underscoreNotation = originalName.replace(/\./g, "_");
     if (dotNotation !== originalName && server.toolNameMapping) {
@@ -7536,7 +7536,7 @@ var createToolNameMappingPlugin = () => ({
     if (originalName !== toolName && server.toolNameMapping) {
       server.toolNameMapping.set(originalName, toolName);
     }
-    return tool3;
+    return tool2;
   }
 });
 var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
@@ -7687,7 +7687,7 @@ You must follow the <manual/>, obey the <rules/>, and use the <format/>.
 
 <parameters>
 \`tool\` - Which tool to execute: "man" to get schemas, or a tool name to execute
-\`args\` - For "man": array of tool names. For other tools: object with parameters.
+\`args\` - For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.
 </parameters>
 
 <rules>
@@ -7702,7 +7702,7 @@ Get tool schemas:
 \`\`\`json
 {
   "tool": "man",
-  "args": ["tool1", "tool2"]
+  "args": { "tools": ["tool1", "tool2"] }
 }
 \`\`\`
 
@@ -7714,80 +7714,6 @@ Execute a tool:
 }
 \`\`\`
 </format>`,
-  /**
-   * Tool-based execution system prompt for autonomous sampling mode with native tools
-   *
-   * Note: Used when client supports sampling.tools capability
-   */
-  SAMPLING_EXECUTION_TOOLS: `Agent \`{toolName}\` that completes tasks by calling tools.
-
-<manual>
-{description}
-</manual>
-
-<rules>
-1. Execute one action per iteration
-2. Adapt based on results from previous actions
-3. Continue until task is complete
-</rules>
-
-<tools>
-{toolList}
-</tools>`,
-  /**
-   * JSON-only execution system prompt for autonomous sampling mode
-   *
-   * Note: Sampling mode runs an internal LLM loop that autonomously calls tools until complete.
-   */
-  SAMPLING_EXECUTION: `Agent \`{toolName}\` that completes tasks by calling tools in an autonomous loop.
-
-<manual>
-{description}
-</manual>
-
-<rules>
-1. **YOUR ENTIRE RESPONSE MUST BE A SINGLE JSON OBJECT** - no text before or after
-2. Execute one tool per iteration  
-3. Specify which tool to use with \`useTool\`
-4. Adapt based on results from previous actions
-5. Continue until task is complete
-</rules>
-
-<format>
-CORRECT:
-\`\`\`json
-{"useTool": "tool_name", "decision": "proceed", "tool_name": {...}}
-\`\`\`
-
-WRONG - No explanations:
-\`\`\`
-I will list the directory
-{"useTool": "list_directory", ...}
-\`\`\`
-
-During execution:
-\`\`\`json
-{
-  "useTool": "tool_name",
-  "decision": "proceed",
-  "tool_name": { /* tool parameters */ }
-}
-\`\`\`
-
-When complete:
-\`\`\`json
-{ "decision": "complete" }
-\`\`\`
-
-Decisions:
-- \`proceed\` = action succeeded, continue
-- \`retry\` = action failed, try again  
-- \`complete\` = task finished
-</format>
-
-<tools>
-{toolList}
-</tools>`,
   /**
    * Tool description for sampling tools (shown in MCP tools list)
    * Explains how to use prompt and context parameters
@@ -7809,7 +7735,21 @@ You must follow the <manual/>, obey the <rules/>, and use the <format/>.
 1. Always provide both \`prompt\` and \`context\` parameters
 2. \`prompt\` must be a clear, actionable description
 3. \`context\` must include relevant environment info (e.g., working directory)
-</rules>`
+</rules>`,
+  /**
+   * System prompt for AI sampling loop (ai_sampling/ai_acp modes)
+   * Used inside the execution loop when AI calls native tools.
+   * Note: Tool schemas are passed via AI SDK native tool calling, not in prompt.
+   */
+  AI_LOOP_SYSTEM: `Agent \`{toolName}\` that completes tasks by calling tools.
+
+<manual>
+{description}
+</manual>
+
+<rules>
+{rules}
+</rules>{context}`
 };
 var ResponseTemplates = {
   /**
@@ -7850,9 +7790,8 @@ Adjust parameters and retry.`,
 };
 var CompiledPrompts = {
   autonomousExecution: p(SystemPrompts.AUTONOMOUS_EXECUTION),
-  samplingExecution: p(SystemPrompts.SAMPLING_EXECUTION),
-  samplingExecutionTools: p(SystemPrompts.SAMPLING_EXECUTION_TOOLS),
   samplingToolDescription: p(SystemPrompts.SAMPLING_TOOL_DESCRIPTION),
+  aiLoopSystem: p(SystemPrompts.AI_LOOP_SYSTEM),
   actionSuccess: p(ResponseTemplates.ACTION_SUCCESS),
   planningPrompt: p(ResponseTemplates.PLANNING_PROMPT),
   errorResponse: p(ResponseTemplates.ERROR_RESPONSE),
@@ -7862,6 +7801,106 @@ var CompiledPrompts = {
   completionMessage: () => ResponseTemplates.COMPLETION_MESSAGE
 };
 
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
+function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
+  return {
+    forSampling: function() {
+      return {
+        type: "object",
+        description: "Provide prompt for autonomous tool execution",
+        properties: {
+          prompt: {
+            type: "string",
+            description: "The task to be completed autonomously by the agentic system using available tools"
+          },
+          context: {
+            type: "object",
+            description: "Execution context, e.g., { cwd: '/path/to/dir' }. Any relevant fields allowed.",
+            additionalProperties: true
+          }
+        },
+        required: [
+          "prompt",
+          "context"
+        ],
+        errorMessage: {
+          required: {
+            prompt: "Missing required field 'prompt'. Please provide a clear task description.",
+            context: "Missing required field 'context'. Please provide relevant context (e.g., { cwd: '...' })."
+          }
+        }
+      };
+    },
+    /**
+     * Agentic schema - simplified Unix-style interface
+     *
+     * Only two fields:
+     * - `tool`: which tool to execute (enum includes "man" + all tool names)
+     * - `args`: object with parameters. For "man": { tools: ["a", "b"] }. For others: tool parameters.
+     */
+    forAgentic: function(allToolNames) {
+      const toolEnum = [
+        "man",
+        ...allToolNames
+      ];
+      return {
+        type: "object",
+        properties: {
+          tool: {
+            type: "string",
+            enum: toolEnum,
+            description: 'Which tool to execute. Use "man" to get tool schemas, or a tool name to execute.',
+            errorMessage: {
+              enum: `Invalid tool. Available: ${toolEnum.join(", ")}`
+            }
+          },
+          args: {
+            type: "object",
+            description: `For "man": { tools: ["tool1", "tool2"] }. For other tools: tool parameters that strictly adhere to the tool's JSON schema.`
+          }
+        },
+        required: [
+          "tool"
+        ],
+        additionalProperties: false
+      };
+    },
+    /**
+     * Schema for "man" command args validation
+     * Expected format: { tools: ["tool1", "tool2"] }
+     */
+    forMan: function(allToolNames) {
+      return {
+        type: "object",
+        properties: {
+          tools: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: allToolNames,
+              errorMessage: {
+                enum: `Invalid tool name. Available: ${allToolNames.join(", ")}`
+              }
+            },
+            minItems: 1,
+            errorMessage: {
+              minItems: "At least one tool name is required"
+            }
+          }
+        },
+        required: [
+          "tools"
+        ],
+        errorMessage: {
+          required: {
+            tools: 'Missing "tools" field. Expected: { tools: ["tool1", "tool2"] }'
+          }
+        }
+      };
+    }
+  };
+}
+
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/schema-validator.js
 var import_ajv2 = require("ajv");
 var import_ajv_formats2 = __toESM(require("ajv-formats"), 1);
@@ -8031,24 +8070,11 @@ var AgenticExecutor = class {
           isError: true
         };
       }
-      const tool3 = args.tool;
-      if (tool3 === "man") {
-        const manSchema = {
-          type: "array",
-          items: {
-            type: "string",
-            enum: this.allToolNames,
-            errorMessage: {
-              enum: `Invalid tool name. Available: ${this.allToolNames.join(", ")}`
-            }
-          },
-          minItems: 1,
-          errorMessage: {
-            type: 'Expected an array of tool names, e.g. ["tool1", "tool2"]',
-            minItems: "At least one tool name is required"
-          }
-        };
-        const manValidation = validateSchema(args.args ?? [], manSchema);
+      const tool2 = args.tool;
+      if (tool2 === "man") {
+        const createArgsDef = createArgsDefFactory(this.name, this.allToolNames, {});
+        const manSchema = createArgsDef.forMan(this.allToolNames);
+        const manValidation = validateSchema(args.args ?? {}, manSchema);
         if (!manValidation.valid) {
           return {
             content: [
@@ -8060,10 +8086,11 @@ var AgenticExecutor = class {
             isError: true
           };
         }
-        return this.handleManCommand(args.args, executeSpan);
+        const argsObj = args.args;
+        return this.handleManCommand(argsObj.tools, executeSpan);
       }
       const toolArgs = args.args || {};
-      return await this.executeTool(tool3, toolArgs, executeSpan);
+      return await this.executeTool(tool2, toolArgs, executeSpan);
     } catch (error) {
       if (executeSpan) {
         endSpan(executeSpan, error);
@@ -8123,14 +8150,14 @@ ${JSON.stringify(cleanedSchema, null, 2)}
   /**
    * Execute a tool with runtime validation
    */
-  async executeTool(tool3, toolArgs, executeSpan) {
-    const externalTool = this.toolNameToDetailList.find(([name]) => name === tool3);
+  async executeTool(tool2, toolArgs, executeSpan) {
+    const externalTool = this.toolNameToDetailList.find(([name]) => name === tool2);
     if (externalTool) {
       const [, toolDetail] = externalTool;
       if (executeSpan) {
         executeSpan.setAttributes({
           toolType: "external",
-          selectedTool: tool3
+          selectedTool: tool2
         });
       }
       if (toolDetail.inputSchema) {
@@ -8148,7 +8175,7 @@ ${JSON.stringify(cleanedSchema, null, 2)}
             content: [
               {
                 type: "text",
-                text: `Parameter validation failed for "${tool3}": ${validation.error}`
+                text: `Parameter validation failed for "${tool2}": ${validation.error}`
               }
             ],
             isError: true
@@ -8157,7 +8184,7 @@ ${JSON.stringify(cleanedSchema, null, 2)}
       }
       this.logger.debug({
         message: "Executing external tool",
-        tool: tool3
+        tool: tool2
       });
       const result = await toolDetail.execute(toolArgs);
       if (executeSpan) {
@@ -8170,19 +8197,19 @@ ${JSON.stringify(cleanedSchema, null, 2)}
       }
       return result;
     }
-    if (this.allToolNames.includes(tool3)) {
+    if (this.allToolNames.includes(tool2)) {
       if (executeSpan) {
         executeSpan.setAttributes({
           toolType: "internal",
-          selectedTool: tool3
+          selectedTool: tool2
         });
       }
       this.logger.debug({
         message: "Executing internal tool",
-        tool: tool3
+        tool: tool2
       });
       try {
-        const result = await this.server.callTool(tool3, toolArgs);
+        const result = await this.server.callTool(tool2, toolArgs);
         const callToolResult = result ?? {
           content: []
         };
@@ -8201,14 +8228,14 @@ ${JSON.stringify(cleanedSchema, null, 2)}
         }
         this.logger.error({
           message: "Error executing internal tool",
-          tool: tool3,
+          tool: tool2,
           error: String(error)
         });
         return {
           content: [
             {
               type: "text",
-              text: `Error executing tool "${tool3}": ${error instanceof Error ? error.message : String(error)}`
+              text: `Error executing tool "${tool2}": ${error instanceof Error ? error.message : String(error)}`
             }
           ],
           isError: true
@@ -8218,7 +8245,7 @@ ${JSON.stringify(cleanedSchema, null, 2)}
     if (executeSpan) {
       executeSpan.setAttributes({
         toolType: "not_found",
-        tool: tool3
+        tool: tool2
       });
       endSpan(executeSpan);
     }
@@ -8226,7 +8253,7 @@ ${JSON.stringify(cleanedSchema, null, 2)}
       content: [
         {
           type: "text",
-          text: `Tool "${tool3}" not found. Available tools: ${this.allToolNames.join(", ")}`
+          text: `Tool "${tool2}" not found. Available tools: ${this.allToolNames.join(", ")}`
         }
       ],
       isError: true
@@ -8237,72 +8264,6 @@ ${JSON.stringify(cleanedSchema, null, 2)}
   }
 };
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/factories/args-def-factory.js
-function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps, _ensureStepActions) {
-  return {
-    forSampling: function() {
-      return {
-        type: "object",
-        description: "Provide prompt for autonomous tool execution",
-        properties: {
-          prompt: {
-            type: "string",
-            description: "The task to be completed autonomously by the agentic system using available tools"
-          },
-          context: {
-            type: "object",
-            description: "Execution context, e.g., { cwd: '/path/to/dir' }. Any relevant fields allowed.",
-            additionalProperties: true
-          }
-        },
-        required: [
-          "prompt",
-          "context"
-        ],
-        errorMessage: {
-          required: {
-            prompt: "Missing required field 'prompt'. Please provide a clear task description.",
-            context: "Missing required field 'context'. Please provide relevant context (e.g., { cwd: '...' })."
-          }
-        }
-      };
-    },
-    /**
-     * Agentic schema - simplified Unix-style interface
-     *
-     * Only two fields:
-     * - `tool`: which tool to execute (enum includes "man" + all tool names)
-     * - `args`: parameters for the tool (array for "man", object for others)
-     */
-    forAgentic: function(allToolNames) {
-      const toolEnum = [
-        "man",
-        ...allToolNames
-      ];
-      return {
-        type: "object",
-        properties: {
-          tool: {
-            type: "string",
-            enum: toolEnum,
-            description: 'Which tool to execute. Use "man" to get tool schemas, or a tool name to execute.',
-            errorMessage: {
-              enum: `Invalid tool. Available: ${toolEnum.join(", ")}`
-            }
-          },
-          args: {
-            description: 'For "man": array of tool names ["tool1", "tool2"]. For other tools: object with parameters.'
-          }
-        },
-        required: [
-          "tool"
-        ],
-        additionalProperties: false
-      };
-    }
-  };
-}
-
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-tool-registrar.js
 function registerAgenticTool(server, { description, name, allToolNames, depGroups, toolNameToDetailList }) {
   const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
@@ -8396,6 +8357,7 @@ function convertMCPStopReasonToAISDK(stopReason) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var DEFAULT_MAX_TOKENS = 128e3;
 var MCPSamplingLanguageModel = class {
   specificationVersion = "v2";
   provider;
@@ -8403,11 +8365,13 @@ var MCPSamplingLanguageModel = class {
   supportedUrls = {};
   server;
   modelPreferences;
+  maxTokens;
   constructor(config) {
     this.server = config.server;
     this.modelId = "";
     this.provider = "mcp-client";
     this.modelPreferences = config.modelPreferences;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
   }
   /**
    * Generate a response using MCP's createMessage capability
@@ -8439,7 +8403,7 @@ var MCPSamplingLanguageModel = class {
     const createMessageParams = {
       systemPrompt,
       messages,
-      maxTokens: options.maxOutputTokens ?? 55e3,
+      maxTokens: options.maxOutputTokens ?? this.maxTokens,
       modelPreferences: this.modelPreferences
     };
     if (useNativeTools && options.tools && options.tools.length > 0) {
@@ -8662,11 +8626,11 @@ var MCPSamplingLanguageModel = class {
    */
   convertAISDKToolsToMCP(tools) {
     if (!tools || tools.length === 0) return [];
-    return tools.filter((tool3) => tool3.type === "function").map((tool3) => {
-      const toolAny = tool3;
+    return tools.filter((tool2) => tool2.type === "function").map((tool2) => {
+      const toolAny = tool2;
       return {
-        name: tool3.name,
-        description: toolAny.description || `Tool: ${tool3.name}`,
+        name: tool2.name,
+        description: toolAny.description || `Tool: ${tool2.name}`,
         inputSchema: {
           type: "object",
           ...toolAny.inputSchema || toolAny.parameters
@@ -8744,18 +8708,18 @@ Follow the JSON schema definition for each tool's parameters.
 You can use multiple tools in one response. DO NOT include text before or after tool calls - wait for the tool results first.
 
 Tools:`;
-    const toolDescriptions = tools.map((tool3) => {
-      if (tool3.type === "function") {
-        const toolAny = tool3;
+    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 `
-- ${tool3.name}: ${description}${params}`;
-      } else if (tool3.type === "provider-defined") {
+- ${tool2.name}: ${description}${params}`;
+      } else if (tool2.type === "provider-defined") {
         return `
-- ${tool3.name}: ${tool3.id || "No description provided"}`;
+- ${tool2.name}: ${tool2.id || "No description provided"}`;
       }
       return "";
     }).filter(Boolean).join("");
@@ -8817,7 +8781,8 @@ var MCPSamplingProvider = class {
   languageModel(options) {
     return new MCPSamplingLanguageModel({
       server: this.config.server,
-      modelPreferences: options?.modelPreferences
+      modelPreferences: options?.modelPreferences,
+      maxTokens: this.config.maxTokens
     });
   }
   /**
@@ -8887,2722 +8852,208 @@ var BaseAIExecutor = class {
           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 (error) {
-      this.logger.error({
-        message: "Execution error",
-        error
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : String(error)}`
-          }
-        ],
-        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) {
-    const cleanedSchema = toolDetail.inputSchema ? cleanToolSchema(toolDetail.inputSchema) : {
-      type: "object"
-    };
-    return (0, import_ai.tool)({
-      description: toolDetail.description || `Tool: ${name}`,
-      inputSchema: (0, import_ai.jsonSchema)(cleanedSchema),
-      execute
-    });
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-executor.js
-var AISamplingExecutor = class extends BaseAIExecutor {
-  server;
-  tools;
-  providerOptions;
-  model = null;
-  constructor(config) {
-    super(config, "callTool" in config.server ? config.server : void 0);
-    this.server = config.server;
-    this.tools = config.tools;
-    this.providerOptions = config.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__cli_latest/node_modules/@jsr/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 validationResult = validateSchema(args, schema);
-    if (!validationResult.valid) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: CompiledPrompts.errorResponse({
-              errorMessage: validationResult.error || "Validation failed"
-            })
-          }
-        ],
-        isError: true
-      };
-    }
-    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
-    return executor.execute({
-      prompt,
-      context: args.context
-    });
-  });
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/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__cli_latest/node_modules/@agentclientprotocol/sdk/dist/acp.js
-var import_zod3 = require("zod");
-
-// __mcpc__cli_latest/node_modules/@agentclientprotocol/sdk/dist/schema.js
-var import_zod2 = require("zod");
-var AGENT_METHODS = {
-  authenticate: "authenticate",
-  initialize: "initialize",
-  session_cancel: "session/cancel",
-  session_load: "session/load",
-  session_new: "session/new",
-  session_prompt: "session/prompt",
-  session_set_mode: "session/set_mode",
-  session_set_model: "session/set_model"
-};
-var CLIENT_METHODS = {
-  fs_read_text_file: "fs/read_text_file",
-  fs_write_text_file: "fs/write_text_file",
-  session_request_permission: "session/request_permission",
-  session_update: "session/update",
-  terminal_create: "terminal/create",
-  terminal_kill: "terminal/kill",
-  terminal_output: "terminal/output",
-  terminal_release: "terminal/release",
-  terminal_wait_for_exit: "terminal/wait_for_exit"
-};
-var PROTOCOL_VERSION = 1;
-var writeTextFileRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  content: import_zod2.z.string(),
-  path: import_zod2.z.string(),
-  sessionId: import_zod2.z.string()
-});
-var readTextFileRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  limit: import_zod2.z.number().optional().nullable(),
-  line: import_zod2.z.number().optional().nullable(),
-  path: import_zod2.z.string(),
-  sessionId: import_zod2.z.string()
-});
-var terminalOutputRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string(),
-  terminalId: import_zod2.z.string()
-});
-var releaseTerminalRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string(),
-  terminalId: import_zod2.z.string()
-});
-var waitForTerminalExitRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string(),
-  terminalId: import_zod2.z.string()
-});
-var killTerminalCommandRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string(),
-  terminalId: import_zod2.z.string()
-});
-var extMethodRequestSchema = import_zod2.z.record(import_zod2.z.unknown());
-var roleSchema = import_zod2.z.union([import_zod2.z.literal("assistant"), import_zod2.z.literal("user")]);
-var textResourceContentsSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  mimeType: import_zod2.z.string().optional().nullable(),
-  text: import_zod2.z.string(),
-  uri: import_zod2.z.string()
-});
-var blobResourceContentsSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  blob: import_zod2.z.string(),
-  mimeType: import_zod2.z.string().optional().nullable(),
-  uri: import_zod2.z.string()
-});
-var toolKindSchema = import_zod2.z.union([
-  import_zod2.z.literal("read"),
-  import_zod2.z.literal("edit"),
-  import_zod2.z.literal("delete"),
-  import_zod2.z.literal("move"),
-  import_zod2.z.literal("search"),
-  import_zod2.z.literal("execute"),
-  import_zod2.z.literal("think"),
-  import_zod2.z.literal("fetch"),
-  import_zod2.z.literal("switch_mode"),
-  import_zod2.z.literal("other")
-]);
-var toolCallStatusSchema = import_zod2.z.union([
-  import_zod2.z.literal("pending"),
-  import_zod2.z.literal("in_progress"),
-  import_zod2.z.literal("completed"),
-  import_zod2.z.literal("failed")
-]);
-var writeTextFileResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
-});
-var readTextFileResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  content: import_zod2.z.string()
-});
-var requestPermissionResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  outcome: import_zod2.z.union([
-    import_zod2.z.object({
-      outcome: import_zod2.z.literal("cancelled")
-    }),
-    import_zod2.z.object({
-      optionId: import_zod2.z.string(),
-      outcome: import_zod2.z.literal("selected")
-    })
-  ])
-});
-var createTerminalResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  terminalId: import_zod2.z.string()
-});
-var releaseTerminalResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
-});
-var waitForTerminalExitResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  exitCode: import_zod2.z.number().optional().nullable(),
-  signal: import_zod2.z.string().optional().nullable()
-});
-var killTerminalResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
-});
-var extMethodResponseSchema = import_zod2.z.record(import_zod2.z.unknown());
-var cancelNotificationSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string()
-});
-var extNotificationSchema = import_zod2.z.record(import_zod2.z.unknown());
-var authenticateRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  methodId: import_zod2.z.string()
-});
-var setSessionModeRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  modeId: import_zod2.z.string(),
-  sessionId: import_zod2.z.string()
-});
-var setSessionModelRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  modelId: import_zod2.z.string(),
-  sessionId: import_zod2.z.string()
-});
-var extMethodRequest1Schema = import_zod2.z.record(import_zod2.z.unknown());
-var httpHeaderSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  name: import_zod2.z.string(),
-  value: import_zod2.z.string()
-});
-var annotationsSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  audience: import_zod2.z.array(roleSchema).optional().nullable(),
-  lastModified: import_zod2.z.string().optional().nullable(),
-  priority: import_zod2.z.number().optional().nullable()
-});
-var embeddedResourceResourceSchema = import_zod2.z.union([
-  textResourceContentsSchema,
-  blobResourceContentsSchema
-]);
-var authenticateResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
-});
-var setSessionModeResponseSchema = import_zod2.z.object({
-  meta: import_zod2.z.unknown().optional()
-});
-var promptResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  stopReason: import_zod2.z.union([
-    import_zod2.z.literal("end_turn"),
-    import_zod2.z.literal("max_tokens"),
-    import_zod2.z.literal("max_turn_requests"),
-    import_zod2.z.literal("refusal"),
-    import_zod2.z.literal("cancelled")
-  ])
-});
-var setSessionModelResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional()
-});
-var extMethodResponse1Schema = import_zod2.z.record(import_zod2.z.unknown());
-var sessionModeIdSchema = import_zod2.z.string();
-var extNotification1Schema = import_zod2.z.record(import_zod2.z.unknown());
-var unstructuredCommandInputSchema = import_zod2.z.object({
-  hint: import_zod2.z.string()
-});
-var permissionOptionSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  kind: import_zod2.z.union([
-    import_zod2.z.literal("allow_once"),
-    import_zod2.z.literal("allow_always"),
-    import_zod2.z.literal("reject_once"),
-    import_zod2.z.literal("reject_always")
-  ]),
-  name: import_zod2.z.string(),
-  optionId: import_zod2.z.string()
-});
-var toolCallContentSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    content: import_zod2.z.union([
-      import_zod2.z.object({
-        _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-        annotations: annotationsSchema.optional().nullable(),
-        text: import_zod2.z.string(),
-        type: import_zod2.z.literal("text")
-      }),
-      import_zod2.z.object({
-        _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-        annotations: annotationsSchema.optional().nullable(),
-        data: import_zod2.z.string(),
-        mimeType: import_zod2.z.string(),
-        type: import_zod2.z.literal("image"),
-        uri: import_zod2.z.string().optional().nullable()
-      }),
-      import_zod2.z.object({
-        _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-        annotations: annotationsSchema.optional().nullable(),
-        data: import_zod2.z.string(),
-        mimeType: import_zod2.z.string(),
-        type: import_zod2.z.literal("audio")
-      }),
-      import_zod2.z.object({
-        _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-        annotations: annotationsSchema.optional().nullable(),
-        description: import_zod2.z.string().optional().nullable(),
-        mimeType: import_zod2.z.string().optional().nullable(),
-        name: import_zod2.z.string(),
-        size: import_zod2.z.number().optional().nullable(),
-        title: import_zod2.z.string().optional().nullable(),
-        type: import_zod2.z.literal("resource_link"),
-        uri: import_zod2.z.string()
-      }),
-      import_zod2.z.object({
-        _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-        annotations: annotationsSchema.optional().nullable(),
-        resource: embeddedResourceResourceSchema,
-        type: import_zod2.z.literal("resource")
-      })
-    ]),
-    type: import_zod2.z.literal("content")
-  }),
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    newText: import_zod2.z.string(),
-    oldText: import_zod2.z.string().optional().nullable(),
-    path: import_zod2.z.string(),
-    type: import_zod2.z.literal("diff")
-  }),
-  import_zod2.z.object({
-    terminalId: import_zod2.z.string(),
-    type: import_zod2.z.literal("terminal")
-  })
-]);
-var toolCallLocationSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  line: import_zod2.z.number().optional().nullable(),
-  path: import_zod2.z.string()
-});
-var envVariableSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  name: import_zod2.z.string(),
-  value: import_zod2.z.string()
-});
-var terminalExitStatusSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  exitCode: import_zod2.z.number().optional().nullable(),
-  signal: import_zod2.z.string().optional().nullable()
-});
-var fileSystemCapabilitySchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  readTextFile: import_zod2.z.boolean().optional(),
-  writeTextFile: import_zod2.z.boolean().optional()
-});
-var stdioSchema = import_zod2.z.object({
-  args: import_zod2.z.array(import_zod2.z.string()),
-  command: import_zod2.z.string(),
-  env: import_zod2.z.array(envVariableSchema),
-  name: import_zod2.z.string()
-});
-var mcpServerSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    headers: import_zod2.z.array(httpHeaderSchema),
-    name: import_zod2.z.string(),
-    type: import_zod2.z.literal("http"),
-    url: import_zod2.z.string()
-  }),
-  import_zod2.z.object({
-    headers: import_zod2.z.array(httpHeaderSchema),
-    name: import_zod2.z.string(),
-    type: import_zod2.z.literal("sse"),
-    url: import_zod2.z.string()
-  }),
-  stdioSchema
-]);
-var contentBlockSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    annotations: annotationsSchema.optional().nullable(),
-    text: import_zod2.z.string(),
-    type: import_zod2.z.literal("text")
-  }),
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    annotations: annotationsSchema.optional().nullable(),
-    data: import_zod2.z.string(),
-    mimeType: import_zod2.z.string(),
-    type: import_zod2.z.literal("image"),
-    uri: import_zod2.z.string().optional().nullable()
-  }),
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    annotations: annotationsSchema.optional().nullable(),
-    data: import_zod2.z.string(),
-    mimeType: import_zod2.z.string(),
-    type: import_zod2.z.literal("audio")
-  }),
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    annotations: annotationsSchema.optional().nullable(),
-    description: import_zod2.z.string().optional().nullable(),
-    mimeType: import_zod2.z.string().optional().nullable(),
-    name: import_zod2.z.string(),
-    size: import_zod2.z.number().optional().nullable(),
-    title: import_zod2.z.string().optional().nullable(),
-    type: import_zod2.z.literal("resource_link"),
-    uri: import_zod2.z.string()
-  }),
-  import_zod2.z.object({
-    _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-    annotations: annotationsSchema.optional().nullable(),
-    resource: embeddedResourceResourceSchema,
-    type: import_zod2.z.literal("resource")
-  })
-]);
-var authMethodSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  description: import_zod2.z.string().optional().nullable(),
-  id: import_zod2.z.string(),
-  name: import_zod2.z.string()
-});
-var mcpCapabilitiesSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  http: import_zod2.z.boolean().optional(),
-  sse: import_zod2.z.boolean().optional()
-});
-var promptCapabilitiesSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  audio: import_zod2.z.boolean().optional(),
-  embeddedContext: import_zod2.z.boolean().optional(),
-  image: import_zod2.z.boolean().optional()
-});
-var modelInfoSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  description: import_zod2.z.string().optional().nullable(),
-  modelId: import_zod2.z.string(),
-  name: import_zod2.z.string()
-});
-var sessionModeSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  description: import_zod2.z.string().optional().nullable(),
-  id: sessionModeIdSchema,
-  name: import_zod2.z.string()
-});
-var sessionModelStateSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  availableModels: import_zod2.z.array(modelInfoSchema),
-  currentModelId: import_zod2.z.string()
-});
-var sessionModeStateSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  availableModes: import_zod2.z.array(sessionModeSchema),
-  currentModeId: import_zod2.z.string()
-});
-var planEntrySchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  content: import_zod2.z.string(),
-  priority: import_zod2.z.union([import_zod2.z.literal("high"), import_zod2.z.literal("medium"), import_zod2.z.literal("low")]),
-  status: import_zod2.z.union([
-    import_zod2.z.literal("pending"),
-    import_zod2.z.literal("in_progress"),
-    import_zod2.z.literal("completed")
-  ])
-});
-var availableCommandInputSchema = unstructuredCommandInputSchema;
-var clientNotificationSchema = import_zod2.z.union([
-  cancelNotificationSchema,
-  extNotificationSchema
-]);
-var createTerminalRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  args: import_zod2.z.array(import_zod2.z.string()).optional(),
-  command: import_zod2.z.string(),
-  cwd: import_zod2.z.string().optional().nullable(),
-  env: import_zod2.z.array(envVariableSchema).optional(),
-  outputByteLimit: import_zod2.z.number().optional().nullable(),
-  sessionId: import_zod2.z.string()
-});
-var terminalOutputResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  exitStatus: terminalExitStatusSchema.optional().nullable(),
-  output: import_zod2.z.string(),
-  truncated: import_zod2.z.boolean()
-});
-var newSessionRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  cwd: import_zod2.z.string(),
-  mcpServers: import_zod2.z.array(mcpServerSchema)
-});
-var loadSessionRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  cwd: import_zod2.z.string(),
-  mcpServers: import_zod2.z.array(mcpServerSchema),
-  sessionId: import_zod2.z.string()
-});
-var promptRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  prompt: import_zod2.z.array(contentBlockSchema),
-  sessionId: import_zod2.z.string()
-});
-var newSessionResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  models: sessionModelStateSchema.optional().nullable(),
-  modes: sessionModeStateSchema.optional().nullable(),
-  sessionId: import_zod2.z.string()
-});
-var loadSessionResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  models: sessionModelStateSchema.optional().nullable(),
-  modes: sessionModeStateSchema.optional().nullable()
-});
-var toolCallUpdateSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  content: import_zod2.z.array(toolCallContentSchema).optional().nullable(),
-  kind: toolKindSchema.optional().nullable(),
-  locations: import_zod2.z.array(toolCallLocationSchema).optional().nullable(),
-  rawInput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  rawOutput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  status: toolCallStatusSchema.optional().nullable(),
-  title: import_zod2.z.string().optional().nullable(),
-  toolCallId: import_zod2.z.string()
-});
-var clientCapabilitiesSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  fs: fileSystemCapabilitySchema.optional(),
-  terminal: import_zod2.z.boolean().optional()
-});
-var agentCapabilitiesSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  loadSession: import_zod2.z.boolean().optional(),
-  mcpCapabilities: mcpCapabilitiesSchema.optional(),
-  promptCapabilities: promptCapabilitiesSchema.optional()
-});
-var availableCommandSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  description: import_zod2.z.string(),
-  input: availableCommandInputSchema.optional().nullable(),
-  name: import_zod2.z.string()
-});
-var clientResponseSchema = import_zod2.z.union([
-  writeTextFileResponseSchema,
-  readTextFileResponseSchema,
-  requestPermissionResponseSchema,
-  createTerminalResponseSchema,
-  terminalOutputResponseSchema,
-  releaseTerminalResponseSchema,
-  waitForTerminalExitResponseSchema,
-  killTerminalResponseSchema,
-  extMethodResponseSchema
-]);
-var requestPermissionRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  options: import_zod2.z.array(permissionOptionSchema),
-  sessionId: import_zod2.z.string(),
-  toolCall: toolCallUpdateSchema
-});
-var initializeRequestSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  clientCapabilities: clientCapabilitiesSchema.optional(),
-  protocolVersion: import_zod2.z.number()
-});
-var initializeResponseSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  agentCapabilities: agentCapabilitiesSchema.optional(),
-  authMethods: import_zod2.z.array(authMethodSchema).optional(),
-  protocolVersion: import_zod2.z.number()
-});
-var sessionNotificationSchema = import_zod2.z.object({
-  _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-  sessionId: import_zod2.z.string(),
-  update: import_zod2.z.union([
-    import_zod2.z.object({
-      content: contentBlockSchema,
-      sessionUpdate: import_zod2.z.literal("user_message_chunk")
-    }),
-    import_zod2.z.object({
-      content: contentBlockSchema,
-      sessionUpdate: import_zod2.z.literal("agent_message_chunk")
-    }),
-    import_zod2.z.object({
-      content: contentBlockSchema,
-      sessionUpdate: import_zod2.z.literal("agent_thought_chunk")
-    }),
-    import_zod2.z.object({
-      _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      content: import_zod2.z.array(toolCallContentSchema).optional(),
-      kind: import_zod2.z.union([
-        import_zod2.z.literal("read"),
-        import_zod2.z.literal("edit"),
-        import_zod2.z.literal("delete"),
-        import_zod2.z.literal("move"),
-        import_zod2.z.literal("search"),
-        import_zod2.z.literal("execute"),
-        import_zod2.z.literal("think"),
-        import_zod2.z.literal("fetch"),
-        import_zod2.z.literal("switch_mode"),
-        import_zod2.z.literal("other")
-      ]).optional(),
-      locations: import_zod2.z.array(toolCallLocationSchema).optional(),
-      rawInput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      rawOutput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      sessionUpdate: import_zod2.z.literal("tool_call"),
-      status: import_zod2.z.union([
-        import_zod2.z.literal("pending"),
-        import_zod2.z.literal("in_progress"),
-        import_zod2.z.literal("completed"),
-        import_zod2.z.literal("failed")
-      ]).optional(),
-      title: import_zod2.z.string(),
-      toolCallId: import_zod2.z.string()
-    }),
-    import_zod2.z.object({
-      _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      content: import_zod2.z.array(toolCallContentSchema).optional().nullable(),
-      kind: toolKindSchema.optional().nullable(),
-      locations: import_zod2.z.array(toolCallLocationSchema).optional().nullable(),
-      rawInput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      rawOutput: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      sessionUpdate: import_zod2.z.literal("tool_call_update"),
-      status: toolCallStatusSchema.optional().nullable(),
-      title: import_zod2.z.string().optional().nullable(),
-      toolCallId: import_zod2.z.string()
-    }),
-    import_zod2.z.object({
-      _meta: import_zod2.z.record(import_zod2.z.unknown()).optional(),
-      entries: import_zod2.z.array(planEntrySchema),
-      sessionUpdate: import_zod2.z.literal("plan")
-    }),
-    import_zod2.z.object({
-      availableCommands: import_zod2.z.array(availableCommandSchema),
-      sessionUpdate: import_zod2.z.literal("available_commands_update")
-    }),
-    import_zod2.z.object({
-      currentModeId: sessionModeIdSchema,
-      sessionUpdate: import_zod2.z.literal("current_mode_update")
-    })
-  ])
-});
-var clientRequestSchema = import_zod2.z.union([
-  writeTextFileRequestSchema,
-  readTextFileRequestSchema,
-  requestPermissionRequestSchema,
-  createTerminalRequestSchema,
-  terminalOutputRequestSchema,
-  releaseTerminalRequestSchema,
-  waitForTerminalExitRequestSchema,
-  killTerminalCommandRequestSchema,
-  extMethodRequestSchema
-]);
-var agentRequestSchema = import_zod2.z.union([
-  initializeRequestSchema,
-  authenticateRequestSchema,
-  newSessionRequestSchema,
-  loadSessionRequestSchema,
-  setSessionModeRequestSchema,
-  promptRequestSchema,
-  setSessionModelRequestSchema,
-  extMethodRequest1Schema
-]);
-var agentResponseSchema = import_zod2.z.union([
-  initializeResponseSchema,
-  authenticateResponseSchema,
-  newSessionResponseSchema,
-  loadSessionResponseSchema,
-  setSessionModeResponseSchema,
-  promptResponseSchema,
-  setSessionModelResponseSchema,
-  extMethodResponse1Schema
-]);
-var agentNotificationSchema = import_zod2.z.union([
-  sessionNotificationSchema,
-  extNotification1Schema
-]);
-var agentClientProtocolSchema = import_zod2.z.union([
-  clientRequestSchema,
-  clientResponseSchema,
-  clientNotificationSchema,
-  agentRequestSchema,
-  agentResponseSchema,
-  agentNotificationSchema
-]);
-
-// __mcpc__cli_latest/node_modules/@agentclientprotocol/sdk/dist/stream.js
-function ndJsonStream(output, input) {
-  const textEncoder = new TextEncoder();
-  const textDecoder = new TextDecoder();
-  const readable = new ReadableStream({
-    async start(controller) {
-      let content = "";
-      const reader = input.getReader();
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) {
-            break;
-          }
-          if (!value) {
-            continue;
-          }
-          content += textDecoder.decode(value, { stream: true });
-          const lines = content.split("\n");
-          content = lines.pop() || "";
-          for (const line of lines) {
-            const trimmedLine = line.trim();
-            if (trimmedLine) {
-              try {
-                const message = JSON.parse(trimmedLine);
-                controller.enqueue(message);
-              } catch (err) {
-                console.error("Failed to parse JSON message:", trimmedLine, err);
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-        controller.close();
-      }
-    }
-  });
-  const writable = new WritableStream({
-    async write(message) {
-      const content = JSON.stringify(message) + "\n";
-      const writer = output.getWriter();
-      try {
-        await writer.write(textEncoder.encode(content));
-      } finally {
-        writer.releaseLock();
-      }
-    }
-  });
-  return { readable, writable };
-}
-
-// __mcpc__cli_latest/node_modules/@agentclientprotocol/sdk/dist/acp.js
-var ClientSideConnection = class {
-  #connection;
-  /**
-   * Creates a new client-side connection to an agent.
-   *
-   * This establishes the communication channel between a client and agent
-   * following the ACP specification.
-   *
-   * @param toClient - A function that creates a Client handler to process incoming agent requests
-   * @param stream - The bidirectional message stream for communication. Typically created using
-   *                 {@link ndJsonStream} for stdio-based connections.
-   *
-   * See protocol docs: [Communication Model](https://agentclientprotocol.com/protocol/overview#communication-model)
-   */
-  constructor(toClient, stream) {
-    const client = toClient(this);
-    const requestHandler = async (method, params) => {
-      switch (method) {
-        case CLIENT_METHODS.fs_write_text_file: {
-          const validatedParams = writeTextFileRequestSchema.parse(params);
-          return client.writeTextFile?.(validatedParams);
-        }
-        case CLIENT_METHODS.fs_read_text_file: {
-          const validatedParams = readTextFileRequestSchema.parse(params);
-          return client.readTextFile?.(validatedParams);
-        }
-        case CLIENT_METHODS.session_request_permission: {
-          const validatedParams = requestPermissionRequestSchema.parse(params);
-          return client.requestPermission(validatedParams);
-        }
-        case CLIENT_METHODS.terminal_create: {
-          const validatedParams = createTerminalRequestSchema.parse(params);
-          return client.createTerminal?.(validatedParams);
-        }
-        case CLIENT_METHODS.terminal_output: {
-          const validatedParams = terminalOutputRequestSchema.parse(params);
-          return client.terminalOutput?.(validatedParams);
-        }
-        case CLIENT_METHODS.terminal_release: {
-          const validatedParams = releaseTerminalRequestSchema.parse(params);
-          const result = await client.releaseTerminal?.(validatedParams);
-          return result ?? {};
-        }
-        case CLIENT_METHODS.terminal_wait_for_exit: {
-          const validatedParams = waitForTerminalExitRequestSchema.parse(params);
-          return client.waitForTerminalExit?.(validatedParams);
-        }
-        case CLIENT_METHODS.terminal_kill: {
-          const validatedParams = killTerminalCommandRequestSchema.parse(params);
-          const result = await client.killTerminal?.(validatedParams);
-          return result ?? {};
-        }
-        default:
-          if (method.startsWith("_")) {
-            const customMethod = method.substring(1);
-            if (!client.extMethod) {
-              throw RequestError.methodNotFound(method);
-            }
-            return client.extMethod(customMethod, params);
-          }
-          throw RequestError.methodNotFound(method);
-      }
-    };
-    const notificationHandler = async (method, params) => {
-      switch (method) {
-        case CLIENT_METHODS.session_update: {
-          const validatedParams = sessionNotificationSchema.parse(params);
-          return client.sessionUpdate(validatedParams);
-        }
-        default:
-          if (method.startsWith("_")) {
-            const customMethod = method.substring(1);
-            if (!client.extNotification) {
-              return;
-            }
-            return client.extNotification(customMethod, params);
-          }
-          throw RequestError.methodNotFound(method);
-      }
-    };
-    this.#connection = new Connection(requestHandler, notificationHandler, stream);
-  }
-  /**
-   * Establishes the connection with a client and negotiates protocol capabilities.
-   *
-   * This method is called once at the beginning of the connection to:
-   * - Negotiate the protocol version to use
-   * - Exchange capability information between client and agent
-   * - Determine available authentication methods
-   *
-   * The agent should respond with its supported protocol version and capabilities.
-   *
-   * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
-   */
-  async initialize(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.initialize, params);
-  }
-  /**
-   * Creates a new conversation session with the agent.
-   *
-   * Sessions represent independent conversation contexts with their own history and state.
-   *
-   * The agent should:
-   * - Create a new session context
-   * - Connect to any specified MCP servers
-   * - Return a unique session ID for future requests
-   *
-   * May return an `auth_required` error if the agent requires authentication.
-   *
-   * See protocol docs: [Session Setup](https://agentclientprotocol.com/protocol/session-setup)
-   */
-  async newSession(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.session_new, params);
-  }
-  /**
-   * Loads an existing session to resume a previous conversation.
-   *
-   * This method is only available if the agent advertises the `loadSession` capability.
-   *
-   * The agent should:
-   * - Restore the session context and conversation history
-   * - Connect to the specified MCP servers
-   * - Stream the entire conversation history back to the client via notifications
-   *
-   * See protocol docs: [Loading Sessions](https://agentclientprotocol.com/protocol/session-setup#loading-sessions)
-   */
-  async loadSession(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.session_load, params) ?? {};
-  }
-  /**
-   * Sets the operational mode for a session.
-   *
-   * Allows switching between different agent modes (e.g., "ask", "architect", "code")
-   * that affect system prompts, tool availability, and permission behaviors.
-   *
-   * The mode must be one of the modes advertised in `availableModes` during session
-   * creation or loading. Agents may also change modes autonomously and notify the
-   * client via `current_mode_update` notifications.
-   *
-   * This method can be called at any time during a session, whether the Agent is
-   * idle or actively generating a turn.
-   *
-   * See protocol docs: [Session Modes](https://agentclientprotocol.com/protocol/session-modes)
-   */
-  async setSessionMode(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.session_set_mode, params) ?? {};
-  }
-  /**
-   * **UNSTABLE**
-   *
-   * This capability is not part of the spec yet, and may be removed or changed at any point.
-   *
-   * Select a model for a given session.
-   */
-  async setSessionModel(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.session_set_model, params) ?? {};
-  }
-  /**
-   * Authenticates the client using the specified authentication method.
-   *
-   * Called when the agent requires authentication before allowing session creation.
-   * The client provides the authentication method ID that was advertised during initialization.
-   *
-   * After successful authentication, the client can proceed to create sessions with
-   * `newSession` without receiving an `auth_required` error.
-   *
-   * See protocol docs: [Initialization](https://agentclientprotocol.com/protocol/initialization)
-   */
-  async authenticate(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.authenticate, params) ?? {};
-  }
-  /**
-   * Processes a user prompt within a session.
-   *
-   * This method handles the whole lifecycle of a prompt:
-   * - Receives user messages with optional context (files, images, etc.)
-   * - Processes the prompt using language models
-   * - Reports language model content and tool calls to the Clients
-   * - Requests permission to run tools
-   * - Executes any requested tool calls
-   * - Returns when the turn is complete with a stop reason
-   *
-   * See protocol docs: [Prompt Turn](https://agentclientprotocol.com/protocol/prompt-turn)
-   */
-  async prompt(params) {
-    return await this.#connection.sendRequest(AGENT_METHODS.session_prompt, params);
-  }
-  /**
-   * Cancels ongoing operations for a session.
-   *
-   * This is a notification sent by the client to cancel an ongoing prompt turn.
-   *
-   * Upon receiving this notification, the Agent SHOULD:
-   * - Stop all language model requests as soon as possible
-   * - Abort all tool call invocations in progress
-   * - Send any pending `session/update` notifications
-   * - Respond to the original `session/prompt` request with `StopReason::Cancelled`
-   *
-   * See protocol docs: [Cancellation](https://agentclientprotocol.com/protocol/prompt-turn#cancellation)
-   */
-  async cancel(params) {
-    return await this.#connection.sendNotification(AGENT_METHODS.session_cancel, params);
-  }
-  /**
-   * Extension method
-   *
-   * Allows the Client to send an arbitrary request that is not part of the ACP spec.
-   */
-  async extMethod(method, params) {
-    return await this.#connection.sendRequest(`_${method}`, params);
-  }
-  /**
-   * Extension notification
-   *
-   * Allows the Client to send an arbitrary notification that is not part of the ACP spec.
-   */
-  async extNotification(method, params) {
-    return await this.#connection.sendNotification(`_${method}`, params);
-  }
-};
-var Connection = class {
-  #pendingResponses = /* @__PURE__ */ new Map();
-  #nextRequestId = 0;
-  #requestHandler;
-  #notificationHandler;
-  #stream;
-  #writeQueue = Promise.resolve();
-  constructor(requestHandler, notificationHandler, stream) {
-    this.#requestHandler = requestHandler;
-    this.#notificationHandler = notificationHandler;
-    this.#stream = stream;
-    this.#receive();
-  }
-  async #receive() {
-    const reader = this.#stream.readable.getReader();
-    try {
-      while (true) {
-        const { value: message, done } = await reader.read();
-        if (done) {
-          break;
-        }
-        if (!message) {
-          continue;
-        }
-        try {
-          this.#processMessage(message);
-        } catch (err) {
-          console.error("Unexpected error during message processing:", message, err);
-          if ("id" in message && message.id !== void 0) {
-            this.#sendMessage({
-              jsonrpc: "2.0",
-              id: message.id,
-              error: {
-                code: -32700,
-                message: "Parse error"
-              }
-            });
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-  }
-  async #processMessage(message) {
-    if ("method" in message && "id" in message) {
-      const response = await this.#tryCallRequestHandler(message.method, message.params);
-      if ("error" in response) {
-        console.error("Error handling request", message, response.error);
-      }
-      await this.#sendMessage({
-        jsonrpc: "2.0",
-        id: message.id,
-        ...response
-      });
-    } else if ("method" in message) {
-      const response = await this.#tryCallNotificationHandler(message.method, message.params);
-      if ("error" in response) {
-        console.error("Error handling notification", message, response.error);
-      }
-    } else if ("id" in message) {
-      this.#handleResponse(message);
-    } else {
-      console.error("Invalid message", { message });
-    }
-  }
-  async #tryCallRequestHandler(method, params) {
-    try {
-      const result = await this.#requestHandler(method, params);
-      return { result: result ?? null };
-    } catch (error) {
-      if (error instanceof RequestError) {
-        return error.toResult();
-      }
-      if (error instanceof import_zod3.z.ZodError) {
-        return RequestError.invalidParams(error.format()).toResult();
-      }
-      let details;
-      if (error instanceof Error) {
-        details = error.message;
-      } else if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
-        details = error.message;
-      }
-      try {
-        return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-      } catch {
-        return RequestError.internalError({ details }).toResult();
-      }
-    }
-  }
-  async #tryCallNotificationHandler(method, params) {
-    try {
-      await this.#notificationHandler(method, params);
-      return { result: null };
-    } catch (error) {
-      if (error instanceof RequestError) {
-        return error.toResult();
-      }
-      if (error instanceof import_zod3.z.ZodError) {
-        return RequestError.invalidParams(error.format()).toResult();
-      }
-      let details;
-      if (error instanceof Error) {
-        details = error.message;
-      } else if (typeof error === "object" && error != null && "message" in error && typeof error.message === "string") {
-        details = error.message;
-      }
-      try {
-        return RequestError.internalError(details ? JSON.parse(details) : {}).toResult();
-      } catch {
-        return RequestError.internalError({ details }).toResult();
-      }
-    }
-  }
-  #handleResponse(response) {
-    const pendingResponse = this.#pendingResponses.get(response.id);
-    if (pendingResponse) {
-      if ("result" in response) {
-        pendingResponse.resolve(response.result);
-      } else if ("error" in response) {
-        pendingResponse.reject(response.error);
-      }
-      this.#pendingResponses.delete(response.id);
-    } else {
-      console.error("Got response to unknown request", response.id);
-    }
-  }
-  async sendRequest(method, params) {
-    const id = this.#nextRequestId++;
-    const responsePromise = new Promise((resolve3, reject) => {
-      this.#pendingResponses.set(id, { resolve: resolve3, reject });
-    });
-    await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
-    return responsePromise;
-  }
-  async sendNotification(method, params) {
-    await this.#sendMessage({ jsonrpc: "2.0", method, params });
-  }
-  async #sendMessage(message) {
-    this.#writeQueue = this.#writeQueue.then(async () => {
-      const writer = this.#stream.writable.getWriter();
-      try {
-        await writer.write(message);
-      } finally {
-        writer.releaseLock();
-      }
-    }).catch((error) => {
-      console.error("ACP write error:", error);
-    });
-    return this.#writeQueue;
-  }
-};
-var RequestError = class _RequestError extends Error {
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.name = "RequestError";
-    this.data = data;
-  }
-  /**
-   * Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
-   */
-  static parseError(data) {
-    return new _RequestError(-32700, "Parse error", data);
-  }
-  /**
-   * The JSON sent is not a valid Request object.
-   */
-  static invalidRequest(data) {
-    return new _RequestError(-32600, "Invalid request", data);
-  }
-  /**
-   * The method does not exist / is not available.
-   */
-  static methodNotFound(method) {
-    return new _RequestError(-32601, "Method not found", { method });
-  }
-  /**
-   * Invalid method parameter(s).
-   */
-  static invalidParams(data) {
-    return new _RequestError(-32602, "Invalid params", data);
-  }
-  /**
-   * Internal JSON-RPC error.
-   */
-  static internalError(data) {
-    return new _RequestError(-32603, "Internal error", data);
-  }
-  /**
-   * Authentication required.
-   */
-  static authRequired(data) {
-    return new _RequestError(-32e3, "Authentication required", data);
-  }
-  /**
-   * Resource, such as a file, was not found
-   */
-  static resourceNotFound(uri) {
-    return new _RequestError(-32002, "Resource not found", uri && { uri });
-  }
-  toResult() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        data: this.data
-      }
-    };
-  }
-  toErrorResponse() {
-    return {
-      code: this.code,
-      message: this.message,
-      data: this.data
-    };
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/language-model.js
-var import_node_child_process = require("node:child_process");
-var import_node_process8 = __toESM(require("node:process"), 1);
-var import_node_stream2 = require("node:stream");
-var import_zod4 = __toESM(require("zod"), 1);
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/format-tool-error.js
-function formatToolError(toolResult) {
-  if (!toolResult || toolResult.length === 0) return "Unknown tool error";
-  const parts = [];
-  for (const blk of toolResult) {
-    if (blk.type === "content") {
-      if (blk.content.type === "text") {
-        parts.push(blk.content.text);
-      }
-    }
-  }
-  return parts.join("\n");
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/tool-proxy/tool-proxy-host.js
-var import_node_net = require("node:net");
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/tool-proxy/json-rpc.js
-function createResponse(id, result) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    result
-  };
-}
-function createErrorResponse(id, code, message, data) {
-  const error = {
-    code,
-    message
-  };
-  if (data !== void 0) {
-    error.data = data;
-  }
-  return {
-    jsonrpc: "2.0",
-    id,
-    error
-  };
-}
-function parseMessage(line) {
-  try {
-    const parsed = JSON.parse(line);
-    if (parsed.jsonrpc !== "2.0") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function serializeMessage2(message) {
-  return JSON.stringify(message);
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/tool-proxy/types.js
-var JsonRpcErrorCode = {
-  PARSE_ERROR: -32700,
-  INVALID_REQUEST: -32600,
-  METHOD_NOT_FOUND: -32601,
-  INVALID_PARAMS: -32602,
-  INTERNAL_ERROR: -32603
-};
-var ProxyMethod = {
-  // Host -> Proxy
-  REGISTER_TOOLS: "registerTools",
-  // Proxy -> Host
-  CALL_HANDLER: "callHandler"
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/tool-proxy/tool-proxy-runtime.js
-var RUNTIME_CODE = `
-/* MCP Protocol Version 2024-11-05 */
-const isDeno=typeof Deno!=="undefined",MCP_VER="2024-11-05";
-let tools=[],host=null,pending=new Map,buf="",hbuf="",rid=0;
-const env=k=>isDeno?Deno.env.get(k):process.env[k];
-const write=async m=>{
-  const s=JSON.stringify(m)+"\\n";
-  if(isDeno)await Deno.stdout.write(new TextEncoder().encode(s));
-  else process.stdout.write(s);
-};
-const send=(id,r,e)=>write({jsonrpc:"2.0",id,...(e?{error:e}:{result:r})});
-const hostReq=(m,p)=>new Promise((res,rej)=>{
-  const id="r-"+ ++rid;
-  const s=JSON.stringify({jsonrpc:"2.0",id,method:m,params:p})+"\\n";
-  if(isDeno)host.write(new TextEncoder().encode(s));
-  else host.write(s);
-  const t=setTimeout(()=>{pending.delete(id);rej(new Error("timeout"))},30000);
-  pending.set(id,{resolve:v=>{clearTimeout(t);res(v)},reject:e=>{clearTimeout(t);rej(e)}});
-});
-const init=async()=>{
-  const p=parseInt(env("ACP_TOOL_PROXY_PORT")||"0",10);
-  if(p){
-    if(isDeno){
-      host=await Deno.connect({hostname:"127.0.0.1",port:p});
-      (async()=>{
-        const d=new TextDecoder(),b=new Uint8Array(65536);
-        while(true){const n=await host.read(b);if(!n)break;
-        hbuf+=d.decode(b.subarray(0,n));let ls=hbuf.split("\\n");hbuf=ls.pop();
-        for(let l of ls)if(l.trim())onHostMsg(l)}})();
-    }else{
-      host=require("net").createConnection({host:"127.0.0.1",port:p});
-      await new Promise(r=>host.on("connect",r));
-      host.on("data",d=>{hbuf+=d;let ls=hbuf.split("\\n");hbuf=ls.pop();
-        for(let l of ls)if(l.trim())onHostMsg(l)});
-    }
-    try{tools=await hostReq("getTools")}catch(e){
-       const m="Failed to get tools: "+e.message+"\\n";
-       if(isDeno)Deno.stderr.write(new TextEncoder().encode(m));
-       else process.stderr.write(m);
-    }
-  }
-};
-const onHostMsg=l=>{try{let r=JSON.parse(l),h=pending.get(r.id);
-  if(h){pending.delete(r.id);r.error?h.reject(new Error(r.error.message)):h.resolve(r.result)}}catch{}};
-const handle=async l=>{let m;try{m=JSON.parse(l)}catch{return}if(m.jsonrpc!=="2.0")return;
-  if(m.method==="initialize")send(m.id,{protocolVersion:MCP_VER,capabilities:{tools:{}},serverInfo:{name:"proxy",version:"1.0"}});
-  else if(m.method==="notifications/initialized");
-  else if(m.method==="tools/list")send(m.id,{tools:tools.map(t=>({name:t.name,description:t.description,inputSchema:t.inputSchema}))});
-  else if(m.method==="tools/call"){let p=m.params,t=tools.find(x=>x.name===p.name);
-    if(!t)send(m.id,null,{code:-32601,message:"Not found"});
-    else try{let r=await hostReq("callHandler",{name:p.name,args:p.arguments||{}});send(m.id,r)}
-    catch(e){send(m.id,{content:[{type:"text",text:"Error: "+e.message}],isError:true})}}
-  else send(m.id,null,{code:-32601,message:"Unknown"});
-};
-init().then(async()=>{
-  if(isDeno){
-    const d=new TextDecoder(),b=new Uint8Array(65536);
-    while(true){const n=await Deno.stdin.read(b);if(!n)break;
-      buf+=d.decode(b.subarray(0,n));let ls=buf.split("\\n");buf=ls.pop();for(let l of ls)if(l.trim())handle(l)}
-  }else{
-    process.stdin.setEncoding("utf8");
-    process.stdin.on("data",c=>{buf+=c;let ls=buf.split("\\n");buf=ls.pop();for(let l of ls)if(l.trim())handle(l)});
-  }
-});
-`.trim().replace(/\n/g, "");
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/tool-proxy/tool-proxy-host.js
-var ToolProxyHost = class {
-  server = null;
-  connections = [];
-  tools = /* @__PURE__ */ new Map();
-  serverName;
-  port = 0;
-  constructor(name = "acp-tool-proxy") {
-    this.serverName = name;
-  }
-  /**
-   * Register an AI SDK tool to be exposed through the proxy
-   */
-  registerTool(name, tool3) {
-    this.tools.set(name, tool3);
-  }
-  /**
-   * Register multiple tools at once
-   */
-  registerTools(tools) {
-    for (const [name, tool3] of Object.entries(tools)) {
-      this.registerTool(name, tool3);
-    }
-  }
-  /**
-   * Get tool definitions for the runtime
-   */
-  getToolDefinitions() {
-    const definitions = [];
-    for (const [name, tool3] of this.tools.entries()) {
-      definitions.push({
-        name,
-        description: tool3.description || `Tool: ${name}`,
-        // inputSchema from Tool can be Zod or JSON schema, cast to JSON schema format
-        inputSchema: tool3.inputSchema || {
-          type: "object",
-          properties: {}
-        }
-      });
-    }
-    return definitions;
-  }
-  /**
-   * Start TCP server and return MCP server config for ACP
-   */
-  async start() {
-    if (!this.server) {
-      await this.startServer();
-    }
-    return this.getServerConfig();
-  }
-  /**
-   * Get MCP server configuration
-   */
-  getServerConfig() {
-    return {
-      name: this.serverName,
-      command: "node",
-      args: [
-        "-e",
-        RUNTIME_CODE
-      ],
-      env: [
-        {
-          name: "ACP_TOOL_PROXY_PORT",
-          value: String(this.port)
-        }
-      ]
-    };
-  }
-  /**
-   * Start TCP server to receive tool execution requests
-   */
-  startServer() {
-    return new Promise((resolve3, reject) => {
-      this.server = (0, import_node_net.createServer)((socket) => {
-        this.handleConnection(socket);
-      });
-      this.server.on("error", (err) => {
-        reject(err);
-      });
-      this.server.listen(0, "127.0.0.1", () => {
-        const address = this.server.address();
-        if (typeof address === "object" && address) {
-          this.port = address.port;
-          resolve3();
-        } else {
-          reject(new Error("Failed to get server address"));
-        }
-      });
-    });
-  }
-  /**
-   * Handle incoming connection from runtime
-   */
-  handleConnection(socket) {
-    this.connections.push(socket);
-    let buffer = "";
-    socket.on("data", (data) => {
-      buffer += data.toString();
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        const message = parseMessage(line);
-        if (!message) continue;
-        if ("method" in message) {
-          this.handleRequest(socket, message).catch((err) => console.error("[ToolProxy] Error handling request:", err));
-        }
-      }
-    });
-    socket.on("close", () => {
-      this.connections = this.connections.filter((c) => c !== socket);
-    });
-    socket.on("error", (err) => {
-      console.error("[ToolProxy] Socket error:", err);
-    });
-  }
-  /**
-   * Handle JSON-RPC request from runtime
-   */
-  async handleRequest(socket, request) {
-    try {
-      if (request.method === ProxyMethod.CALL_HANDLER) {
-        const params = request.params;
-        const tool3 = this.tools.get(params.name);
-        if (!tool3) {
-          this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Tool not found: ${params.name}`));
-          return;
-        }
-        if (!tool3.execute) {
-          const clientToolResult = {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  isClientTool: true,
-                  toolName: params.name,
-                  args: params.args
-                })
-              }
-            ],
-            isError: false
-          };
-          this.sendResponse(socket, createResponse(request.id, clientToolResult));
-          return;
-        }
-        const result = await tool3.execute(params.args, {
-          toolCallId: params.name,
-          messages: []
-        });
-        let toolResult;
-        const parseResult = CallToolResultSchema.safeParse(result);
-        if (parseResult.success) {
-          toolResult = parseResult.data;
-        } else {
-          toolResult = {
-            content: [
-              {
-                type: "text",
-                text: typeof result === "string" ? result : JSON.stringify(result)
-              }
-            ]
-          };
-        }
-        this.sendResponse(socket, createResponse(request.id, toolResult));
-      } else if (request.method === "getTools") {
-        const definitions = this.getToolDefinitions();
-        this.sendResponse(socket, createResponse(request.id, definitions));
-      } else {
-        this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Unknown method: ${request.method}`));
-      }
-    } catch (error) {
-      this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.INTERNAL_ERROR, error instanceof Error ? error.message : String(error)));
-    }
-  }
-  /**
-   * Send response to runtime
-   */
-  sendResponse(socket, response) {
-    socket.write(serializeMessage2(response) + "\n");
-  }
-  /**
-   * Stop the TCP server
-   */
-  stop() {
-    for (const socket of this.connections) {
-      socket.destroy();
-    }
-    this.connections = [];
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-    this.port = 0;
-  }
-};
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/acp-tool.js
-var import_ai2 = require("ai");
-var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME = "acp.acp_provider_agent_dynamic_tool";
-var executeRegistry = /* @__PURE__ */ new Map();
-function acpTools(tools) {
-  for (const [name, toolDef] of Object.entries(tools)) {
-    executeRegistry.set(name, toolDef.execute);
-  }
-  return {
-    ...tools,
-    ...getACPDynamicTool()
-  };
-}
-function getACPDynamicTool() {
-  return {
-    [ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME]: (0, import_ai2.tool)({
-      type: "provider-defined",
-      id: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
-      name: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
-      args: {},
-      inputSchema: (0, import_ai2.jsonSchema)({})
-    })
-  };
-}
-function getExecuteByName(name) {
-  return executeRegistry.get(name);
-}
-function hasRegisteredExecute(name) {
-  return executeRegistry.has(name);
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/utils.js
-function extractBase64Data(data) {
-  return data.includes(",") ? data.split(",")[1] : data;
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/convert-utils.js
-var import_ai3 = require("ai");
-function convertAiSdkMessagesToAcp(options, isFreshSession) {
-  const messages = !isFreshSession ? options.prompt.filter((m) => m.role === "user").slice(-1) : options.prompt;
-  const contentBlocks = [];
-  for (const msg of messages) {
-    let prefix = "";
-    if (msg.role === "system") prefix = "System: ";
-    else if (msg.role === "assistant") prefix = "Assistant: ";
-    else if (msg.role === "tool") prefix = "Result: ";
-    if (Array.isArray(msg.content)) {
-      let isFirst = true;
-      for (const part of msg.content) {
-        if (part.type === "text") {
-          const text = isFirst ? `${prefix}${part.text} ` : part.text;
-          contentBlocks.push({
-            type: "text",
-            text
-          });
-          isFirst = false;
-        } else if (part.type === "tool-call") {
-          const toolCallText = `[Tool Call: ${part.toolName}(${JSON.stringify(part.input)})]`;
-          const text = isFirst ? `${prefix}${toolCallText} ` : toolCallText;
-          contentBlocks.push({
-            type: "text",
-            text
-          });
-          isFirst = false;
-        } else if (part.type === "tool-result") {
-          const resultData = part.result ?? part.output;
-          const resultText = JSON.stringify(resultData) ?? "null";
-          const text = isFirst ? `${prefix}${resultText} ` : resultText;
-          contentBlocks.push({
-            type: "text",
-            text
-          });
-          isFirst = false;
-        } else if (part.type === "file" && typeof part.data === "string") {
-          const type = part.mediaType.startsWith("image/") ? "image" : part.mediaType.startsWith("audio/") ? "audio" : null;
-          if (type) {
-            contentBlocks.push({
-              type,
-              mimeType: part.mediaType,
-              data: extractBase64Data(part.data)
-            });
-          }
-        }
-      }
-    } else if (typeof msg.content === "string") {
-      contentBlocks.push({
-        type: "text",
-        text: `${prefix}${msg.content} `
-      });
-    }
-  }
-  return contentBlocks;
-}
-function extractACPTools(tools, prepared = true) {
-  const acpTools2 = [];
-  if (!tools) {
-    return acpTools2;
-  }
-  const toolsArray = Array.isArray(tools) ? tools : Object.entries(tools).map(([name, tool3]) => ({
-    type: "function",
-    name,
-    ...tool3
-  }));
-  for (const t of toolsArray) {
-    if (t.type === "function") {
-      const toolWithSchema = t;
-      const toolInputSchema = toolWithSchema.inputSchema;
-      if (hasRegisteredExecute(t.name) && toolInputSchema) {
-        const execute = getExecuteByName(t.name);
-        acpTools2.push({
-          ...t,
-          name: t.name,
-          inputSchema: prepared ? toolInputSchema : (0, import_ai3.asSchema)(toolInputSchema).jsonSchema,
-          execute
-        });
-      }
-    }
-  }
-  return acpTools2;
-}
-
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/language-model.js
-var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2 = "acp.acp_provider_agent_dynamic_tool";
-var providerAgentDynamicToolSchema = import_zod4.default.object({
-  toolCallId: import_zod4.default.string().describe("The unique ID of the tool call."),
-  toolName: import_zod4.default.string().describe("The name of the tool being called."),
-  args: import_zod4.default.record(import_zod4.default.unknown()).describe("The input arguments for the tool call.")
-});
-var ACPAISDKClient = class {
-  onSessionUpdateCallback;
-  onPermissionRequestCallback;
-  setSessionUpdateHandler(handler) {
-    this.onSessionUpdateCallback = handler;
-  }
-  setPermissionRequestHandler(handler) {
-    this.onPermissionRequestCallback = handler;
-  }
-  sessionUpdate(params) {
-    if (this.onSessionUpdateCallback) {
-      this.onSessionUpdateCallback(params);
-    }
-    return Promise.resolve();
-  }
-  async requestPermission(params) {
-    if (this.onPermissionRequestCallback) {
-      return await this.onPermissionRequestCallback(params);
-    }
-    return {
-      outcome: {
-        outcome: "selected",
-        optionId: params.options[0]?.optionId || "allow"
-      }
-    };
-  }
-  writeTextFile(_params) {
-    throw new Error("File operations not implemented in language model client");
-  }
-  readTextFile(_params) {
-    throw new Error("File operations not implemented in language model client");
-  }
-};
-var ACPLanguageModel = class {
-  specificationVersion = "v2";
-  provider = "acp";
-  modelId;
-  modeId;
-  supportedUrls = {};
-  config;
-  agentProcess = null;
-  connection = null;
-  sessionId = null;
-  sessionResponse = null;
-  client = null;
-  currentModelId = null;
-  currentModeId = null;
-  isFreshSession = true;
-  // State for managing stream conversion
-  textBlockIndex = 0;
-  thinkBlockIndex = 0;
-  currentTextId = null;
-  currentThinkingId = null;
-  toolCallsMap = /* @__PURE__ */ new Map();
-  // Tool proxy for host-side tool execution
-  toolProxyHost = null;
-  // Client tool interrupt mechanism
-  clientToolAbort = null;
-  constructor(modelId, modeId, config) {
-    this.modelId = modelId;
-    this.modeId = modeId;
-    this.config = config;
-  }
-  /**
-   * Resets the internal state used for stream conversion.
-   */
-  resetStreamState() {
-    this.textBlockIndex = 0;
-    this.thinkBlockIndex = 0;
-    this.currentTextId = null;
-    this.currentThinkingId = null;
-    this.toolCallsMap.clear();
-    this.clientToolAbort = null;
-  }
-  /**
-   * Parses a 'tool_call' notification update into a structured object.
-   * Note: We only use rawInput for tool input (content is for UI display).
-   */
-  parseToolCall(update) {
-    if (update.sessionUpdate !== "tool_call") {
-      throw new Error("Invalid update type for parseToolCall");
-    }
-    const toolCallId = update.toolCallId;
-    const toolName = update.title || update.toolCallId;
-    const toolInput = update.rawInput ?? {};
-    return {
-      toolCallId,
-      toolName,
-      toolInput
-    };
-  }
-  /**
-   * Parses a 'tool_call_update' notification update into a structured object.
-   * Note: We only use rawOutput for tool result (content is for UI display).
-   */
-  parseToolResult(update) {
-    if (update.sessionUpdate !== "tool_call_update") {
-      throw new Error("Invalid update type for parseToolResult");
-    }
-    const toolCallId = update.toolCallId;
-    const toolName = update.title || update.toolCallId;
-    const toolResult = update.rawOutput ?? update.content ?? null;
-    const isError = update.status === "failed";
-    return {
-      toolCallId,
-      toolName,
-      toolResult,
-      isError,
-      status: update.status
-    };
-  }
-  /**
-   * Checks if a tool result is from a client-side tool (no execute function).
-   * Client tools return a special response with `isClientTool: true`.
-   * Handles both MCP format (type: "text") and ACP ToolCallContent format (type: "content").
-   */
-  isClientToolResult(toolResult) {
-    if (!Array.isArray(toolResult) || toolResult.length === 0) {
-      return {
-        isClientTool: false
-      };
-    }
-    const content = toolResult[0];
-    if (!content?.type) {
-      return {
-        isClientTool: false
-      };
-    }
-    const textContent = content.type === "text" && typeof content.text === "string" ? content.text : content.type === "content" && content.content?.type === "text" ? content.content.text : void 0;
-    if (!textContent) {
-      return {
-        isClientTool: false
-      };
-    }
-    try {
-      const parsed = JSON.parse(textContent);
-      if (parsed.isClientTool === true) {
-        return {
-          isClientTool: true,
-          toolName: parsed.toolName,
-          args: parsed.args
-        };
-      }
-    } catch {
-    }
-    return {
-      isClientTool: false
-    };
-  }
-  /**
-   * Converts AI SDK prompt messages into ACP ContentBlock objects.
-   * When session exists, only extracts the last user message (history is in session).
-   * Prefixes text with role since ACP ContentBlock has no role field.
-   */
-  /**
-  * Ensures the ACP agent process is running and a session is established.
-  * @param acpTools - Tools from streamText options to proxy
-  */
-  /**
-  * Connects to the ACP agent process and initializes the protocol connection.
-  * Does NOT start a session.
-  */
-  async connectClient() {
-    if (this.connection) {
-      return;
-    }
-    if (!this.agentProcess) {
-      const sessionCwd = this.config.session?.cwd || (typeof import_node_process8.default.cwd === "function" ? import_node_process8.default.cwd() : "/");
-      this.agentProcess = (0, import_node_child_process.spawn)(this.config.command, this.config.args ?? [], {
-        stdio: [
-          "pipe",
-          "pipe",
-          "inherit"
-        ],
-        env: {
-          ...import_node_process8.default.env,
-          ...this.config.env
-        },
-        cwd: sessionCwd
-      });
-      if (!this.agentProcess.stdout || !this.agentProcess.stdin) {
-        throw new Error("Failed to spawn agent process with stdio");
-      }
-      const input = import_node_stream2.Writable.toWeb(this.agentProcess.stdin);
-      const output = import_node_stream2.Readable.toWeb(this.agentProcess.stdout);
-      this.client = new ACPAISDKClient();
-      this.connection = new ClientSideConnection(() => this.client, ndJsonStream(input, output));
-    }
-    if (!this.connection) {
-      throw new Error("Connection not initialized");
-    }
-    const initConfig = {
-      ...this.config.initialize,
-      protocolVersion: this.config.initialize?.protocolVersion ?? PROTOCOL_VERSION,
-      clientCapabilities: this.config.initialize?.clientCapabilities ?? {
-        fs: {
-          readTextFile: false,
-          writeTextFile: false
-        },
-        terminal: false
-      }
-    };
-    const initResult = await this.connection.initialize(initConfig);
-    const validAuthMethods = initResult.authMethods?.find((a) => a.id === this.config.authMethodId)?.id;
-    if ((initResult.authMethods?.length ?? 0) > 0) {
-      if (!this.config.authMethodId || !validAuthMethods) {
-        console.log("[acp-ai-provider] Warning: No authMethodId specified in config, skipping authentication step. If this is not desired, please set one of the authMethodId in the ACPProviderSettings.", JSON.stringify(initResult.authMethods, null, 2));
-      }
-      if (this.config.authMethodId && validAuthMethods) {
-        await this.connection.authenticate({
-          methodId: this.config.authMethodId ?? initResult.authMethods?.[0].id
-        });
-      }
-    }
-  }
-  /**
-   * Starts a new session or updates the existing one.
-   * Assumes connectClient() has been called.
-   */
-  async startSession(acpTools2) {
-    if (!this.connection) {
-      throw new Error("Not connected");
-    }
-    const mcpServers = [
-      ...this.config.session?.mcpServers ?? []
-    ];
-    let toolsAdded = false;
-    if (acpTools2 && acpTools2.length > 0 && !this.toolProxyHost) {
-      console.log("[acp-ai-provider] Setting up tool proxy for client-side tools...", acpTools2.map((t) => t.name));
-      this.toolProxyHost = new ToolProxyHost("acp-ai-sdk-tools");
-      for (const t of acpTools2) {
-        this.toolProxyHost.registerTool(t.name, t);
-      }
-      toolsAdded = true;
-    }
-    if (this.toolProxyHost) {
-      const proxyConfig = await this.toolProxyHost.start();
-      mcpServers.push(proxyConfig);
-    }
-    if (this.sessionId && toolsAdded) {
-      this.sessionResponse = await this.connection.newSession({
-        ...this.config.session,
-        cwd: this.config.session?.cwd ?? import_node_process8.default.cwd(),
-        mcpServers
-      });
-      this.sessionId = this.sessionResponse.sessionId;
-      this.isFreshSession = true;
-      await this.applySessionDelay();
-      return;
-    }
-    if (this.sessionId) {
-      return;
-    }
-    if (this.config.existingSessionId) {
-      await this.connection.loadSession({
-        sessionId: this.config.existingSessionId,
-        cwd: this.config.session?.cwd ?? import_node_process8.default.cwd(),
-        mcpServers
-      });
-      this.sessionId = this.config.existingSessionId;
-      this.sessionResponse = {
-        sessionId: this.config.existingSessionId
-      };
-      this.isFreshSession = false;
-    } else {
-      this.sessionResponse = await this.connection.newSession({
-        ...this.config.session,
-        cwd: this.config.session?.cwd ?? import_node_process8.default.cwd(),
-        mcpServers
-      });
-      this.sessionId = this.sessionResponse.sessionId;
-      this.isFreshSession = true;
-    }
-    const { models, modes } = this.sessionResponse ?? {};
-    if (models?.currentModelId) {
-      this.currentModelId = models.currentModelId;
-    }
-    if (modes?.currentModeId) {
-      this.currentModeId = modes.currentModeId;
-    }
-    if (this.modelId && this.modelId !== this.currentModelId) {
-      await this.setModel(this.modelId);
-      this.currentModelId = this.modelId;
-    }
-    if (this.modeId && this.modeId !== this.currentModeId) {
-      await this.setMode(this.modeId);
-      this.currentModeId = this.modeId;
-    }
-    await this.applySessionDelay();
-  }
-  async applySessionDelay() {
-    if (this.config.sessionDelayMs) {
-      console.log(`[acp-ai-provider] Waiting ${this.config.sessionDelayMs}ms after session setup...`);
-      await new Promise((resolve3) => setTimeout(resolve3, this.config.sessionDelayMs));
-    }
-  }
-  /**
-   * Ensures the ACP agent process is running and a session is established.
-   * @param acpTools - Tools from streamText options to proxy
-   */
-  async ensureConnected(acpTools2) {
-    await this.connectClient();
-    await this.startSession(acpTools2);
-  }
-  /**
-   * Clears connection state. Skips if persistSession is enabled.
-   */
-  cleanup() {
-    if (this.config.persistSession) return;
-    this.forceCleanup();
-  }
-  /**
-   * Returns the current session ID.
-   */
-  getSessionId() {
-    return this.sessionId;
-  }
-  /**
-   * Initializes the session and returns session info (models, modes, meta).
-   * Call this before prompting to discover available options.
-   */
-  /**
-  * Initializes the session and returns session info (models, modes, meta).
-  * Call this before prompting to discover available options.
-  *
-  * @param acpTools - Optional list of tools to register during session initialization.
-  */
-  async initSession(tools) {
-    const acpTools2 = extractACPTools(tools, false);
-    await this.ensureConnected(acpTools2.length > 0 ? acpTools2 : void 0);
-    return this.sessionResponse;
-  }
-  /**
-   * Sets the session mode (e.g., "ask", "plan").
-   */
-  async setMode(modeId) {
-    if (!this.connection || !this.sessionId) {
-      throw new Error("Not connected. Call preconnect() first.");
-    }
-    const availableModes = this.sessionResponse?.modes?.availableModes;
-    if (availableModes) {
-      const foundMode = availableModes.find((m) => m.id === modeId);
-      if (!foundMode) {
-        const availableList = availableModes.map((m) => m.id).join(", ");
-        const currentInfo = this.sessionResponse?.modes?.currentModeId ? ` (Current: "${this.sessionResponse.modes.currentModeId}")` : "";
-        throw new Error(`Mode "${modeId}" is not available${currentInfo}. Available modes: ${availableList}`);
-      }
-    }
-    await this.connection.setSessionMode({
-      sessionId: this.sessionId,
-      modeId
-    });
-    this.currentModeId = modeId;
-  }
-  /**
-   * Sets the session model.
-   */
-  async setModel(modelId) {
-    if (!this.connection || !this.sessionId) {
-      throw new Error("Not connected. Call preconnect() first.");
-    }
-    const { models } = this.sessionResponse ?? {};
-    if (models?.availableModels) {
-      if (!models.availableModels.some((m) => m.modelId === modelId)) {
-        const availableList = models.availableModels.map((m) => m.modelId).join(", ");
-        const currentInfo = this.currentModelId ? ` (Current: "${this.currentModelId}")` : "";
-        throw new Error(`Model "${modelId}" is not available${currentInfo}. Available models: ${availableList}`);
-      }
-    }
-    await this.connection.setSessionModel({
-      sessionId: this.sessionId,
-      modelId
-    });
-    this.currentModelId = modelId;
-  }
-  /**
-   * Forces cleanup regardless of persistSession setting.
-   */
-  forceCleanup() {
-    if (this.toolProxyHost) {
-      this.toolProxyHost.stop();
-      this.toolProxyHost = null;
-    }
-    if (this.agentProcess) {
-      this.agentProcess.kill();
-      this.agentProcess.stdin?.end();
-      this.agentProcess.stdout?.destroy();
-      this.agentProcess = null;
-    }
-    this.connection = null;
-    this.sessionId = null;
-    this.sessionResponse = null;
-    this.client = null;
-  }
-  /**
-   * Emits raw content (plan, diffs, terminals) as raw stream parts.
-   * Plan data is emitted directly, while diffs and terminals are bound to a toolCallId.
-   */
-  emitRawContent(controller, data) {
-    if ("entries" in data) {
-      controller.enqueue({
-        type: "raw",
-        rawValue: JSON.stringify({
-          type: "plan",
-          entries: data.entries
-        })
-      });
-      return;
-    }
-    for (const item of data.content) {
-      if (item.type === "diff" || item.type === "terminal") {
-        controller.enqueue({
-          type: "raw",
-          rawValue: JSON.stringify({
-            ...item,
-            toolCallId: data.toolCallId
-          })
-        });
-      }
-    }
-  }
-  /**
-   * Flushes any pending tool calls that haven't emitted tool-call yet.
-   * This handles the case where a tool emits {} first, then the next message is a different type.
-   */
-  flushPendingToolCalls(controller) {
-    for (const [toolCallId, toolInfo] of this.toolCallsMap.entries()) {
-      if (!toolInfo.inputAvailable) {
-        toolInfo.inputAvailable = true;
-        controller.enqueue({
-          type: "tool-call",
-          toolCallId,
-          toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-          input: JSON.stringify({
-            toolCallId,
-            toolName: toolInfo.name,
-            args: {}
-          })
-        });
-      }
-    }
-  }
-  /**
-   * Standardized handler for converting SessionNotifications into
-   * LanguageModelV2StreamPart objects, pushing them onto a stream controller.
-   */
-  handleStreamNotification(controller, notification) {
-    const update = notification.update;
-    switch (update.sessionUpdate) {
-      case "plan":
-        this.flushPendingToolCalls(controller);
-        this.emitRawContent(controller, {
-          type: "plan",
-          entries: update.entries
-        });
-        break;
-      case "agent_thought_chunk":
-        this.flushPendingToolCalls(controller);
-        if (!this.currentThinkingId) {
-          this.currentThinkingId = `reasoning - ${this.thinkBlockIndex++} `;
-          controller.enqueue({
-            type: "reasoning-start",
-            id: this.currentThinkingId
-          });
-        }
-        controller.enqueue({
-          type: "reasoning-delta",
-          id: this.currentThinkingId,
-          delta: update.content.type === "text" ? update.content.text : ""
-        });
-        break;
-      case "agent_message_chunk":
-        this.flushPendingToolCalls(controller);
-        if (this.currentThinkingId) {
-          controller.enqueue({
-            type: "reasoning-end",
-            id: this.currentThinkingId
-          });
-          this.currentThinkingId = null;
-        }
-        if (update.content.type === "text") {
-          const textChunk = update.content.text;
-          if (!this.currentTextId) {
-            this.currentTextId = `text - ${this.textBlockIndex++} `;
-            controller.enqueue({
-              type: "text-start",
-              id: this.currentTextId
-            });
-          }
-          controller.enqueue({
-            type: "text-delta",
-            id: this.currentTextId,
-            delta: textChunk
-          });
-        }
-        break;
-      case "tool_call": {
-        if (this.currentTextId) {
-          controller.enqueue({
-            type: "text-end",
-            id: this.currentTextId
-          });
-          this.currentTextId = null;
-        }
-        if (this.currentThinkingId) {
-          controller.enqueue({
-            type: "reasoning-end",
-            id: this.currentThinkingId
-          });
-          this.currentThinkingId = null;
-        }
-        const { toolCallId, toolName, toolInput } = this.parseToolCall(update);
-        const existingToolCall = this.toolCallsMap.get(toolCallId);
-        const hasInput = toolInput && typeof toolInput === "object" && Object.keys(toolInput).length > 0;
-        if (!existingToolCall) {
-          this.toolCallsMap.set(toolCallId, {
-            index: this.toolCallsMap.size,
-            name: toolName,
-            inputStarted: true,
-            inputAvailable: !!hasInput
-          });
-          controller.enqueue({
-            type: "tool-input-start",
-            id: toolCallId,
-            toolName
-          });
-          if (hasInput) {
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId,
-              toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-              input: JSON.stringify({
-                toolCallId,
-                toolName,
-                args: toolInput
-              })
-            });
-          }
-        } else if (!existingToolCall.inputAvailable && hasInput) {
-          existingToolCall.inputAvailable = true;
-          if (update.title && existingToolCall.name !== update.title && update.title !== toolCallId) {
-            existingToolCall.name = update.title;
-          }
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId,
-            toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-            input: JSON.stringify({
-              toolCallId,
-              toolName: existingToolCall.name,
-              args: toolInput
-            })
-          });
-        }
-        break;
-      }
-      case "tool_call_update": {
-        const { toolCallId, toolName, toolResult, isError, status } = this.parseToolResult(update);
-        let toolInfo = this.toolCallsMap.get(toolCallId);
-        if (status === "in_progress") {
-          if (!toolInfo) {
-            toolInfo = {
-              index: this.toolCallsMap.size,
-              name: toolName,
-              inputStarted: true,
-              inputAvailable: true
-            };
-            this.toolCallsMap.set(toolCallId, toolInfo);
-            controller.enqueue({
-              type: "tool-input-start",
-              id: toolCallId,
-              toolName
-            });
-          }
-          if (!toolInfo.inputAvailable) {
-            toolInfo.inputAvailable = true;
-            if (update.title && toolInfo.name !== update.title && update.title !== toolCallId) {
-              toolInfo.name = update.title;
-            }
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId,
-              toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-              input: JSON.stringify({
-                toolCallId,
-                toolName: toolInfo.name,
-                args: {}
-              })
-            });
-          }
-          const content2 = update.content ?? [];
-          if (content2.length > 0) {
-            this.emitRawContent(controller, {
-              content: content2,
-              toolCallId
-            });
-          }
-          break;
-        }
-        if (![
-          "completed",
-          "failed"
-        ].includes(status)) {
-          break;
-        }
-        if (!toolInfo) {
-          toolInfo = {
-            index: this.toolCallsMap.size,
-            name: toolName,
-            inputAvailable: true
-          };
-          this.toolCallsMap.set(toolCallId, toolInfo);
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId,
-            toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-            input: JSON.stringify({
-              toolCallId,
-              toolName
-            })
-          });
-        } else if (!toolInfo.inputAvailable) {
-          toolInfo.inputAvailable = true;
-          if (update.title && toolInfo.name !== update.title && update.title !== toolCallId) {
-            toolInfo.name = update.title;
-          }
-          controller.enqueue({
-            type: "tool-call",
-            toolCallId,
-            toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-            input: JSON.stringify({
-              toolCallId,
-              toolName: toolInfo.name,
-              args: {}
-            })
-          });
-        }
-        const clientToolInfo = this.isClientToolResult(toolResult);
-        if (clientToolInfo.isClientTool) {
-          console.log(`[acp-ai-provider] Detected client tool: ${clientToolInfo.toolName}, stopping stream`);
-          const content2 = update.content ?? [];
-          if (content2.length > 0) {
-            this.emitRawContent(controller, {
-              content: content2,
-              toolCallId
-            });
-          }
-          if (this.clientToolAbort) {
-            controller.enqueue({
-              type: "finish",
-              finishReason: "tool-calls",
-              usage: {
-                inputTokens: void 0,
-                outputTokens: void 0,
-                totalTokens: void 0
-              }
+        } : void 0,
+        onStepFinish: (step) => {
+          if (span) {
+            span.addEvent("step", {
+              tools: step.toolCalls?.length ?? 0,
+              reason: step.finishReason ?? ""
             });
-            controller.close();
-            this.clientToolAbort.resolve();
-            this.cleanup();
-          }
-          break;
-        }
-        controller.enqueue({
-          type: "tool-result",
-          toolCallId,
-          toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
-          result: toolResult,
-          providerExecuted: true,
-          // https://github.com/vercel/ai/blob/282f062922cb59167dd3a11e3af67cfa0b75f317/packages/ai/src/generate-text/run-tools-transformation.ts#L316
-          ...isError && {
-            isError: true,
-            result: new Error(formatToolError(toolResult))
           }
-        });
-        const content = update.content ?? [];
-        if (content.length > 0) {
-          this.emitRawContent(controller, {
-            content,
-            toolCallId
-          });
         }
-        break;
-      }
-    }
-  }
-  /**
-   * Implements the non-streaming generation method.
-   */
-  async doGenerate(options) {
-    try {
-      await this.ensureConnected();
-      const promptContent = convertAiSdkMessagesToAcp(options, this.isFreshSession);
-      this.isFreshSession = false;
-      let accumulatedText = "";
-      const toolCalls = [];
-      const toolResults = /* @__PURE__ */ new Map();
-      const mockController = {
-        enqueue: (part) => {
-          switch (part.type) {
-            case "text-delta":
-              accumulatedText += part.delta;
-              break;
-            case "tool-call": {
-              const inputData = JSON.parse(part.input);
-              toolCalls.push({
-                id: part.toolCallId,
-                name: inputData.toolName,
-                input: inputData.args
-              });
-              break;
-            }
-            case "tool-result": {
-              const matchingToolCall = toolCalls.find((tc) => tc.id === part.toolCallId);
-              toolResults.set(part.toolCallId, {
-                name: matchingToolCall?.name || part.toolCallId,
-                result: part.result,
-                isError: part.isError
-              });
-              break;
-            }
-            // Other stream parts (reasoning, start/end blocks, etc.)
-            // are ignored in non-streaming mode
-            default:
-              break;
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: await result.text || `Completed in ${(await result.steps)?.length ?? "unknown"} step(s).`
           }
-        }
+        ],
+        isError: false
       };
-      const streamHandler = this.handleStreamNotification.bind(this);
-      this.resetStreamState();
-      if (this.client) {
-        this.client.setSessionUpdateHandler((notification) => {
-          streamHandler(mockController, notification);
-        });
-      }
-      const response = await this.connection.prompt({
-        sessionId: this.sessionId,
-        prompt: promptContent
+    } catch (error) {
+      this.logger.error({
+        message: "Execution error",
+        error
       });
-      const content = [];
-      if (accumulatedText.trim()) {
-        content.push({
-          type: "text",
-          text: accumulatedText
-        });
-      }
-      for (const toolCall of toolCalls) {
-        content.push({
-          type: "tool-call",
-          toolCallId: toolCall.id,
-          toolName: toolCall.name,
-          args: JSON.stringify(toolCall.input),
-          input: toolCall.input,
-          output: toolResults.get(toolCall.id)?.result
-        });
-      }
-      const result = {
-        content,
-        finishReason: response.stopReason === "end_turn" ? "stop" : "other",
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0,
-          totalTokens: 0
-        },
-        warnings: []
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
       };
-      this.cleanup();
-      return result;
-    } catch (error) {
-      this.cleanup();
-      throw error;
     }
   }
-  /**
-   * Implements the streaming generation method.
-   */
-  async doStream(options) {
-    const acpTools2 = extractACPTools(options.tools);
-    await this.ensureConnected(acpTools2.length > 0 ? acpTools2 : void 0);
-    const promptContent = convertAiSdkMessagesToAcp(options, this.isFreshSession);
-    this.isFreshSession = false;
-    const connection = this.connection;
-    const sessionId = this.sessionId;
-    const client = this.client;
-    const cleanup = () => this.cleanup();
-    const streamHandler = this.handleStreamNotification.bind(this);
-    const stream = new ReadableStream({
-      start: async (controller) => {
-        controller.enqueue({
-          type: "stream-start",
-          warnings: []
-        });
-        this.resetStreamState();
-        const clientToolPromise = new Promise((resolve3) => {
-          this.clientToolAbort = {
-            controller,
-            resolve: resolve3
-          };
-        });
-        try {
-          if (client) {
-            client.setSessionUpdateHandler((notification) => {
-              streamHandler(controller, notification);
-            });
-          }
-          const promptPromise = connection.prompt({
-            sessionId,
-            prompt: promptContent
-          });
-          const result = await Promise.race([
-            promptPromise.then((response2) => ({
-              type: "response",
-              response: response2
-            })),
-            clientToolPromise.then(() => ({
-              type: "client-tool"
-            }))
-          ]);
-          if (result.type === "client-tool") {
-            return;
-          }
-          const response = result.response;
-          controller.enqueue({
-            type: "finish",
-            finishReason: response.stopReason === "end_turn" ? "stop" : "other",
-            usage: {
-              inputTokens: 0,
-              outputTokens: 0,
-              totalTokens: 0
-            }
-          });
-          controller.close();
-          cleanup();
-        } catch (error) {
-          cleanup();
-          controller.enqueue({
-            type: "error",
-            error
-          });
-        }
-      },
-      cancel: () => {
-        cleanup();
-      }
+  buildSystemPrompt(args) {
+    return CompiledPrompts.aiLoopSystem({
+      toolName: this.config.name,
+      description: this.config.description,
+      rules: this.getRules(),
+      context: this.formatContext(args.context)
     });
-    return {
-      stream,
-      warnings: []
-    };
   }
-  get tools() {
-    return getACPDynamicTool();
+  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`;
+  }
+  formatContext(context2) {
+    if (!context2 || Object.keys(context2).length === 0) {
+      return "";
+    }
+    return `
+
+<context>
+${JSON.stringify(context2, null, 2)}
+</context>`;
+  }
+  convertToAISDKTool(name, toolDetail, execute) {
+    const cleanedSchema = toolDetail.inputSchema ? cleanToolSchema(toolDetail.inputSchema) : {
+      type: "object"
+    };
+    return (0, import_ai.tool)({
+      description: toolDetail.description || `Tool: ${name}`,
+      inputSchema: (0, import_ai.jsonSchema)(cleanedSchema),
+      execute
+    });
   }
 };
 
-// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/provider.js
-var ACPProvider = class {
-  config;
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-executor.js
+var AISamplingExecutor = class extends BaseAIExecutor {
+  server;
+  tools;
+  providerOptions;
+  maxTokens;
   model = null;
   constructor(config) {
-    this.config = config;
+    super(config, "callTool" in config.server ? config.server : void 0);
+    this.server = config.server;
+    this.tools = config.tools;
+    this.providerOptions = config.providerOptions;
+    this.maxTokens = config.maxTokens;
   }
-  /**
-   * Create a language model instance for a specific ACP agent
-   *
-   * @returns A LanguageModelV2 instance
-   */
-  languageModel(modelId, modeId) {
+  initProvider() {
     if (!this.model) {
-      this.model = new ACPLanguageModel(modelId, modeId, this.config);
-    }
-    if (modelId) {
-      this.model.modelId = modelId;
-    }
-    if (modeId) {
-      this.model.modeId = modeId;
+      const provider = new MCPSamplingProvider({
+        server: this.server,
+        maxTokens: this.maxTokens
+      });
+      this.model = provider.languageModel(this.providerOptions);
     }
     return this.model;
   }
-  /**
-   * Shorthand for creating a language model
-   */
-  call() {
-    return this.languageModel();
-  }
-  /**
-   * Provider tools - includes the agent dynamic tool
-   */
-  get tools() {
-    return this.model?.tools;
-  }
-  /**
-   * Returns the current session ID if one is active.
-   * Useful when `persistSession` is enabled and you need to reference the session later.
-   */
-  getSessionId() {
-    return this.model?.getSessionId() ?? null;
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
   }
-  /**
-   * Initializes the session and returns session info (models, modes, meta).
-   * Call this before prompting to discover available options.
-   */
-  initSession(tools) {
-    if (!this.model) {
-      this.languageModel();
-    }
-    return this.model.initSession(tools);
+  getExecutorType() {
+    return "mcp";
   }
-  /**
-   * Initializes the connection to the agent process without starting a session.
-   * Useful if you need to reduce the time to the first token.
-   */
-  connect() {
-    if (!this.model) {
-      this.languageModel();
+  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 this.model.connectClient();
+    return aiTools;
   }
-  /**
-   * Sets the session mode (e.g., "ask", "plan").
-   */
-  setMode(modeId) {
-    if (!this.model) {
-      throw new Error("No model initialized. Call languageModel() first.");
+  async callTool(name, input) {
+    if ("callTool" in this.server) {
+      return await this.server.callTool(name, input);
     }
-    return this.model.setMode(modeId);
+    const detail = this.tools.find(([n]) => n === name)?.[1];
+    if (detail?.execute) return await detail.execute(input);
+    throw new Error(`Cannot call tool "${name}"`);
   }
-  /**
-   * Sets the session model.
-   */
-  setModel(modelId) {
-    if (!this.model) {
-      throw new Error("No model initialized. Call languageModel() first.");
-    }
-    return this.model.setModel(modelId);
+  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);
   }
-  /**
-   * Forces cleanup of the connection and session.
-   * Call this when you're done with the provider instance, especially when using `persistSession`.
-   */
-  cleanup() {
-    this.model?.forceCleanup();
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
   }
 };
-function createACPProvider(config) {
-  return new ACPProvider(config);
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-sampling-registrar.js
+function registerAISamplingTool(server, params) {
+  const { name, description, allToolNames, depGroups, toolNameToDetailList, providerOptions, maxSteps = 50, tracingEnabled = false, maxTokens } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AISamplingExecutor({
+    name,
+    description,
+    server,
+    tools: toolNameToDetailList,
+    providerOptions,
+    maxSteps,
+    tracingEnabled,
+    maxTokens
+  });
+  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 validationResult = validateSchema(args, schema);
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: CompiledPrompts.errorResponse({
+              errorMessage: validationResult.error || "Validation failed"
+            })
+          }
+        ],
+        isError: true
+      };
+    }
+    const prompt = typeof args.prompt === "string" ? args.prompt : JSON.stringify(args);
+    return executor.execute({
+      prompt,
+      context: args.context
+    });
+  });
 }
 
+// __mcpc__cli_latest/node_modules/@jsr/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,
+      maxTokens: opts.maxTokens
+    });
+  }
+});
+var mode_ai_sampling_plugin_default = createAISamplingModePlugin();
+
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-executor.js
+var import_acp_ai_provider = require("@mcpc-tech/acp-ai-provider");
 var AIACPExecutor = class extends BaseAIExecutor {
   acpSettings;
   tools;
@@ -11615,7 +9066,7 @@ var AIACPExecutor = class extends BaseAIExecutor {
   }
   initProvider() {
     if (!this.model) {
-      this.provider = createACPProvider(this.acpSettings);
+      this.provider = (0, import_acp_ai_provider.createACPProvider)(this.acpSettings);
       this.model = this.provider.languageModel();
     }
     return this.model;
@@ -11627,12 +9078,6 @@ var AIACPExecutor = class extends BaseAIExecutor {
   getExecutorType() {
     return "acp";
   }
-  getToolListDescription() {
-    if (this.tools.length === 0) {
-      return "Tools will be provided by ACP agent";
-    }
-    return this.tools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
-  }
   buildTools() {
     const aiTools = {};
     for (const [name, detail] of this.tools) {
@@ -11642,7 +9087,7 @@ var AIACPExecutor = class extends BaseAIExecutor {
         return this.formatResult(result);
       });
     }
-    return acpTools(aiTools);
+    return (0, import_acp_ai_provider.acpTools)(aiTools);
   }
   formatResult(result) {
     const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
@@ -12027,13 +9472,13 @@ var PluginManager = class {
   /**
    * Apply transformTool hooks to a tool during composition
    */
-  async applyTransformToolHooks(tool3, context2) {
+  async applyTransformToolHooks(tool2, context2) {
     const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
     if (transformPlugins.length === 0) {
-      return tool3;
+      return tool2;
     }
     const sortedPlugins = sortPluginsByOrder(transformPlugins);
-    let currentTool = tool3;
+    let currentTool = tool2;
     for (const plugin of sortedPlugins) {
       if (plugin.transformTool) {
         try {
@@ -12145,7 +9590,7 @@ var ToolManager = class {
       description,
       schema
     });
-    if (options.internal) {
+    if (options.hidden) {
       this.toolConfigs.set(name, {
         visibility: {
           hidden: true
@@ -12165,6 +9610,11 @@ var ToolManager = class {
         inputSchema: schema
       });
     }
+    this.toolConfigs.set(name, {
+      visibility: {
+        public: true
+      }
+    });
   }
   /**
    * Check if a tool is public (exposed to MCP clients)
@@ -12281,12 +9731,12 @@ var ToolManager = class {
    * Get tool schema if it's hidden (for internal access)
    */
   getHiddenToolSchema(name) {
-    const tool3 = this.toolRegistry.get(name);
+    const tool2 = this.toolRegistry.get(name);
     const config = this.toolConfigs.get(name);
-    if (tool3 && config?.visibility?.hidden && tool3.schema) {
+    if (tool2 && config?.visibility?.hidden && tool2.schema) {
       return {
-        description: tool3.description,
-        schema: tool3.schema
+        description: tool2.description,
+        schema: tool2.schema
       };
     }
     return void 0;
@@ -12315,18 +9765,18 @@ var ToolManager = class {
    */
   getRegisteredToolsAsComposed() {
     const composedTools = {};
-    for (const [name, tool3] 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: tool3.description,
-        inputSchema: jsonSchema(tool3.schema || {
+        description: tool2.description,
+        inputSchema: jsonSchema(tool2.schema || {
           type: "object",
           properties: {}
         }),
-        execute: tool3.callback
+        execute: tool2.callback
       };
     }
     return composedTools;
@@ -12396,18 +9846,18 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
 function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
   const depGroups = {};
   const toolManager = server.toolManager;
-  toolNameToDetailList.forEach(([toolName, tool3]) => {
+  toolNameToDetailList.forEach(([toolName, tool2]) => {
     const resolvedName = toolManager.resolveToolName(toolName);
     if (hiddenToolNames.includes(resolvedName ?? "") || publicToolNames.includes(resolvedName ?? "")) {
       return;
     }
-    if (!tool3) {
+    if (!tool2) {
       const allToolNames = [
         ...toolNameToDetailList.map(([n]) => n)
       ];
       throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
     }
-    const baseSchema = tool3.inputSchema.jsonSchema ?? tool3.inputSchema ?? {
+    const baseSchema = tool2.inputSchema.jsonSchema ?? tool2.inputSchema ?? {
       type: "object",
       properties: {},
       required: []
@@ -12418,7 +9868,7 @@ function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicTool
     const sanitizedKey = sanitizePropertyKey(toolName);
     depGroups[sanitizedKey] = {
       type: "object",
-      description: tool3.description,
+      description: tool2.description,
       properties: updatedProperties,
       required: [
         ...baseRequired
@@ -12694,9 +10144,9 @@ var ComposableMCPServer = class extends Server {
     const requestedToolNames = /* @__PURE__ */ new Set();
     const availableToolNames = /* @__PURE__ */ new Set();
     const allPlaceholderUsages = [];
-    tagToResults.tool.forEach((tool3) => {
-      if (tool3.attribs.name) {
-        const originalName = tool3.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);
@@ -12714,24 +10164,24 @@ var ComposableMCPServer = class extends Server {
       if (!this.toolNameMapping.has(internalName)) {
         this.toolManager.setToolNameMapping(internalName, toolId);
       }
-      return tagToResults.tool.find((tool3) => {
-        const selectAll = tool3.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool3.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 tool3.attribs.name === toolNameWithScope || tool3.attribs.name === toolId;
+        return tool2.attribs.name === toolNameWithScope || tool2.attribs.name === toolId;
       });
     });
-    Object.entries(tools).forEach(([toolId, tool3]) => {
-      this.toolManager.registerTool(toolId, tool3.description || "", tool3.inputSchema, tool3.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, tool3]) => {
+    Object.entries(registeredTools).forEach(([toolName, tool2]) => {
       if (!allTools[toolName]) {
-        allTools[toolName] = tool3;
+        allTools[toolName] = tool2;
       }
       availableToolNames.add(toolName);
     });
@@ -12773,13 +10223,13 @@ var ComposableMCPServer = class extends Server {
     const toolNameToDetailList = Object.entries(allTools);
     const publicToolNames = this.getPublicToolNames();
     const hiddenToolNames = this.getHiddenToolNames();
-    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
+    const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n) && !publicToolNames.includes(n));
     publicToolNames.forEach((toolId) => {
-      const tool3 = allTools[toolId];
-      if (!tool3) {
-        throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
+      const tool2 = allTools[toolId];
+      if (!tool2) {
+        return;
       }
-      this.tool(toolId, tool3.description || "", jsonSchema(tool3.inputSchema), tool3.execute, {
+      this.tool(toolId, tool2.description || "", jsonSchema(tool2.inputSchema), tool2.execute, {
         internal: false
       });
     });
@@ -12832,12 +10282,12 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-var import_node_process9 = __toESM(require("node:process"), 1);
-var isSCF = () => Boolean(import_node_process9.default.env.SCF_RUNTIME || import_node_process9.default.env.PROD_SCF);
+var import_node_process8 = __toESM(require("node:process"), 1);
+var isSCF = () => Boolean(import_node_process8.default.env.SCF_RUNTIME || import_node_process8.default.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: import_node_process9.default.env.SCF_RUNTIME
+    SCF_RUNTIME: import_node_process8.default.env.SCF_RUNTIME
   });
 }
 
@@ -12886,15 +10336,13 @@ function createSearchPlugin(options = {}) {
   const timeoutMs = options.timeoutMs || 3e4;
   const global2 = options.global ?? true;
   const agentName = options.agentName;
-  const toolName = agentName ? `${agentName}__search-tool-result` : "search-tool-result";
+  const toolName = agentName ? `${agentName}__grep` : "mcpc__grep";
   const activeTimeouts = /* @__PURE__ */ new Set();
   return {
     name: "plugin-search",
     version: "1.0.0",
     configureServer: (server) => {
-      const defaultDescription = agentName ? `Search for text patterns in files for the "${agentName}" agent. Use this to find specific content within large tool results. Provide a simple literal string or a regular expression.
-Only search within the allowed directory: ${allowedSearchDir}` : `Search for text patterns in files and directories. Use this to find specific content, code, or information within files. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid; otherwise use quotes or escape special characters to treat it as a literal string.
-Only search within the allowed directory: ${allowedSearchDir}`;
+      const defaultDescription = agentName ? `Grep/search for text patterns within large tool result files for the "${agentName}" agent. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool searches within previously saved large results only. Provide a simple literal string or a regular expression. Only search within the allowed directory: ${allowedSearchDir}` : `Grep/search for text patterns within large tool result files. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool searches within previously saved large results only. Provide a simple literal string or a regular expression. If your pattern is a regex, ensure it's valid. Only search within the allowed directory: ${allowedSearchDir}`;
       const toolDescription = options.toolDescription || defaultDescription;
       server.tool(toolName, toolDescription, jsonSchema({
         type: "object",
@@ -13113,7 +10561,7 @@ function createLargeResultPlugin(options = {}) {
   let tempDir = options.tempDir || null;
   let serverRef = null;
   let agentName = null;
-  const defaultSearchDescription = `Search within large tool result files that were saved due to size limits. Use when: a tool result was saved to file because it exceeded the context limit. Do NOT use this tool before calling the actual tool first. Provide specific keywords or patterns related to the content you're looking for.`;
+  const defaultSearchDescription = `Grep/search within large tool result files that were saved due to size limits. **IMPORTANT**: You MUST execute the actual tool first and get a "Result too large, saved to file" response before using this grep tool. This tool is ONLY for searching within previously saved large results, not for general file search. Provide specific keywords or regex patterns related to the content you're looking for.`;
   return {
     name: "plugin-large-result-handler",
     version: "1.0.0",
@@ -13128,17 +10576,17 @@ function createLargeResultPlugin(options = {}) {
           maxResults: options.search?.maxResults || 15,
           maxOutputSize: options.search?.maxOutputSize || 4e3,
           toolDescription: options.search?.toolDescription || defaultSearchDescription,
-          global: true,
+          global: false,
           agentName
         };
         const searchPlugin = createSearchPlugin(searchConfig);
         await serverRef.addPlugin(searchPlugin);
       }
     },
-    transformTool: (tool3, context2) => {
-      const originalExecute = tool3.execute;
-      const searchToolName = agentName ? `${agentName}__search-tool-result` : "search-tool-result";
-      tool3.execute = async (args) => {
+    transformTool: (tool2, context2) => {
+      const originalExecute = tool2.execute;
+      const searchToolName = agentName ? `${agentName}__grep` : "mcpc__grep";
+      tool2.execute = async (args) => {
         try {
           const result = await originalExecute(args);
           const resultText = JSON.stringify(result);
@@ -13180,7 +10628,7 @@ ${preview}
           throw error;
         }
       };
-      return tool3;
+      return tool2;
     },
     dispose: () => {
       serverRef = null;