@mcpc-tech/cli 0.1.24 → 0.1.25

package/bin/mcpc.cjs

@@ -502,7 +502,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
-    function spawn3(command, args, options) {
+    function spawn2(command, args, options) {
       const parsed = parse(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -514,8 +514,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn3;
-    module2.exports.spawn = spawn3;
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
@@ -5161,17 +5161,17 @@ var Client = class extends Protocol {
     this._cachedToolOutputValidators.clear();
     this._cachedKnownTaskTools.clear();
     this._cachedRequiredTaskTools.clear();
-    for (const tool3 of tools) {
-      if (tool3.outputSchema) {
-        const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
-        this._cachedToolOutputValidators.set(tool3.name, toolValidator);
+    for (const tool2 of tools) {
+      if (tool2.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool2.outputSchema);
+        this._cachedToolOutputValidators.set(tool2.name, toolValidator);
       }
-      const taskSupport = tool3.execution?.taskSupport;
+      const taskSupport = tool2.execution?.taskSupport;
       if (taskSupport === "required" || taskSupport === "optional") {
-        this._cachedKnownTaskTools.add(tool3.name);
+        this._cachedKnownTaskTools.add(tool2.name);
       }
       if (taskSupport === "required") {
-        this._cachedRequiredTaskTools.add(tool3.name);
+        this._cachedRequiredTaskTools.add(tool2.name);
       }
     }
   }
@@ -7468,14 +7468,14 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
       acquiredKeys.push(defKey);
       allClients[serverId] = client;
       const { tools } = await client.listTools();
-      tools.forEach((tool3) => {
-        const toolNameWithScope = `${name}.${tool3.name}`;
-        const internalToolName = tool3.name;
+      tools.forEach((tool2) => {
+        const toolNameWithScope = `${name}.${tool2.name}`;
+        const internalToolName = tool2.name;
         const rawToolId = `${serverId}_${internalToolName}`;
         const toolId = sanitizePropertyKey(rawToolId);
         if (filterIn && !filterIn({
           action: internalToolName,
-          tool: tool3,
+          tool: tool2,
           mcpName: name,
           toolNameWithScope,
           internalToolName,
@@ -7490,7 +7490,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
           timeout: def.toolCallTimeout
         });
         allTools[toolId] = {
-          ...tool3,
+          ...tool2,
           execute,
           _originalName: toolNameWithScope
         };
@@ -7553,13 +7553,13 @@ var createConfigPlugin = () => ({
   name: "built-in-config",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool3, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const config = server.findToolConfig?.(context2.toolName);
     if (config?.description) {
-      tool3.description = config.description;
+      tool2.description = config.description;
     }
-    return tool3;
+    return tool2;
   }
 });
 var config_plugin_default = createConfigPlugin();
@@ -7569,10 +7569,10 @@ var createToolNameMappingPlugin = () => ({
   name: "built-in-tool-name-mapping",
   version: "1.0.0",
   enforce: "pre",
-  transformTool: (tool3, context2) => {
+  transformTool: (tool2, context2) => {
     const server = context2.server;
     const toolName = context2.toolName;
-    const originalName = tool3._originalName || toolName;
+    const originalName = tool2._originalName || toolName;
     const dotNotation = originalName.replace(/_/g, ".");
     const underscoreNotation = originalName.replace(/\./g, "_");
     if (dotNotation !== originalName && server.toolNameMapping) {
@@ -7584,7 +7584,7 @@ var createToolNameMappingPlugin = () => ({
     if (originalName !== toolName && server.toolNameMapping) {
       server.toolNameMapping.set(originalName, toolName);
     }
-    return tool3;
+    return tool2;
   }
 });
 var tool_name_mapping_plugin_default = createToolNameMappingPlugin();
@@ -8077,13 +8077,13 @@ var PromptUtils = {
    * Generate tool list for descriptions
    */
   generateToolList: (tools) => {
-    return tools.filter((tool3) => !tool3.hide).map((tool3) => `<tool name="${tool3.name}"${tool3.description ? ` description="${tool3.description}"` : ""}/>`).join("\n");
+    return tools.filter((tool2) => !tool2.hide).map((tool2) => `<tool name="${tool2.name}"${tool2.description ? ` description="${tool2.description}"` : ""}/>`).join("\n");
   },
   /**
    * Generate hidden tool list for descriptions
    */
   generateHiddenToolList: (tools) => {
-    return tools.filter((tool3) => tool3.hide).map((tool3) => `<tool name="${tool3.name}" hide/>`).join("\n");
+    return tools.filter((tool2) => tool2.hide).map((tool2) => `<tool name="${tool2.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, tool3]) => {
-      if (tool3?.inputSchema) {
+    this.toolNameToDetailList.forEach(([toolName, tool2]) => {
+      if (tool2?.inputSchema) {
         depGroups[toolName] = {
           type: "object",
-          description: tool3.description || `Tool: ${toolName}`,
-          ...tool3.inputSchema
+          description: tool2.description || `Tool: ${toolName}`,
+          ...tool2.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 tool3 = this.toolNameToDetailList.find(([toolName]) => toolName === name);
+      const tool2 = this.toolNameToDetailList.find(([toolName]) => toolName === name);
       const toolSchema = this.server.getHiddenToolSchema(name);
-      if (tool3 && tool3[1]) {
-        return `- ${name}: ${tool3[1].description || `Tool: ${name}`}`;
+      if (tool2 && tool2[1]) {
+        return `- ${name}: ${tool2[1].description || `Tool: ${name}`}`;
       } else if (toolSchema) {
         return `- ${name}: ${toolSchema.description}`;
       }
@@ -9960,7 +9960,7 @@ ${JSON.stringify(context2, null, 2)}`;
 ## Current Task
 You will now use agentic sampling to complete the following task: "${userRequest}"${contextInfo}
 
-When you need to use a tool, specify the tool name in 'action' and provide tool-specific parameters as additional properties.`;
+When you need to use a tool, specify the tool name in 'useTool' and provide tool-specific parameters as additional properties.`;
     return this.formatPromptForMode({
       prompt: basePrompt + taskPrompt,
       schema: agenticSchema
@@ -10156,8 +10156,9 @@ function convertAISDKToMCPMessages(prompt) {
     if (toolCalls.length > 0) {
       const calls = toolCalls.map((c) => {
         const call = c;
+        const toolArgs = call.args ?? call.input ?? {};
         return `<use_tool tool="${call.toolName}">
-${JSON.stringify(call.input || {})}
+${JSON.stringify(toolArgs)}
 </use_tool>`;
       });
       parts.push(calls.join("\n"));
@@ -10165,7 +10166,8 @@ ${JSON.stringify(call.input || {})}
     if (toolResults.length > 0) {
       const results = toolResults.map((c) => {
         const result = c;
-        const output = JSON.stringify(result.output || result.result || "undefined");
+        const resultValue = result.result ?? result.output ?? "undefined";
+        const output = JSON.stringify(resultValue);
         return `Tool "${result.toolName}" result:
 ${output}`;
       });
@@ -10372,11 +10374,11 @@ var MCPSamplingLanguageModel = class {
    */
   convertAISDKToolsToMCP(tools) {
     if (!tools || tools.length === 0) return [];
-    return tools.filter((tool3) => tool3.type === "function").map((tool3) => {
-      const toolAny = tool3;
+    return tools.filter((tool2) => tool2.type === "function").map((tool2) => {
+      const toolAny = tool2;
       return {
-        name: tool3.name,
-        description: toolAny.description || `Tool: ${tool3.name}`,
+        name: tool2.name,
+        description: toolAny.description || `Tool: ${tool2.name}`,
         inputSchema: {
           type: "object",
           ...toolAny.inputSchema || toolAny.parameters
@@ -10446,18 +10448,18 @@ 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 toolDescriptions = tools.map((tool2) => {
+      if (tool2.type === "function") {
+        const toolAny = tool2;
         const description = toolAny.description || "No description provided";
         const schema = toolAny.inputSchema || toolAny.parameters;
         const params = schema ? `
   JSON Schema: ${JSON.stringify(schema, null, 2)}` : "";
         return `
-- ${tool3.name}: ${description}${params}`;
-      } else if (tool3.type === "provider-defined") {
+- ${tool2.name}: ${description}${params}`;
+      } else if (tool2.type === "provider-defined") {
         return `
-- ${tool3.name}: ${tool3.id || "No description provided"}`;
+- ${tool2.name}: ${tool2.id || "No description provided"}`;
       }
       return "";
     }).filter(Boolean).join("");
@@ -10779,2381 +10781,8 @@ var createAISamplingModePlugin = () => ({
 });
 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 import_acp_ai_provider = require("@mcpc-tech/acp-ai-provider");
 var AIACPExecutor = class extends BaseAIExecutor {
   acpSettings;
   clientTools;
@@ -13166,7 +10795,7 @@ var AIACPExecutor = class extends BaseAIExecutor {
   }
   initProvider() {
     if (!this.model) {
-      this.provider = createACPProvider(this.acpSettings);
+      this.provider = (0, import_acp_ai_provider.createACPProvider)(this.acpSettings);
       this.model = this.provider.languageModel();
     }
     return this.model;
@@ -13567,13 +11196,13 @@ var PluginManager = class {
   /**
    * Apply transformTool hooks to a tool during composition
    */
-  async applyTransformToolHooks(tool3, context2) {
+  async applyTransformToolHooks(tool2, context2) {
     const transformPlugins = this.plugins.filter((p2) => p2.transformTool && shouldApplyPlugin(p2, context2.mode));
     if (transformPlugins.length === 0) {
-      return tool3;
+      return tool2;
     }
     const sortedPlugins = sortPluginsByOrder(transformPlugins);
-    let currentTool = tool3;
+    let currentTool = tool2;
     for (const plugin of sortedPlugins) {
       if (plugin.transformTool) {
         try {
@@ -13821,12 +11450,12 @@ var ToolManager = class {
    * Get tool schema if it's hidden (for internal access)
    */
   getHiddenToolSchema(name) {
-    const tool3 = this.toolRegistry.get(name);
+    const tool2 = this.toolRegistry.get(name);
     const config = this.toolConfigs.get(name);
-    if (tool3 && config?.visibility?.hidden && tool3.schema) {
+    if (tool2 && config?.visibility?.hidden && tool2.schema) {
       return {
-        description: tool3.description,
-        schema: tool3.schema
+        description: tool2.description,
+        schema: tool2.schema
       };
     }
     return void 0;
@@ -13855,18 +11484,18 @@ var ToolManager = class {
    */
   getRegisteredToolsAsComposed() {
     const composedTools = {};
-    for (const [name, tool3] of this.toolRegistry.entries()) {
+    for (const [name, tool2] of this.toolRegistry.entries()) {
       if (this.toolConfigs.get(name)?.visibility?.public === true) {
         continue;
       }
       composedTools[name] = {
         name,
-        description: tool3.description,
-        inputSchema: jsonSchema(tool3.schema || {
+        description: tool2.description,
+        inputSchema: jsonSchema(tool2.schema || {
           type: "object",
           properties: {}
         }),
-        execute: tool3.callback
+        execute: tool2.callback
       };
     }
     return composedTools;
@@ -13936,18 +11565,18 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
 function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
   const depGroups = {};
   const toolManager = server.toolManager;
-  toolNameToDetailList.forEach(([toolName, tool3]) => {
+  toolNameToDetailList.forEach(([toolName, tool2]) => {
     const resolvedName = toolManager.resolveToolName(toolName);
     if (hiddenToolNames.includes(resolvedName ?? "") || publicToolNames.includes(resolvedName ?? "")) {
       return;
     }
-    if (!tool3) {
+    if (!tool2) {
       const allToolNames = [
         ...toolNameToDetailList.map(([n]) => n)
       ];
       throw new Error(`Action ${toolName} not found, available action list: ${allToolNames.join(", ")}`);
     }
-    const baseSchema = tool3.inputSchema.jsonSchema ?? tool3.inputSchema ?? {
+    const baseSchema = tool2.inputSchema.jsonSchema ?? tool2.inputSchema ?? {
       type: "object",
       properties: {},
       required: []
@@ -13958,7 +11587,7 @@ function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicTool
     const sanitizedKey = sanitizePropertyKey(toolName);
     depGroups[sanitizedKey] = {
       type: "object",
-      description: tool3.description,
+      description: tool2.description,
       properties: updatedProperties,
       required: [
         ...baseRequired
@@ -14234,9 +11863,9 @@ var ComposableMCPServer = class extends Server {
     const requestedToolNames = /* @__PURE__ */ new Set();
     const availableToolNames = /* @__PURE__ */ new Set();
     const allPlaceholderUsages = [];
-    tagToResults.tool.forEach((tool3) => {
-      if (tool3.attribs.name) {
-        const originalName = tool3.attribs.name;
+    tagToResults.tool.forEach((tool2) => {
+      if (tool2.attribs.name) {
+        const originalName = tool2.attribs.name;
         const toolName = sanitizePropertyKey(originalName);
         if (toolName.endsWith(`_${ALL_TOOLS_PLACEHOLDER2}`) || toolName === ALL_TOOLS_PLACEHOLDER2) {
           allPlaceholderUsages.push(originalName);
@@ -14262,24 +11891,24 @@ var ComposableMCPServer = class extends Server {
         }
         return true;
       }
-      return tagToResults.tool.find((tool3) => {
-        const selectAll = tool3.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool3.attribs.name === `${mcpName}`;
+      return tagToResults.tool.find((tool2) => {
+        const selectAll = tool2.attribs.name === `${mcpName}.${ALL_TOOLS_PLACEHOLDER2}` || tool2.attribs.name === `${mcpName}`;
         if (selectAll) {
           return true;
         }
-        return tool3.attribs.name === toolNameWithScope || tool3.attribs.name === toolId;
+        return tool2.attribs.name === toolNameWithScope || tool2.attribs.name === toolId;
       });
     });
-    Object.entries(tools).forEach(([toolId, tool3]) => {
-      this.toolManager.registerTool(toolId, tool3.description || "", tool3.inputSchema, tool3.execute);
+    Object.entries(tools).forEach(([toolId, tool2]) => {
+      this.toolManager.registerTool(toolId, tool2.description || "", tool2.inputSchema, tool2.execute);
     });
     const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
     const allTools = {
       ...tools
     };
-    Object.entries(registeredTools).forEach(([toolName, tool3]) => {
+    Object.entries(registeredTools).forEach(([toolName, tool2]) => {
       if (!allTools[toolName]) {
-        allTools[toolName] = tool3;
+        allTools[toolName] = tool2;
       }
       availableToolNames.add(toolName);
     });
@@ -14323,11 +11952,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 tool3 = allTools[toolId];
-      if (!tool3) {
+      const tool2 = allTools[toolId];
+      if (!tool2) {
         throw new Error(`Public tool ${toolId} not found in registry, available: ${Object.keys(allTools).join(", ")}`);
       }
-      this.tool(toolId, tool3.description || "", jsonSchema(tool3.inputSchema), tool3.execute, {
+      this.tool(toolId, tool2.description || "", jsonSchema(tool2.inputSchema), tool2.execute, {
         internal: false
       });
     });
@@ -14380,12 +12009,12 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-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);
+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);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: import_node_process10.default.env.SCF_RUNTIME
+    SCF_RUNTIME: import_node_process9.default.env.SCF_RUNTIME
   });
 }
 
@@ -14675,9 +12304,9 @@ function createLargeResultPlugin(options = {}) {
         configuredServers.set(server, true);
       }
     },
-    transformTool: (tool3, context2) => {
-      const originalExecute = tool3.execute;
-      tool3.execute = async (args) => {
+    transformTool: (tool2, context2) => {
+      const originalExecute = tool2.execute;
+      tool2.execute = async (args) => {
         try {
           const result = await originalExecute(args);
           const resultText = JSON.stringify(result);
@@ -14719,7 +12348,7 @@ ${preview}
           throw error;
         }
       };
-      return tool3;
+      return tool2;
     },
     dispose: () => {
       configuredServers.clear();