@mcpc-tech/cli 0.1.23 → 0.1.24

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 spawn2(command, args, options) {
+    function spawn3(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 = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -5161,17 +5161,17 @@ var Client = class extends Protocol {
     this._cachedToolOutputValidators.clear();
     this._cachedKnownTaskTools.clear();
     this._cachedRequiredTaskTools.clear();
-    for (const tool of tools) {
-      if (tool.outputSchema) {
-        const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
-        this._cachedToolOutputValidators.set(tool.name, toolValidator);
+    for (const tool3 of tools) {
+      if (tool3.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
+        this._cachedToolOutputValidators.set(tool3.name, toolValidator);
       }
-      const taskSupport = tool.execution?.taskSupport;
+      const taskSupport = tool3.execution?.taskSupport;
       if (taskSupport === "required" || taskSupport === "optional") {
-        this._cachedKnownTaskTools.add(tool.name);
+        this._cachedKnownTaskTools.add(tool3.name);
       }
       if (taskSupport === "required") {
-        this._cachedRequiredTaskTools.add(tool.name);
+        this._cachedRequiredTaskTools.add(tool3.name);
       }
     }
   }
@@ -7468,14 +7468,14 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
       acquiredKeys.push(defKey);
       allClients[serverId] = client;
       const { tools } = await client.listTools();
-      tools.forEach((tool) => {
-        const toolNameWithScope = `${name}.${tool.name}`;
-        const internalToolName = tool.name;
+      tools.forEach((tool3) => {
+        const toolNameWithScope = `${name}.${tool3.name}`;
+        const internalToolName = tool3.name;
         const rawToolId = `${serverId}_${internalToolName}`;
         const toolId = sanitizePropertyKey(rawToolId);
         if (filterIn && !filterIn({
           action: internalToolName,
-          tool,
+          tool: tool3,
           mcpName: name,
           toolNameWithScope,
           internalToolName,
@@ -7490,7 +7490,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
           timeout: def.toolCallTimeout
         });
         allTools[toolId] = {
-          ...tool,
+          ...tool3,
           execute,
           _originalName: toolNameWithScope
         };
@@ -7553,13 +7553,13 @@ var createConfigPlugin = () => ({
   name: "built-in-config",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool, context2) => {
+  transformTool: (tool3, context2) => {
     const server = context2.server;
     const config = server.findToolConfig?.(context2.toolName);
     if (config?.description) {
-      tool.description = config.description;
+      tool3.description = config.description;
     }
-    return tool;
+    return tool3;
   }
 });
 var config_plugin_default = createConfigPlugin();
@@ -7569,10 +7569,10 @@ var createToolNameMappingPlugin = () => ({
   name: "built-in-tool-name-mapping",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool, context2) => {
+  transformTool: (tool3, context2) => {
     const server = context2.server;
     const toolName = context2.toolName;
-    const originalName = tool._originalName || toolName;
+    const originalName = tool3._originalName || toolName;
     const dotNotation = originalName.replace(/_/g, ".");
     const underscoreNotation = originalName.replace(/\./g, "_");
     if (dotNotation !== originalName && server.toolNameMapping) {
@@ -7584,7 +7584,7 @@ var createToolNameMappingPlugin = () => ({
     if (originalName !== toolName && server.toolNameMapping) {
       server.toolNameMapping.set(originalName, toolName);
     }
-    return tool;
+    return tool3;
   }
 });
 var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
@@ -8077,13 +8077,13 @@ var PromptUtils = {
    * Generate tool list for descriptions
    */
   generateToolList: (tools) => {
-    return tools.filter((tool) => !tool.hide).map((tool) => `<tool name="${tool.name}"${tool.description ? ` description="${tool.description}"` : ""}/>`).join("\n");
+    return tools.filter((tool3) => !tool3.hide).map((tool3) => `<tool name="${tool3.name}"${tool3.description ? ` description="${tool3.description}"` : ""}/>`).join("\n");
   },
   /**
    * Generate hidden tool list for descriptions
    */
   generateHiddenToolList: (tools) => {
-    return tools.filter((tool) => tool.hide).map((tool) => `<tool name="${tool.name}" hide/>`).join("\n");
+    return tools.filter((tool3) => tool3.hide).map((tool3) => `<tool name="${tool3.name}" hide/>`).join("\n");
   },
   /**
    * Format workflow steps for display
@@ -9868,12 +9868,12 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
   }
   buildDepGroups() {
     const depGroups = {};
-    this.toolNameToDetailList.forEach(([toolName, tool]) => {
-      if (tool?.inputSchema) {
+    this.toolNameToDetailList.forEach(([toolName, tool3]) => {
+      if (tool3?.inputSchema) {
         depGroups[toolName] = {
           type: "object",
-          description: tool.description || `Tool: ${toolName}`,
-          ...tool.inputSchema
+          description: tool3.description || `Tool: ${toolName}`,
+          ...tool3.inputSchema
         };
       } else {
         const toolSchema = this.server.getHiddenToolSchema(toolName);
@@ -9930,10 +9930,10 @@ var SamplingExecutor = class extends BaseSamplingExecutor {
   }
   buildSystemPrompt(userRequest, agenticSchema, context2) {
     const toolList = this.allToolNames.map((name) => {
-      const tool = this.toolNameToDetailList.find(([toolName]) => toolName === name);
+      const tool3 = this.toolNameToDetailList.find(([toolName]) => toolName === name);
       const toolSchema = this.server.getHiddenToolSchema(name);
-      if (tool && tool[1]) {
-        return `- ${name}: ${tool[1].description || `Tool: ${name}`}`;
+      if (tool3 && tool3[1]) {
+        return `- ${name}: ${tool3[1].description || `Tool: ${name}`}`;
       } else if (toolSchema) {
         return `- ${name}: ${toolSchema.description}`;
       }
@@ -10140,6 +10140,3134 @@ var createWorkflowSamplingModePlugin = () => ({
 });
 var mode_workflow_sampling_plugin_default = createWorkflowSamplingModePlugin();
 
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/utils.js
+function convertAISDKToMCPMessages(prompt) {
+  const messages = [];
+  for (const msg of prompt) {
+    if (msg.role === "system") continue;
+    const role = msg.role === "assistant" ? "assistant" : "user";
+    const textParts = msg.content.filter((c) => c.type === "text");
+    const toolCalls = msg.content.filter((c) => c.type === "tool-call");
+    const toolResults = msg.content.filter((c) => c.type === "tool-result");
+    const parts = [];
+    if (textParts.length > 0) {
+      parts.push(textParts.map((c) => c.text).join("\n"));
+    }
+    if (toolCalls.length > 0) {
+      const calls = toolCalls.map((c) => {
+        const call = c;
+        return `<use_tool tool="${call.toolName}">
+${JSON.stringify(call.input || {})}
+</use_tool>`;
+      });
+      parts.push(calls.join("\n"));
+    }
+    if (toolResults.length > 0) {
+      const results = toolResults.map((c) => {
+        const result = c;
+        const output = JSON.stringify(result.output || result.result || "undefined");
+        return `Tool "${result.toolName}" result:
+${output}`;
+      });
+      parts.push(results.join("\n\n"));
+    }
+    const text = parts.join("\n\n");
+    if (text) {
+      messages.push({
+        role,
+        content: {
+          type: "text",
+          text
+        }
+      });
+    }
+  }
+  return messages;
+}
+function convertMCPStopReasonToAISDK(stopReason) {
+  if (stopReason === "endTurn" || stopReason === "stopSequence") {
+    return "stop";
+  }
+  if (stopReason === "maxTokens") return "length";
+  return stopReason ?? "unknown";
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/language-model.js
+var MCPSamplingLanguageModel = class {
+  specificationVersion = "v2";
+  provider;
+  modelId;
+  supportedUrls = {};
+  server;
+  modelPreferences;
+  constructor(config) {
+    this.server = config.server;
+    this.modelId = "";
+    this.provider = "mcp-client";
+    this.modelPreferences = config.modelPreferences;
+  }
+  /**
+   * Generate a response using MCP's createMessage capability
+   */
+  async doGenerate(options) {
+    const messages = this.convertMessages(options.prompt);
+    let systemPrompt;
+    for (const msg of options.prompt) {
+      if (msg.role === "system") {
+        systemPrompt = msg.content;
+        break;
+      }
+    }
+    const useNativeTools = this.supportsSamplingTools();
+    systemPrompt = this.injectResponseFormatInstructions(systemPrompt, options.responseFormat, useNativeTools);
+    systemPrompt = this.injectToolInstructions(systemPrompt, options.tools, useNativeTools);
+    const createMessageParams = {
+      systemPrompt,
+      messages,
+      maxTokens: options.maxOutputTokens ?? 55e3,
+      modelPreferences: this.modelPreferences
+    };
+    if (useNativeTools && options.tools && options.tools.length > 0) {
+      createMessageParams.tools = this.convertAISDKToolsToMCP(options.tools);
+      createMessageParams.toolChoice = {
+        mode: "auto"
+      };
+    }
+    const result = await this.server.createMessage(createMessageParams);
+    const content = [];
+    if (useNativeTools) {
+      const contentArray = Array.isArray(result.content) ? result.content : [
+        result.content
+      ];
+      for (const block of contentArray) {
+        if (block.type === "text" && "text" in block) {
+          content.push({
+            type: "text",
+            text: block.text
+          });
+        } else if (block.type === "tool_use" && "id" in block && "name" in block) {
+          const toolInput = block.input || {};
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: block.name,
+            input: JSON.stringify(toolInput)
+          });
+        }
+      }
+    } else {
+      if (result.content.type === "text" && result.content.text) {
+        const { text, toolCalls } = this.extractToolCalls(result.content.text, options.tools);
+        if (text.trim()) {
+          const textContent = {
+            type: "text",
+            text
+          };
+          content.push(textContent);
+        }
+        content.push(...toolCalls);
+      }
+    }
+    const finishReason = this.mapStopReason(result.stopReason);
+    return {
+      content,
+      finishReason,
+      usage: {
+        inputTokens: void 0,
+        outputTokens: void 0,
+        totalTokens: 0
+      },
+      request: {
+        body: JSON.stringify({
+          systemPrompt,
+          messages
+        })
+      },
+      response: {
+        modelId: result.model
+      },
+      warnings: []
+    };
+  }
+  /**
+   * Stream a response using MCP's createMessage capability
+   *
+   * Since MCP doesn't support native streaming, we generate the full response
+   * and emit it as stream events following AI SDK's protocol.
+   */
+  async doStream(options) {
+    const result = await this.doGenerate(options);
+    const stream = new ReadableStream({
+      start(controller) {
+        if (result.response?.modelId) {
+          controller.enqueue({
+            type: "response-metadata",
+            modelId: result.response.modelId,
+            ...result.response.headers && {
+              headers: result.response.headers
+            }
+          });
+        }
+        let textIndex = 0;
+        for (const part of result.content) {
+          if (part.type === "text") {
+            const id = `text-${++textIndex}`;
+            controller.enqueue({
+              type: "text-start",
+              id
+            });
+            controller.enqueue({
+              type: "text-delta",
+              id,
+              delta: part.text
+            });
+            controller.enqueue({
+              type: "text-end",
+              id
+            });
+          } else if (part.type === "tool-call") {
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: part.toolCallId,
+              toolName: part.toolName,
+              input: part.input
+            });
+          }
+        }
+        controller.enqueue({
+          type: "finish",
+          finishReason: result.finishReason,
+          usage: result.usage
+        });
+        controller.close();
+      }
+    });
+    return {
+      stream,
+      request: result.request,
+      warnings: result.warnings
+    };
+  }
+  /**
+   * Convert AI SDK messages to MCP sampling format
+   */
+  convertMessages(prompt) {
+    return convertAISDKToMCPMessages(prompt);
+  }
+  /**
+   * Map MCP stop reason to AI SDK finish reason
+   */
+  mapStopReason(stopReason) {
+    return convertMCPStopReasonToAISDK(stopReason);
+  }
+  /**
+   * Check if client supports native tool use in sampling
+   */
+  supportsSamplingTools() {
+    const capabilities = this.server.getClientCapabilities();
+    return !!capabilities?.sampling?.tools;
+  }
+  /**
+   * Convert AI SDK tools to MCP Tool format
+   */
+  convertAISDKToolsToMCP(tools) {
+    if (!tools || tools.length === 0) return [];
+    return tools.filter((tool3) => tool3.type === "function").map((tool3) => {
+      const toolAny = tool3;
+      return {
+        name: tool3.name,
+        description: toolAny.description || `Tool: ${tool3.name}`,
+        inputSchema: {
+          type: "object",
+          ...toolAny.inputSchema || toolAny.parameters
+        }
+      };
+    });
+  }
+  /**
+   * Inject response format instructions into system prompt
+   *
+   * Only injects formatting instructions in JSON fallback mode.
+   * In native tools mode, structured output is handled by the provider.
+   */
+  injectResponseFormatInstructions(systemPrompt, responseFormat, useNativeTools) {
+    if (!responseFormat) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      return systemPrompt;
+    }
+    let enhanced = systemPrompt || "";
+    if (responseFormat.type === "json") {
+      const jsonPrompt = `
+
+IMPORTANT: You MUST respond with valid JSON only. Do not include any text before or after the JSON.
+- Your response must be a valid JSON object
+- Do not wrap the JSON in markdown code blocks
+- Do not include explanations or comments
+- Ensure all JSON is properly formatted and parseable`;
+      enhanced = enhanced ? `${enhanced}${jsonPrompt}` : jsonPrompt.trim();
+      if (responseFormat.schema) {
+        const schemaInfo = `
+- Follow this JSON schema structure: ${JSON.stringify(responseFormat.schema)}`;
+        enhanced += schemaInfo;
+      }
+    }
+    return enhanced || void 0;
+  }
+  /**
+   * Inject tool definitions into system prompt
+   *
+   * WORKAROUND: MCP sampling currently doesn't support native tools parameter.
+   * This method injects tool descriptions and usage instructions into the system prompt.
+   *
+   * TODO: Remove this workaround when MCP protocol adds native support for:
+   * - tools parameter in createMessage
+   * - Tool calling and function execution
+   * - Structured tool responses
+   */
+  injectToolInstructions(systemPrompt, tools, useNativeTools) {
+    if (!tools || tools.length === 0) {
+      return systemPrompt;
+    }
+    if (useNativeTools) {
+      return systemPrompt;
+    }
+    let enhanced = systemPrompt || "";
+    const toolsPrompt = `
+
+AVAILABLE TOOLS:
+You have access to the following tools. To use a tool, respond with this XML format:
+<use_tool tool="tool_name">
+{"param1": "value1", "param2": "value2"}
+</use_tool>
+
+Follow the JSON schema definition for each tool's parameters.
+You can use multiple tools in one response. You can include text before tool calls, but do NOT include text after tool calls - wait for the tool results first.
+
+Tools:`;
+    const toolDescriptions = tools.map((tool3) => {
+      if (tool3.type === "function") {
+        const toolAny = tool3;
+        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") {
+        return `
+- ${tool3.name}: ${tool3.id || "No description provided"}`;
+      }
+      return "";
+    }).filter(Boolean).join("");
+    enhanced = enhanced ? `${enhanced}${toolsPrompt}${toolDescriptions}` : `${toolsPrompt}${toolDescriptions}`.trim();
+    return enhanced || void 0;
+  }
+  /**
+   * Extract tool calls from LLM response text
+   *
+   * Parses XML-style tool call tags from the response:
+   * <use_tool tool="tool_name">{"arg": "value"}</use_tool>
+   */
+  extractToolCalls(responseText, tools) {
+    if (!tools || tools.length === 0) {
+      return {
+        text: responseText,
+        toolCalls: []
+      };
+    }
+    const toolCalls = [];
+    const toolCallRegex = /<use_tool\s+tool="([^"]+)">([\s\S]*?)<\/use_tool>/g;
+    let match;
+    let lastIndex = 0;
+    const textParts = [];
+    let callIndex = 0;
+    while ((match = toolCallRegex.exec(responseText)) !== null) {
+      textParts.push(responseText.slice(lastIndex, match.index));
+      const toolName = match[1];
+      const argsText = match[2].trim?.();
+      toolCalls.push({
+        type: "tool-call",
+        toolCallId: `call_${Date.now()}_${callIndex++}`,
+        toolName,
+        input: argsText
+      });
+      lastIndex = match.index + match[0].length;
+    }
+    textParts.push(responseText.slice(lastIndex));
+    const text = textParts.join("").trim();
+    return {
+      text,
+      toolCalls
+    };
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__mcp-sampling-ai-provider/src/provider.js
+var MCPSamplingProvider = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a language model instance for a specific MCP tool/agent
+   *
+   * @param options - Optional configuration overrides
+   * @returns A LanguageModelV2 instance
+   */
+  languageModel(options) {
+    return new MCPSamplingLanguageModel({
+      server: this.config.server,
+      modelPreferences: options?.modelPreferences
+    });
+  }
+  /**
+   * Shorthand for creating a language model
+   */
+  call(options) {
+    return this.languageModel(options);
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/base-ai-executor.js
+var import_api2 = require("@opentelemetry/api");
+var import_ai = require("ai");
+var BaseAIExecutor = class {
+  config;
+  tracer;
+  logger;
+  constructor(config, server) {
+    this.config = {
+      maxSteps: 50,
+      tracingEnabled: true,
+      ...config
+    };
+    this.tracer = import_api2.trace.getTracer(`mcpc.ai.${config.name}`);
+    this.logger = createLogger(`mcpc.ai.${config.name}`, server);
+  }
+  execute(args) {
+    if (this.config.tracingEnabled) {
+      return this.executeWithTracing(args);
+    }
+    return this.executeCore(args);
+  }
+  executeWithTracing(args) {
+    return this.tracer.startActiveSpan(`mcpc.ai.${this.config.name}`, async (span) => {
+      try {
+        span.setAttributes({
+          "mcpc.executor": this.config.name,
+          "mcpc.type": this.getExecutorType()
+        });
+        const result = await this.executeCore(args, span);
+        span.setAttributes({
+          "mcpc.error": !!result.isError
+        });
+        return result;
+      } catch (error) {
+        span.recordException(error);
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  }
+  async executeCore(args, span) {
+    try {
+      const result = (0, import_ai.streamText)({
+        model: this.getModel(),
+        system: this.buildSystemPrompt(args),
+        messages: [
+          {
+            role: "user",
+            content: args.userRequest
+          }
+        ],
+        tools: this.buildTools(),
+        stopWhen: (0, import_ai.stepCountIs)(this.config.maxSteps),
+        experimental_telemetry: this.config.tracingEnabled ? {
+          isEnabled: true,
+          functionId: `mcpc.${this.config.name}`,
+          tracer: this.tracer
+        } : void 0,
+        onStepFinish: (step) => {
+          if (span) {
+            span.addEvent("step", {
+              tools: step.toolCalls?.length ?? 0,
+              reason: step.finishReason ?? ""
+            });
+          }
+        }
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: await result.text || `Completed in ${(await result.steps)?.length ?? "unknown"} step(s).`
+          }
+        ],
+        isError: false
+      };
+    } catch (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) {
+    return (0, import_ai.tool)({
+      description: toolDetail.description || `Tool: ${name}`,
+      inputSchema: (0, import_ai.jsonSchema)(toolDetail.inputSchema || {
+        type: "object"
+      }),
+      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 userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    return executor.execute({
+      userRequest,
+      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_process9 = __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) {
+          this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.INTERNAL_ERROR, `Tool has no execute function: ${params.name}`));
+          return;
+        }
+        const result = await tool3.execute?.(params.args, {
+          toolCallId: params.name,
+          messages: []
+        });
+        const 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 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);
+        if (execute) {
+          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;
+  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();
+  }
+  /**
+   * 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 isError2 = update.status === "failed";
+    return {
+      toolCallId,
+      toolName,
+      toolResult,
+      isError: isError2,
+      status: update.status
+    };
+  }
+  /**
+   * 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_process9.default.cwd === "function" ? import_node_process9.default.cwd() : "/");
+      this.agentProcess = (0, import_node_child_process.spawn)(this.config.command, this.config.args ?? [], {
+        stdio: [
+          "pipe",
+          "pipe",
+          "inherit"
+        ],
+        env: {
+          ...import_node_process9.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_process9.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_process9.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_process9.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
+          })
+        });
+      }
+    }
+  }
+  /**
+   * 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.emitRawContent(controller, {
+          type: "plan",
+          entries: update.entries
+        });
+        break;
+      case "agent_thought_chunk":
+        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":
+        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: isError2, 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: {}
+            })
+          });
+        }
+        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
+          ...isError2 && {
+            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;
+          }
+        }
+      };
+      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
+      });
+      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: []
+      };
+      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();
+        try {
+          if (client) {
+            client.setSessionUpdateHandler((notification) => {
+              streamHandler(controller, notification);
+            });
+          }
+          const response = await connection.prompt({
+            sessionId,
+            prompt: promptContent
+          });
+          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();
+      }
+    });
+    return {
+      stream,
+      warnings: []
+    };
+  }
+  get tools() {
+    return getACPDynamicTool();
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__acp-ai-provider/src/provider.js
+var ACPProvider = class {
+  config;
+  model = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a language model instance for a specific ACP agent
+   *
+   * @returns A LanguageModelV2 instance
+   */
+  languageModel(modelId, modeId) {
+    if (!this.model) {
+      this.model = new ACPLanguageModel(modelId, modeId, this.config);
+    }
+    if (modelId) {
+      this.model.modelId = modelId;
+    }
+    if (modeId) {
+      this.model.modeId = modeId;
+    }
+    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;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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();
+    }
+    return this.model.connectClient();
+  }
+  /**
+   * Sets the session mode (e.g., "ask", "plan").
+   */
+  setMode(modeId) {
+    if (!this.model) {
+      throw new Error("No model initialized. Call languageModel() first.");
+    }
+    return this.model.setMode(modeId);
+  }
+  /**
+   * Sets the session model.
+   */
+  setModel(modelId) {
+    if (!this.model) {
+      throw new Error("No model initialized. Call languageModel() first.");
+    }
+    return this.model.setModel(modelId);
+  }
+  /**
+   * 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();
+  }
+};
+function createACPProvider(config) {
+  return new ACPProvider(config);
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-executor.js
+var AIACPExecutor = class extends BaseAIExecutor {
+  acpSettings;
+  clientTools;
+  provider = null;
+  model = null;
+  constructor(config) {
+    super(config);
+    this.acpSettings = config.acpSettings;
+    this.clientTools = config.clientTools ?? [];
+  }
+  initProvider() {
+    if (!this.model) {
+      this.provider = createACPProvider(this.acpSettings);
+      this.model = this.provider.languageModel();
+    }
+    return this.model;
+  }
+  getModel() {
+    if (!this.model) throw new Error("Model not initialized");
+    return this.model;
+  }
+  getExecutorType() {
+    return "acp";
+  }
+  getToolListDescription() {
+    if (this.clientTools.length === 0) {
+      return "Tools will be provided by AI SDK";
+    }
+    return this.clientTools.map(([name, detail]) => `- ${name}: ${detail.description || "No description"}`).join("\n");
+  }
+  buildTools() {
+    const aiTools = {};
+    for (const [name, detail] of this.clientTools) {
+      if (!detail.execute) continue;
+      aiTools[name] = this.convertToAISDKTool(name, detail, async (input) => {
+        const result = await detail.execute(input);
+        return this.formatResult(result);
+      });
+    }
+    return aiTools;
+  }
+  formatResult(result) {
+    const texts = result.content?.filter((c) => c.type === "text").map((c) => c.text);
+    return texts?.length ? texts.join("\n") : JSON.stringify(result.content);
+  }
+  execute(args) {
+    this.initProvider();
+    return super.execute(args);
+  }
+  cleanup() {
+    if (this.provider && typeof this.provider.cleanup === "function") {
+      this.provider.cleanup();
+    }
+    this.model = null;
+    this.provider = null;
+  }
+};
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/ai/ai-acp-registrar.js
+function registerAIACPTool(server, params) {
+  const { name, description, allToolNames, depGroups, acpSettings, clientTools = [], maxSteps = 50, tracingEnabled = false } = params;
+  const createArgsDef = createArgsDefFactory(name, allToolNames, depGroups, void 0, void 0);
+  const executor = new AIACPExecutor({
+    name,
+    description,
+    acpSettings,
+    clientTools,
+    maxSteps,
+    tracingEnabled
+  });
+  const toolDescription = CompiledPrompts.samplingToolDescription({
+    toolName: name,
+    description,
+    toolList: allToolNames.length > 0 ? allToolNames.map((n) => `- ${n}`).join("\n") : "Agent has its own tools"
+  });
+  const argsDef = createArgsDef.forSampling();
+  const schema = allToolNames.length > 0 ? argsDef : {
+    type: "object",
+    properties: {}
+  };
+  server.tool(name, toolDescription, jsonSchema(createModelCompatibleJSONSchema(schema)), (args) => {
+    const userRequest = typeof args.userRequest === "string" ? args.userRequest : JSON.stringify(args);
+    return executor.execute({
+      userRequest,
+      context: args.context
+    });
+  });
+  return executor;
+}
+
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/mode-ai-acp-plugin.js
+var createAIACPModePlugin = () => ({
+  name: "mode-ai-acp",
+  version: "1.0.0",
+  apply: "ai_acp",
+  registerAgentTool: (context2) => {
+    const opts = context2.options;
+    if (!opts.acpSettings) {
+      throw new Error("ai_acp mode requires acpSettings in options");
+    }
+    registerAIACPTool(context2.server, {
+      description: context2.description,
+      name: context2.name,
+      allToolNames: context2.allToolNames,
+      depGroups: context2.depGroups,
+      acpSettings: opts.acpSettings,
+      clientTools: opts.clientTools,
+      maxSteps: opts.maxSteps,
+      tracingEnabled: opts.tracingEnabled
+    });
+  }
+});
+var mode_ai_acp_plugin_default = createAIACPModePlugin();
+
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/built-in/index.js
 function getBuiltInPlugins() {
   return [
@@ -10149,6 +13277,8 @@ function getBuiltInPlugins() {
     mode_workflow_plugin_default,
     mode_agentic_sampling_plugin_default,
     mode_workflow_sampling_plugin_default,
+    mode_ai_sampling_plugin_default,
+    mode_ai_acp_plugin_default,
     logging_plugin_default
   ];
 }
@@ -10437,13 +13567,13 @@ var PluginManager = class {
   /**
    * Apply transformTool hooks to a tool during composition
    */
-  async applyTransformToolHooks(tool, context2) {
+  async applyTransformToolHooks(tool3, context2) {
     const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
     if (transformPlugins.length === 0) {
-      return tool;
+      return tool3;
     }
     const sortedPlugins = sortPluginsByOrder(transformPlugins);
-    let currentTool = tool;
+    let currentTool = tool3;
     for (const plugin of sortedPlugins) {
       if (plugin.transformTool) {
         try {
@@ -10691,12 +13821,12 @@ var ToolManager = class {
    * Get tool schema if it's hidden (for internal access)
    */
   getHiddenToolSchema(name) {
-    const tool = this.toolRegistry.get(name);
+    const tool3 = this.toolRegistry.get(name);
     const config = this.toolConfigs.get(name);
-    if (tool && config?.visibility?.hidden && tool.schema) {
+    if (tool3 && config?.visibility?.hidden && tool3.schema) {
       return {
-        description: tool.description,
-        schema: tool.schema
+        description: tool3.description,
+        schema: tool3.schema
       };
     }
     return void 0;
@@ -10725,18 +13855,18 @@ var ToolManager = class {
    */
   getRegisteredToolsAsComposed() {
     const composedTools = {};
-    for (const [name, tool] of this.toolRegistry.entries()) {
+    for (const [name, tool3] of this.toolRegistry.entries()) {
       if (this.toolConfigs.get(name)?.visibility?.public === true) {
         continue;
       }
       composedTools[name] = {
         name,
-        description: tool.description,
-        inputSchema: jsonSchema(tool.schema || {
+        description: tool3.description,
+        inputSchema: jsonSchema(tool3.schema || {
           type: "object",
           properties: {}
         }),
-        execute: tool.callback
+        execute: tool3.callback
       };
     }
     return composedTools;
@@ -10806,18 +13936,18 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
 function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
   const depGroups = {};
   const toolManager = server.toolManager;
-  toolNameToDetailList.forEach(([toolName, tool]) => {
+  toolNameToDetailList.forEach(([toolName, tool3]) => {
     const resolvedName = toolManager.resolveToolName(toolName);
     if (hiddenToolNames.includes(resolvedName ?? "") || publicToolNames.includes(resolvedName ?? "")) {
       return;
     }
-    if (!tool) {
+    if (!tool3) {
       const allToolNames = [
         ...toolNameToDetailList.map(([n]) => n)
       ];
       throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
     }
-    const baseSchema = tool.inputSchema.jsonSchema ?? tool.inputSchema ?? {
+    const baseSchema = tool3.inputSchema.jsonSchema ?? tool3.inputSchema ?? {
       type: "object",
       properties: {},
       required: []
@@ -10828,7 +13958,7 @@ function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicTool
     const sanitizedKey = sanitizePropertyKey(toolName);
     depGroups[sanitizedKey] = {
       type: "object",
-      description: tool.description,
+      description: tool3.description,
       properties: updatedProperties,
       required: [
         ...baseRequired
@@ -11104,9 +14234,9 @@ var ComposableMCPServer = class extends Server {
     const requestedToolNames = /* @__PURE__ */ new Set();
     const availableToolNames = /* @__PURE__ */ new Set();
     const allPlaceholderUsages = [];
-    tagToResults.tool.forEach((tool) => {
-      if (tool.attribs.name) {
-        const originalName = tool.attribs.name;
+    tagToResults.tool.forEach((tool3) => {
+      if (tool3.attribs.name) {
+        const originalName = tool3.attribs.name;
         const toolName = sanitizePropertyKey(originalName);
         if (toolName.endsWith(`_${ALL_TOOLS_PLACEHOLDER2}`) || toolName === ALL_TOOLS_PLACEHOLDER2) {
           allPlaceholderUsages.push(originalName);
@@ -11132,24 +14262,24 @@ var ComposableMCPServer = class extends Server {
         }
         return true;
       }
-      return tagToResults.tool.find((tool) => {
-        const selectAll = tool.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool.attribs.name === `${mcpName}`;
+      return tagToResults.tool.find((tool3) => {
+        const selectAll = tool3.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool3.attribs.name === `${mcpName}`;
         if (selectAll) {
           return true;
         }
-        return tool.attribs.name === toolNameWithScope || tool.attribs.name === toolId;
+        return tool3.attribs.name === toolNameWithScope || tool3.attribs.name === toolId;
       });
     });
-    Object.entries(tools).forEach(([toolId, tool]) => {
-      this.toolManager.registerTool(toolId, tool.description || "", tool.inputSchema, tool.execute);
+    Object.entries(tools).forEach(([toolId, tool3]) => {
+      this.toolManager.registerTool(toolId, tool3.description || "", tool3.inputSchema, tool3.execute);
     });
     const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
     const allTools = {
       ...tools
     };
-    Object.entries(registeredTools).forEach(([toolName, tool]) => {
+    Object.entries(registeredTools).forEach(([toolName, tool3]) => {
       if (!allTools[toolName]) {
-        allTools[toolName] = tool;
+        allTools[toolName] = tool3;
       }
       availableToolNames.add(toolName);
     });
@@ -11193,11 +14323,11 @@ var ComposableMCPServer = class extends Server {
     const hiddenToolNames = this.getHiddenToolNames();
     const contextToolNames = toolNameToDetailList.map(([name2]) => name2).filter((n) => !hiddenToolNames.includes(n));
     publicToolNames.forEach((toolId) => {
-      const tool = allTools[toolId];
-      if (!tool) {
+      const tool3 = allTools[toolId];
+      if (!tool3) {
         throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
       }
-      this.tool(toolId, tool.description || "", jsonSchema(tool.inputSchema), tool.execute, {
+      this.tool(toolId, tool3.description || "", jsonSchema(tool3.inputSchema), tool3.execute, {
         internal: false
       });
     });
@@ -11250,12 +14380,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_process10 = __toESM(require("node:process"), 1);
+var isSCF = () => Boolean(import_node_process10.default.env.SCF_RUNTIME || import_node_process10.default.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: import_node_process9.default.env.SCF_RUNTIME
+    SCF_RUNTIME: import_node_process10.default.env.SCF_RUNTIME
   });
 }
 
@@ -11545,9 +14675,9 @@ function createLargeResultPlugin(options = {}) {
         configuredServers.set(server, true);
       }
     },
-    transformTool: (tool, context2) => {
-      const originalExecute = tool.execute;
-      tool.execute = async (args) => {
+    transformTool: (tool3, context2) => {
+      const originalExecute = tool3.execute;
+      tool3.execute = async (args) => {
         try {
           const result = await originalExecute(args);
           const resultText = JSON.stringify(result);
@@ -11589,7 +14719,7 @@ ${preview}
           throw error;
         }
       };
-      return tool;
+      return tool3;
     },
     dispose: () => {
       configuredServers.clear();