@axhub/acp 0.1.0

package/dist/lib/acp2aisdk/vendor/acp-ai-provider/package/index.mjs

@@ -0,0 +1,1945 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/language-model.js
+import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+import { Readable, Writable } from "node:stream";
+import z from "zod";
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/format-tool-error.js
+function normalizeToolResultBlocks(toolResult) {
+  // rawOutput can be an object when ACP agents report failed MCP tool calls.
+  if (!toolResult) return [];
+  if (Array.isArray(toolResult)) return toolResult;
+  if (typeof toolResult === "string") {
+    return [
+      {
+        type: "content",
+        content: {
+          type: "text",
+          text: toolResult
+        }
+      }
+    ];
+  }
+  const content = typeof toolResult === "object" ? toolResult.content : null;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (item?.type === "content") return item;
+      if (item?.type === "text") {
+        return {
+          type: "content",
+          content: {
+            type: "text",
+            text: String(item.text ?? "")
+          }
+        };
+      }
+      return {
+        type: "content",
+        content: {
+          type: "text",
+          text: JSON.stringify(item)
+        }
+      };
+    });
+  }
+  return [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: JSON.stringify(toolResult)
+      }
+    }
+  ];
+}
+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__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/tool-proxy/tool-proxy-host.js
+import { createServer } from "node:net";
+
+// __mcpc__acp-ai-provider_latest/node_modules/@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 serializeMessage(message) {
+  return JSON.stringify(message);
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@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__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/tool-proxy/tool-proxy-host.js
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// __mcpc__acp-ai-provider_latest/node_modules/@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__acp-ai-provider_latest/node_modules/@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, tool2) {
+    this.tools.set(name, tool2);
+  }
+  /**
+   * Register multiple tools at once
+   */
+  registerTools(tools) {
+    for (const [name, tool2] of Object.entries(tools)) {
+      this.registerTool(name, tool2);
+    }
+  }
+  /**
+   * Get tool definitions for the runtime
+   */
+  getToolDefinitions() {
+    const definitions = [];
+    for (const [name, tool2] of this.tools.entries()) {
+      definitions.push({
+        name,
+        description: tool2.description || `Tool: ${name}`,
+        // inputSchema from Tool can be Zod or JSON schema, cast to JSON schema format
+        inputSchema: tool2.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((resolve, reject) => {
+      this.server = 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;
+          resolve();
+        } 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 tool2 = this.tools.get(params.name);
+        if (!tool2) {
+          this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Tool not found: ${params.name}`));
+          return;
+        }
+        if (!tool2.execute) {
+          const clientToolResult = {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  isClientTool: true,
+                  toolName: params.name,
+                  args: params.args
+                })
+              }
+            ],
+            isError: false
+          };
+          this.sendResponse(socket, createResponse(request.id, clientToolResult));
+          return;
+        }
+        const result = await tool2.execute(params.args, {
+          toolCallId: params.name,
+          messages: []
+        });
+        let toolResult;
+        const parseResult = CallToolResultSchema.safeParse(result);
+        if (parseResult.success) {
+          toolResult = parseResult.data;
+        } else {
+          toolResult = {
+            content: [
+              {
+                type: "text",
+                text: typeof result === "string" ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        }
+        this.sendResponse(socket, createResponse(request.id, toolResult));
+      } else if (request.method === "getTools") {
+        const definitions = this.getToolDefinitions();
+        this.sendResponse(socket, createResponse(request.id, definitions));
+      } else {
+        this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.METHOD_NOT_FOUND, `Unknown method: ${request.method}`));
+      }
+    } catch (error) {
+      this.sendResponse(socket, createErrorResponse(request.id, JsonRpcErrorCode.INTERNAL_ERROR, error instanceof Error ? error.message : String(error)));
+    }
+  }
+  /**
+   * Send response to runtime
+   */
+  sendResponse(socket, response) {
+    socket.write(serializeMessage(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__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/acp-tool.js
+import { jsonSchema, tool } from "ai";
+var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME = "acp.acp_provider_agent_dynamic_tool";
+var executeRegistry = /* @__PURE__ */ new Map();
+function acpTools(tools) {
+  for (const [name, toolDef] of Object.entries(tools)) {
+    executeRegistry.set(name, toolDef.execute);
+  }
+  return {
+    ...tools,
+    ...getACPDynamicTool()
+  };
+}
+function getACPDynamicTool() {
+  return {
+    [ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME]: tool({
+      type: "provider",
+      id: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+      args: {},
+      inputSchema: jsonSchema({})
+    })
+  };
+}
+function getExecuteByName(name) {
+  return executeRegistry.get(name);
+}
+function hasRegisteredExecute(name) {
+  return executeRegistry.has(name);
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/convert-utils.js
+import { convertUint8ArrayToBase64 } from "@ai-sdk/provider-utils";
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/utils.js
+function extractBase64Data(data) {
+  return data.includes(",") ? data.split(",")[1] : data;
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/convert-utils.js
+import { asSchema } from "ai";
+var ROLE_PREFIXES = {
+  system: "System: ",
+  assistant: "Assistant: ",
+  tool: "Result: "
+};
+function getRolePrefix(role) {
+  return ROLE_PREFIXES[role] || "";
+}
+function getMediaType(mimeType) {
+  if (mimeType.startsWith("image/")) return "image";
+  if (mimeType.startsWith("audio/")) return "audio";
+  return null;
+}
+function convertAiSdkMessagesToAcp(options, isFreshSession, jsonSchemaPrompt) {
+  const messages = !isFreshSession ? options.prompt.filter((m) => m.role === "user").slice(-1) : options.prompt;
+  const contentBlocks = [];
+  if (jsonSchemaPrompt) {
+    contentBlocks.push({
+      type: "text",
+      text: jsonSchemaPrompt
+    });
+  }
+  for (const msg of messages) {
+    const prefix = getRolePrefix(msg.role);
+    if (typeof msg.content === "string") {
+      contentBlocks.push({
+        type: "text",
+        text: `${prefix}${msg.content} `
+      });
+      continue;
+    }
+    if (!Array.isArray(msg.content)) continue;
+    let needsPrefix = true;
+    for (const part of msg.content) {
+      const currentPrefix = needsPrefix ? prefix : "";
+      if (part.type === "text") {
+        contentBlocks.push({
+          type: "text",
+          text: currentPrefix + part.text
+        });
+        needsPrefix = false;
+      }
+      if (part.type === "tool-call") {
+        const toolCallText = `[Tool Call: ${part.toolName}(${JSON.stringify(part.input)})]`;
+        contentBlocks.push({
+          type: "text",
+          text: currentPrefix + toolCallText
+        });
+        needsPrefix = false;
+      }
+      if (part.type === "tool-result") {
+        const resultData = part.result ?? part.output;
+        const resultText = JSON.stringify(resultData) ?? "null";
+        contentBlocks.push({
+          type: "text",
+          text: currentPrefix + resultText
+        });
+        needsPrefix = false;
+      }
+      if (part.type === "file") {
+        const mediaType = getMediaType(part.mediaType);
+        if (mediaType) {
+          let base64Data;
+          if (typeof part.data === "string") {
+            base64Data = extractBase64Data(part.data);
+          } else if (part.data instanceof Uint8Array) {
+            base64Data = convertUint8ArrayToBase64(part.data);
+          }
+          if (base64Data !== void 0) {
+            contentBlocks.push({
+              type: mediaType,
+              mimeType: part.mediaType,
+              data: base64Data
+            });
+          }
+        }
+      }
+    }
+  }
+  return contentBlocks;
+}
+function extractACPTools(tools, prepared = true) {
+  const acpTools2 = [];
+  if (!tools) {
+    return acpTools2;
+  }
+  const toolsArray = Array.isArray(tools) ? tools : Object.entries(tools).map(([name, tool2]) => ({
+    type: "function",
+    name,
+    ...tool2
+  }));
+  for (const t of toolsArray) {
+    if (t.type === "function") {
+      const toolWithSchema = t;
+      const toolInputSchema = toolWithSchema.inputSchema;
+      if (hasRegisteredExecute(t.name) && toolInputSchema) {
+        const execute = getExecuteByName(t.name);
+        acpTools2.push({
+          ...t,
+          name: t.name,
+          inputSchema: prepared ? toolInputSchema : asSchema(toolInputSchema).jsonSchema,
+          execute
+        });
+      }
+    }
+  }
+  return acpTools2;
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/lazy-auth.js
+var ACP_AUTH_REQUIRED_ERROR_CODE = -32e3;
+var ACP_AUTH_REQUIRED_MESSAGE = "authentication required";
+function isAuthRequiredError(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    if (code === ACP_AUTH_REQUIRED_ERROR_CODE) {
+      return true;
+    }
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    const message = String(error.message ?? "");
+    return message.toLowerCase().includes(ACP_AUTH_REQUIRED_MESSAGE);
+  }
+  return false;
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/debug.js
+import { appendFileSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+var ACPDebugLogger = class {
+  agentMessageLogFilePath = null;
+  isEnabled() {
+    const value = process.env.ACP_AI_PROVIDER_DEBUG;
+    return value === "1" || value === "true";
+  }
+  log(...args) {
+    if (!this.isEnabled()) {
+      return;
+    }
+    console.log(...args);
+  }
+  ensureAgentMessageLogFile() {
+    if (this.agentMessageLogFilePath || !this.isEnabled()) {
+      return;
+    }
+    const debugDir = mkdtempSync(join(tmpdir(), "acp-ai-provider-"));
+    this.agentMessageLogFilePath = join(debugDir, "agent-messages.ndjson");
+    this.log(`[acp-ai-provider] Agent message log: ${this.agentMessageLogFilePath}`);
+  }
+  appendAgentMessage(notification) {
+    this.appendLogEntry({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "notification",
+      notification
+    });
+  }
+  appendPromptResponse(response) {
+    this.appendLogEntry({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "prompt-response",
+      response
+    });
+  }
+  appendPromptError(error) {
+    this.appendLogEntry({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      kind: "prompt-error",
+      error: this.serializeError(error)
+    });
+  }
+  appendLogEntry(entry) {
+    this.ensureAgentMessageLogFile();
+    if (!this.agentMessageLogFilePath) {
+      return;
+    }
+    try {
+      appendFileSync(this.agentMessageLogFilePath, `${JSON.stringify(entry)}
+`);
+    } catch {
+    }
+  }
+  serializeError(error) {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+        ...typeof error.code !== "undefined" ? {
+          code: error.code
+        } : {},
+        ...typeof error.data !== "undefined" ? {
+          data: error.data
+        } : {}
+      };
+    }
+    return error;
+  }
+};
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/json-output.js
+var OPENING_FENCE_PATTERN = /^```(?:\w+)?\s*\n/;
+var CLOSING_FENCE_PATTERN = /\n?```\s*$/;
+var SUFFIX_BUFFER_SIZE = 12;
+function isJsonResponseFormat(responseFormat) {
+  return responseFormat?.type === "json";
+}
+function buildJsonSchemaPrompt(responseFormat) {
+  const parts = [];
+  parts.push("[Structured Output Instruction]", "You MUST respond with a single valid JSON value.", "Do NOT wrap JSON in markdown fences (no ```json blocks).", "Do NOT add explanations, comments, or any other text before or after the JSON.", "Your entire response must be ONLY the JSON value, nothing else.");
+  if (responseFormat.name) {
+    parts.push(`Output name: ${responseFormat.name}`);
+  }
+  if (responseFormat.description) {
+    parts.push(`Output description: ${responseFormat.description}`);
+  }
+  if (responseFormat.schema) {
+    parts.push("The JSON value MUST conform to this JSON Schema:", JSON.stringify(responseFormat.schema, null, 2));
+  }
+  parts.push("[End Structured Output Instruction]");
+  return parts.join("\n");
+}
+function stripMarkdownFences(text) {
+  const trimmed = text.trim();
+  const fenceMatch = trimmed.match(/^```(?:\w+)?\s*\n?([\s\S]*?)\n?\s*```\s*$/);
+  if (fenceMatch) {
+    return fenceMatch[1].trim();
+  }
+  return trimmed;
+}
+function emitTextDelta(controller, id, delta) {
+  if (!delta) {
+    return;
+  }
+  controller.enqueue({
+    type: "text-delta",
+    id,
+    delta
+  });
+}
+function finalizeBufferedText(block) {
+  if (block.prefixStripped) {
+    return block.buffer.replace(CLOSING_FENCE_PATTERN, "").trimEnd();
+  }
+  return stripMarkdownFences(block.buffer);
+}
+function createJsonCleanupTransform() {
+  const textBlocks = {};
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (chunk.type === "text-start") {
+        textBlocks[chunk.id] = {
+          startEvent: chunk,
+          phase: "prefix",
+          buffer: "",
+          prefixStripped: false
+        };
+        return;
+      }
+      if (chunk.type === "text-delta") {
+        const block = textBlocks[chunk.id];
+        if (!block) {
+          controller.enqueue(chunk);
+          return;
+        }
+        block.buffer += chunk.delta;
+        if (block.phase === "prefix") {
+          if (block.buffer.length > 0 && !block.buffer.startsWith("`")) {
+            block.phase = "streaming";
+            controller.enqueue(block.startEvent);
+          } else if (block.buffer.startsWith("```")) {
+            if (block.buffer.includes("\n")) {
+              const prefixMatch = block.buffer.match(OPENING_FENCE_PATTERN);
+              block.phase = "streaming";
+              if (prefixMatch) {
+                block.buffer = block.buffer.slice(prefixMatch[0].length);
+                block.prefixStripped = true;
+              }
+              controller.enqueue(block.startEvent);
+            }
+          } else if (block.buffer.length >= 3 && !block.buffer.startsWith("```")) {
+            block.phase = "streaming";
+            controller.enqueue(block.startEvent);
+          }
+        }
+        if (block.phase === "streaming" && block.buffer.length > SUFFIX_BUFFER_SIZE) {
+          const toStream = block.buffer.slice(0, -SUFFIX_BUFFER_SIZE);
+          block.buffer = block.buffer.slice(-SUFFIX_BUFFER_SIZE);
+          emitTextDelta(controller, chunk.id, toStream);
+        }
+        return;
+      }
+      if (chunk.type === "text-end") {
+        const block = textBlocks[chunk.id];
+        if (!block) {
+          controller.enqueue(chunk);
+          return;
+        }
+        if (block.phase === "prefix") {
+          controller.enqueue(block.startEvent);
+        }
+        emitTextDelta(controller, chunk.id, finalizeBufferedText(block));
+        controller.enqueue(chunk);
+        delete textBlocks[chunk.id];
+        return;
+      }
+      controller.enqueue(chunk);
+    },
+    flush(controller) {
+      for (const [id, block] of Object.entries(textBlocks)) {
+        if (block.phase === "prefix") {
+          controller.enqueue(block.startEvent);
+        }
+        emitTextDelta(controller, id, finalizeBufferedText(block));
+      }
+    }
+  });
+}
+
+// __mcpc__acp-ai-provider_latest/node_modules/@mcpc/acp-ai-provider/src/language-model.js
+function getACPResponse(response) {
+  return {
+    acp: JSON.parse(JSON.stringify(response))
+  };
+}
+function mapACPStopReasonToAISDK(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "max_tokens":
+    case "max_turn_requests":
+      return "length";
+    case "cancelled":
+      return "other";
+    default:
+      return "other";
+  }
+}
+function toCatchableError(error, stderrText) {
+  if (error !== null && typeof error === "object" && "code" in error && "message" in error && typeof error.code === "number" && typeof error.message === "string") {
+    const jsonRpcError = error;
+    const err2 = new Error(jsonRpcError.message);
+    err2.name = "ACPError";
+    err2.code = jsonRpcError.code;
+    err2.data = jsonRpcError.data;
+    if (stderrText) {
+      err2.message = `${err2.message}
+[agent stderr]
+${stderrText}`;
+    }
+    return err2;
+  }
+  if (error instanceof Error) {
+    if (stderrText) {
+      error.message = `${error.message}
+[agent stderr]
+${stderrText}`;
+    }
+    return error;
+  }
+  const err = new Error(String(error));
+  if (stderrText) {
+    err.message = `${err.message}
+[agent stderr]
+${stderrText}`;
+  }
+  return err;
+}
+var ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2 = "acp.acp_provider_agent_dynamic_tool";
+var providerAgentDynamicToolSchema = z.object({
+  toolCallId: z.string().describe("The unique ID of the tool call."),
+  toolName: z.string().describe("The name of the tool being called."),
+  args: z.record(z.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 = "v3";
+  provider = "acp";
+  modelId;
+  modeId;
+  supportedUrls = {};
+  config;
+  agentProcess = null;
+  connection = null;
+  sessionId = null;
+  sessionResponse = null;
+  client = null;
+  currentModelId = null;
+  currentModeId = null;
+  isFreshSession = true;
+  // Captured stderr output from the agent process.
+  stderrChunks = [];
+  // State for managing stream conversion
+  textBlockIndex = 0;
+  thinkBlockIndex = 0;
+  currentTextId = null;
+  currentThinkingId = null;
+  toolCallsMap = /* @__PURE__ */ new Map();
+  // Tool proxy for host-side tool execution
+  toolProxyHost = null;
+  // Client tool interrupt mechanism
+  clientToolAbort = null;
+  debug = new ACPDebugLogger();
+  availableAuthMethodIds = [];
+  constructor(modelId, modeId, config) {
+    this.modelId = modelId;
+    this.modeId = modeId;
+    this.config = config;
+    this.debug.ensureAgentMessageLogFile();
+  }
+  /**
+   * Resets the internal state used for stream conversion.
+   */
+  resetStreamState() {
+    this.textBlockIndex = 0;
+    this.thinkBlockIndex = 0;
+    this.currentTextId = null;
+    this.currentThinkingId = null;
+    this.toolCallsMap.clear();
+    this.clientToolAbort = null;
+  }
+  hasToolInput(input) {
+    if (input === null || input === void 0) {
+      return false;
+    }
+    if (typeof input === "object") {
+      return Object.keys(input).length > 0;
+    }
+    if (typeof input === "string") {
+      return input.length > 0;
+    }
+    return true;
+  }
+  normalizeToolInput(input) {
+    return input ?? {};
+  }
+  /**
+   * 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 here (content is for UI display).
+   * rawInput is handled in handleStreamNotification when emitting tool-call args.
+   */
+  parseToolResult(update) {
+    if (update.sessionUpdate !== "tool_call_update") {
+      throw new Error("Invalid update type for parseToolResult");
+    }
+    const toolCallId = update.toolCallId;
+    const toolName = update.title || update.toolCallId;
+    const toolResult = update.rawOutput ?? update.content ?? null;
+    const isError = update.status === "failed";
+    return {
+      toolCallId,
+      toolName,
+      toolResult,
+      isError,
+      status: update.status
+    };
+  }
+  /**
+   * Checks if a tool result is from a client-side tool (no execute function).
+   * Client tools return a special response with `isClientTool: true`.
+   * Handles both MCP format (type: "text") and ACP ToolCallContent format (type: "content").
+   */
+  isClientToolResult(toolResult) {
+    if (!Array.isArray(toolResult) || toolResult.length === 0) {
+      return {
+        isClientTool: false
+      };
+    }
+    const content = toolResult[0];
+    if (!content?.type) {
+      return {
+        isClientTool: false
+      };
+    }
+    const textContent = content.type === "text" && typeof content.text === "string" ? content.text : content.type === "content" && content.content?.type === "text" ? content.content.text : void 0;
+    if (!textContent) {
+      return {
+        isClientTool: false
+      };
+    }
+    try {
+      const parsed = JSON.parse(textContent);
+      if (parsed.isClientTool === true) {
+        return {
+          isClientTool: true,
+          toolName: parsed.toolName,
+          args: parsed.args
+        };
+      }
+    } catch {
+    }
+    return {
+      isClientTool: false
+    };
+  }
+  /**
+   * Converts AI SDK prompt messages into ACP ContentBlock objects.
+   * When session exists, only extracts the last user message (history is in session).
+   * Prefixes text with role since ACP ContentBlock has no role field.
+   */
+  /**
+  * Ensures the ACP agent process is running and a session is established.
+  * @param acpTools - Tools from streamText options to proxy
+  */
+  /**
+  * Connects to the ACP agent process and initializes the protocol connection.
+  * Does NOT start a session.
+  */
+  async connectClient() {
+    this.debug.ensureAgentMessageLogFile();
+    if (this.connection) {
+      return;
+    }
+    if (!this.agentProcess) {
+      const sessionCwd = this.config.session?.cwd || (typeof process2.cwd === "function" ? process2.cwd() : "/");
+      this.agentProcess = spawn(this.config.command, this.config.args ?? [], {
+        stdio: [
+          "pipe",
+          "pipe",
+          "pipe"
+        ],
+        env: {
+          ...process2.env,
+          ...this.config.env
+        },
+        cwd: sessionCwd,
+        // Windows GUI hosts (e.g. Electron, /SUBSYSTEM:WINDOWS) have no parent console.
+        // `windowsHide: true` prevents CreateProcess from showing an auto-created console window.
+        // Ref: https://github.com/nodejs/node/issues/21825
+        ...process2.platform === "win32" ? {
+          windowsHide: true
+        } : {}
+      });
+      if (!this.agentProcess.stdout || !this.agentProcess.stdin) {
+        throw new Error("Failed to spawn agent process with stdio");
+      }
+      this.stderrChunks = [];
+      this.agentProcess.stderr?.on("data", (chunk) => {
+        const text = new TextDecoder().decode(chunk);
+        this.stderrChunks.push(text);
+        process2.stderr.write(chunk);
+      });
+      const input = Writable.toWeb(this.agentProcess.stdin);
+      const output = 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
+      }
+    };
+    try {
+      const initResult = await this.connection.initialize(initConfig);
+      const authMethods = initResult.authMethods ?? [];
+      this.availableAuthMethodIds = authMethods.map((a) => a.id);
+      if (authMethods.length > 0) {
+        const configuredAuthMethodId = this.config.authMethodId;
+        if (!configuredAuthMethodId) {
+          const defaultAuthMethodId = this.availableAuthMethodIds[0];
+          console.log(`[acp-ai-provider] Warning: authMethodId is not configured. Lazy auth will default to the first auth method "${defaultAuthMethodId}".`, JSON.stringify(authMethods, null, 2));
+        } else if (!this.availableAuthMethodIds.includes(configuredAuthMethodId)) {
+          console.log(`[acp-ai-provider] Warning: authMethodId "${configuredAuthMethodId}" is not in initialize.authMethods. Lazy auth auto-retry will be skipped unless you call authenticate() with a valid method.`, JSON.stringify(authMethods, null, 2));
+        } else {
+          console.log(`[acp-ai-provider] Lazy auth enabled with authMethodId="${configuredAuthMethodId}". Authentication will run only when required (code ${ACP_AUTH_REQUIRED_ERROR_CODE}).`);
+        }
+      }
+    } catch (error) {
+      throw toCatchableError(error, this.stderrChunks.join(""));
+    }
+  }
+  /**
+   * 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");
+    }
+    try {
+      const mcpServers = [
+        ...this.config.session?.mcpServers ?? []
+      ];
+      let toolsAdded = false;
+      if (acpTools2 && acpTools2.length > 0 && !this.toolProxyHost) {
+        this.debug.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 ?? process2.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 ?? process2.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 ?? process2.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();
+    } catch (error) {
+      throw toCatchableError(error, this.stderrChunks.join(""));
+    }
+  }
+  async applySessionDelay() {
+    if (this.config.sessionDelayMs) {
+      this.debug.log(`[acp-ai-provider] Waiting ${this.config.sessionDelayMs}ms after session setup...`);
+      await new Promise((resolve) => setTimeout(resolve, this.config.sessionDelayMs));
+    }
+  }
+  /**
+   * Resolves the auth method ID to use for lazy authentication.
+   * Returns null if no valid method is available.
+   */
+  resolveLazyAuthMethodId() {
+    const configured = this.config.authMethodId;
+    if (!configured) {
+      return this.availableAuthMethodIds[0] ?? null;
+    }
+    if (this.availableAuthMethodIds.length === 0) {
+      return configured;
+    }
+    return this.availableAuthMethodIds.includes(configured) ? configured : null;
+  }
+  /**
+   * Runs an operation with lazy auth: try once, and if an auth-required error
+   * is thrown, authenticate and retry exactly once.
+   */
+  async withLazyAuthRetry(stage, operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isAuthRequiredError(error)) {
+        throw error;
+      }
+      const methodId = this.resolveLazyAuthMethodId();
+      if (!methodId) {
+        throw error;
+      }
+      this.debug.log(`[acp-ai-provider] Authentication required during ${stage} (code ${ACP_AUTH_REQUIRED_ERROR_CODE}). Running lazy authenticate with methodId="${methodId}" and retrying once...`);
+      await this.authenticate(methodId);
+      return await operation();
+    }
+  }
+  /**
+   * Ensures the ACP agent process is running and a session is established.
+   *
+   * Lazy auth behavior:
+   * - first try connect + start session without authenticating
+   * - if auth is required (ACP auth-required error), authenticate once and retry once
+   *
+   * @param acpTools - Tools from streamText options to proxy
+   */
+  async ensureConnected(acpTools2) {
+    await this.withLazyAuthRetry("session setup", async () => {
+      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.
+   *
+   * @param tools - Optional 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;
+  }
+  /**
+   * Triggers ACP authentication manually.
+   * Useful when callers catch an auth-required error and want to authenticate then retry.
+   */
+  async authenticate(methodId) {
+    await this.connectClient();
+    if (!this.connection) {
+      throw new Error("Not connected");
+    }
+    try {
+      await this.connection.authenticate({
+        methodId
+      });
+    } catch (error) {
+      throw toCatchableError(error, this.stderrChunks.join(""));
+    }
+  }
+  async promptWithLazyAuthRetry(request) {
+    if (!this.connection) {
+      throw new Error("Not connected");
+    }
+    try {
+      const response = await this.withLazyAuthRetry("prompt", () => this.connection.prompt(request));
+      this.debug.appendPromptResponse(response);
+      return response;
+    } catch (error) {
+      this.debug.appendPromptError(error);
+      throw error;
+    }
+  }
+  /**
+   * 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.unstable_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.stderr?.destroy();
+      this.agentProcess = null;
+    }
+    this.connection = null;
+    this.sessionId = null;
+    this.sessionResponse = null;
+    this.client = null;
+    this.stderrChunks = [];
+    this.availableAuthMethodIds = [];
+  }
+  /**
+   * Emits raw content (plan, diffs, terminals) as raw stream parts.
+   * Plan data is emitted directly, while diffs and terminals are bound to a toolCallId.
+   */
+  emitRawContent(controller, data) {
+    if ("entries" in data) {
+      controller.enqueue({
+        type: "raw",
+        rawValue: JSON.stringify({
+          type: "plan",
+          entries: data.entries
+        })
+      });
+      return;
+    }
+    for (const item of data.content) {
+      if (item.type === "diff" || item.type === "terminal") {
+        controller.enqueue({
+          type: "raw",
+          rawValue: JSON.stringify({
+            ...item,
+            toolCallId: data.toolCallId
+          })
+        });
+      }
+    }
+  }
+  /**
+   * Flushes any pending tool calls that haven't emitted tool-call yet.
+   * This handles the case where a tool emits {} first, then the next message is a different type.
+   */
+  flushPendingToolCalls(controller) {
+    for (const [toolCallId, toolInfo] of this.toolCallsMap.entries()) {
+      if (!toolInfo.inputAvailable) {
+        toolInfo.inputAvailable = true;
+        controller.enqueue({
+          type: "tool-call",
+          toolCallId,
+          toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
+          input: JSON.stringify({
+            toolCallId,
+            toolName: toolInfo.name,
+            args: {}
+          })
+        });
+      }
+    }
+  }
+  /**
+   * Standardized handler for converting SessionNotifications into
+   * LanguageModelV3StreamPart objects, pushing them onto a stream controller.
+   */
+  handleStreamNotification(controller, notification) {
+    this.debug.appendAgentMessage(notification);
+    const update = notification.update;
+    switch (update.sessionUpdate) {
+      case "plan":
+        this.flushPendingToolCalls(controller);
+        this.emitRawContent(controller, {
+          type: "plan",
+          entries: update.entries
+        });
+        break;
+      case "agent_thought_chunk":
+        this.flushPendingToolCalls(controller);
+        if (!this.currentThinkingId) {
+          this.currentThinkingId = `reasoning - ${this.thinkBlockIndex++} `;
+          controller.enqueue({
+            type: "reasoning-start",
+            id: this.currentThinkingId
+          });
+        }
+        controller.enqueue({
+          type: "reasoning-delta",
+          id: this.currentThinkingId,
+          delta: update.content.type === "text" ? update.content.text : ""
+        });
+        break;
+      case "agent_message_chunk":
+        this.flushPendingToolCalls(controller);
+        if (this.currentThinkingId) {
+          controller.enqueue({
+            type: "reasoning-end",
+            id: this.currentThinkingId
+          });
+          this.currentThinkingId = null;
+        }
+        if (update.content.type === "text") {
+          const textChunk = update.content.text;
+          if (!this.currentTextId) {
+            this.currentTextId = `text - ${this.textBlockIndex++} `;
+            controller.enqueue({
+              type: "text-start",
+              id: this.currentTextId
+            });
+          }
+          controller.enqueue({
+            type: "text-delta",
+            id: this.currentTextId,
+            delta: textChunk
+          });
+        }
+        break;
+      case "tool_call": {
+        if (this.currentTextId) {
+          controller.enqueue({
+            type: "text-end",
+            id: this.currentTextId
+          });
+          this.currentTextId = null;
+        }
+        if (this.currentThinkingId) {
+          controller.enqueue({
+            type: "reasoning-end",
+            id: this.currentThinkingId
+          });
+          this.currentThinkingId = null;
+        }
+        const { toolCallId, toolName, toolInput } = this.parseToolCall(update);
+        const existingToolCall = this.toolCallsMap.get(toolCallId);
+        const hasInput = this.hasToolInput(toolInput);
+        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 } = this.parseToolResult(update);
+        const effectiveStatus = update.status ?? "in_progress";
+        let toolInfo = this.toolCallsMap.get(toolCallId);
+        const updateInput = this.normalizeToolInput("rawInput" in update ? update.rawInput : void 0);
+        if (effectiveStatus === "in_progress") {
+          if (!toolInfo) {
+            toolInfo = {
+              index: this.toolCallsMap.size,
+              name: toolName,
+              inputStarted: true,
+              inputAvailable: false
+            };
+            this.toolCallsMap.set(toolCallId, toolInfo);
+            controller.enqueue({
+              type: "tool-input-start",
+              id: toolCallId,
+              toolName
+            });
+          }
+          const hasNewInput = this.hasToolInput(updateInput);
+          if (!toolInfo.inputAvailable || hasNewInput) {
+            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: updateInput
+              })
+            });
+          }
+          const content2 = update.content ?? [];
+          if (content2.length > 0) {
+            this.emitRawContent(controller, {
+              content: content2,
+              toolCallId
+            });
+          }
+          break;
+        }
+        if (![
+          "completed",
+          "failed"
+        ].includes(effectiveStatus)) {
+          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,
+              args: updateInput
+            })
+          });
+        } else {
+          const hasNewInput = this.hasToolInput(updateInput);
+          if (!toolInfo.inputAvailable || hasNewInput) {
+            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: updateInput
+              })
+            });
+          }
+        }
+        const clientToolInfo = this.isClientToolResult(toolResult);
+        if (clientToolInfo.isClientTool) {
+          this.debug.log(`[acp-ai-provider] Detected client tool: ${clientToolInfo.toolName}, stopping stream`);
+          const content2 = update.content ?? [];
+          if (content2.length > 0) {
+            this.emitRawContent(controller, {
+              content: content2,
+              toolCallId
+            });
+          }
+          if (this.clientToolAbort) {
+            controller.enqueue({
+              type: "finish",
+              finishReason: {
+                unified: "tool-calls",
+                raw: void 0
+              },
+              usage: {
+                inputTokens: {
+                  total: void 0,
+                  noCache: void 0,
+                  cacheRead: void 0,
+                  cacheWrite: void 0
+                },
+                outputTokens: {
+                  total: void 0,
+                  text: void 0,
+                  reasoning: void 0
+                }
+              }
+            });
+            controller.close();
+            this.clientToolAbort.resolve();
+            this.cleanup();
+          }
+          break;
+        }
+        controller.enqueue({
+          type: "tool-result",
+          toolCallId,
+          toolName: ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2,
+          result: toolResult,
+          // https://github.com/vercel/ai/blob/282f062922cb59167dd3a11e3af67cfa0b75f317/packages/ai/src/generate-text/run-tools-transformation.ts#L316
+          ...isError && {
+            isError: true,
+            result: new Error(formatToolError(normalizeToolResultBlocks(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 {
+      const jsonResponseFormat = isJsonResponseFormat(options.responseFormat) ? options.responseFormat : null;
+      const jsonSchemaPrompt = jsonResponseFormat ? buildJsonSchemaPrompt(jsonResponseFormat) : void 0;
+      await this.ensureConnected();
+      const promptContent = convertAiSdkMessagesToAcp(options, this.isFreshSession, jsonSchemaPrompt);
+      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.promptWithLazyAuthRetry({
+        sessionId: this.sessionId,
+        prompt: promptContent
+      });
+      const content = [];
+      const finalText = jsonResponseFormat ? stripMarkdownFences(accumulatedText) : accumulatedText;
+      if (finalText.trim()) {
+        content.push({
+          type: "text",
+          text: finalText
+        });
+      }
+      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: {
+          unified: mapACPStopReasonToAISDK(response.stopReason),
+          raw: response.stopReason
+        },
+        providerMetadata: getACPResponse(response),
+        usage: {
+          inputTokens: {
+            total: void 0,
+            noCache: void 0,
+            cacheRead: void 0,
+            cacheWrite: void 0
+          },
+          outputTokens: {
+            total: void 0,
+            text: void 0,
+            reasoning: void 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);
+    const jsonResponseFormat = isJsonResponseFormat(options.responseFormat) ? options.responseFormat : null;
+    const jsonSchemaPrompt = jsonResponseFormat ? buildJsonSchemaPrompt(jsonResponseFormat) : void 0;
+    try {
+      await this.ensureConnected(acpTools2.length > 0 ? acpTools2 : void 0);
+    } catch (error) {
+      this.forceCleanup();
+      throw error;
+    }
+    const promptContent = convertAiSdkMessagesToAcp(options, this.isFreshSession, jsonSchemaPrompt);
+    this.isFreshSession = false;
+    const sessionId = this.sessionId;
+    const client = this.client;
+    const cleanup = () => this.cleanup();
+    const streamHandler = this.handleStreamNotification.bind(this);
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        controller.enqueue({
+          type: "stream-start",
+          warnings: []
+        });
+        this.resetStreamState();
+        const clientToolPromise = new Promise((resolve) => {
+          this.clientToolAbort = {
+            controller,
+            resolve
+          };
+        });
+        try {
+          if (client) {
+            client.setSessionUpdateHandler((notification) => {
+              streamHandler(controller, notification);
+            });
+          }
+          const promptPromise = this.promptWithLazyAuthRetry({
+            sessionId,
+            prompt: promptContent
+          });
+          const result = await Promise.race([
+            promptPromise.then((response2) => ({
+              type: "response",
+              response: response2
+            })),
+            clientToolPromise.then(() => ({
+              type: "client-tool"
+            }))
+          ]);
+          if (result.type === "client-tool") {
+            return;
+          }
+          const response = result.response;
+          controller.enqueue({
+            type: "finish",
+            finishReason: {
+              unified: mapACPStopReasonToAISDK(response.stopReason),
+              raw: response.stopReason
+            },
+            providerMetadata: getACPResponse(response),
+            usage: {
+              inputTokens: {
+                total: void 0,
+                noCache: void 0,
+                cacheRead: void 0,
+                cacheWrite: void 0
+              },
+              outputTokens: {
+                total: void 0,
+                text: void 0,
+                reasoning: void 0
+              }
+            }
+          });
+          controller.close();
+          cleanup();
+        } catch (error) {
+          cleanup();
+          controller.enqueue({
+            type: "error",
+            error: toCatchableError(error, this.stderrChunks.join(""))
+          });
+        }
+      },
+      cancel: () => {
+        cleanup();
+      }
+    });
+    const outputStream = jsonResponseFormat ? stream.pipeThrough(createJsonCleanupTransform()) : stream;
+    return {
+      stream: outputStream,
+      warnings: void 0
+    };
+  }
+  get tools() {
+    return getACPDynamicTool();
+  }
+};
+
+// __mcpc__acp-ai-provider_latest/node_modules/@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();
+  }
+  /**
+   * Runs authentication manually.
+   *
+   * If `methodId` is omitted, falls back to `config.authMethodId`.
+   */
+  authenticate(methodId) {
+    if (!this.model) {
+      this.languageModel();
+    }
+    const resolvedMethodId = methodId ?? this.config.authMethodId;
+    if (!resolvedMethodId) {
+      throw new Error("No auth method configured. Pass methodId or set authMethodId in ACPProviderSettings.");
+    }
+    return this.model.authenticate(resolvedMethodId);
+  }
+  /**
+   * 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);
+}
+export {
+  ACPLanguageModel,
+  ACPProvider,
+  ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME2 as ACP_PROVIDER_AGENT_DYNAMIC_TOOL_NAME,
+  acpTools,
+  createACPProvider,
+  getExecuteByName,
+  hasRegisteredExecute,
+  providerAgentDynamicToolSchema
+};