svamp-cli 0.2.342 → 0.2.346

package/dist/acpBackend-BZ1MJhQV.mjs

@@ -0,0 +1,922 @@
+import { spawn } from 'node:child_process';
+import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
+import { randomUUID } from 'node:crypto';
+import { DefaultTransport } from './DefaultTransport-vfp78fug.mjs';
+import { w as wrapWithIsolation } from './wrapCommand-CdNawSaa.mjs';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+
+const DEFAULT_IDLE_TIMEOUT_MS = 500;
+const DEFAULT_TOOL_CALL_TIMEOUT_MS = 12e4;
+function parseArgsFromContent(content) {
+  if (Array.isArray(content)) return { items: content };
+  if (content && typeof content === "object" && content !== null) {
+    return content;
+  }
+  return {};
+}
+function extractErrorDetail(content) {
+  if (!content) return void 0;
+  if (typeof content === "string") return content;
+  if (typeof content === "object" && content !== null && !Array.isArray(content)) {
+    const obj = content;
+    if (obj.error) {
+      const error = obj.error;
+      if (typeof error === "string") return error;
+      if (error && typeof error === "object" && "message" in error) {
+        const errObj = error;
+        if (typeof errObj.message === "string") return errObj.message;
+      }
+      return JSON.stringify(error);
+    }
+    if (typeof obj.message === "string") return obj.message;
+    const status = typeof obj.status === "string" ? obj.status : void 0;
+    const reason = typeof obj.reason === "string" ? obj.reason : void 0;
+    return status || reason || JSON.stringify(obj).substring(0, 500);
+  }
+  return void 0;
+}
+function formatDuration(startTime) {
+  if (!startTime) return "unknown";
+  const duration = Date.now() - startTime;
+  return `${(duration / 1e3).toFixed(2)}s`;
+}
+function handleAgentMessageChunk(update, ctx) {
+  const content = update.content;
+  if (!content || typeof content !== "object" || !("text" in content)) {
+    return { handled: false };
+  }
+  const text = content.text;
+  if (typeof text !== "string") return { handled: false };
+  const isThinking = /^\*\*[^*]+\*\*\n/.test(text);
+  if (isThinking) {
+    ctx.emit({ type: "event", name: "thinking", payload: { text, streaming: true } });
+  } else {
+    ctx.emit({ type: "model-output", textDelta: text });
+    ctx.clearIdleTimeout();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, idleTimeoutMs);
+  }
+  return { handled: true };
+}
+function handleAgentThoughtChunk(update, ctx) {
+  const content = update.content;
+  if (!content || typeof content !== "object" || !("text" in content)) {
+    return { handled: false };
+  }
+  const text = content.text;
+  if (typeof text !== "string") return { handled: false };
+  ctx.emit({ type: "event", name: "thinking", payload: { text, streaming: true } });
+  return { handled: true };
+}
+function startToolCall(toolCallId, toolKind, update, ctx, source) {
+  const startTime = Date.now();
+  const toolKindStr = typeof toolKind === "string" ? toolKind : void 0;
+  const isInvestigation = ctx.transport.isInvestigationTool?.(toolCallId, toolKindStr) ?? false;
+  const extractedName = ctx.transport.extractToolNameFromId?.(toolCallId);
+  const realToolName = extractedName ?? (toolKindStr || "unknown");
+  ctx.toolCallIdToNameMap.set(toolCallId, realToolName);
+  ctx.activeToolCalls.add(toolCallId);
+  ctx.toolCallStartTimes.set(toolCallId, startTime);
+  ctx.log(`Tool call START: ${toolCallId} (${toolKind} -> ${realToolName})${isInvestigation ? " [INVESTIGATION]" : ""} (from ${source})`);
+  const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
+  if (!ctx.toolCallTimeouts.has(toolCallId)) {
+    const timeout = setTimeout(() => {
+      ctx.activeToolCalls.delete(toolCallId);
+      ctx.toolCallStartTimes.delete(toolCallId);
+      ctx.toolCallTimeouts.delete(toolCallId);
+      ctx.toolCallIdToNameMap.delete(toolCallId);
+      ctx.log(`Tool call TIMEOUT: ${toolCallId} (${toolKind}) after ${(timeoutMs / 1e3).toFixed(0)}s`);
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, timeoutMs);
+    ctx.toolCallTimeouts.set(toolCallId, timeout);
+  }
+  ctx.clearIdleTimeout();
+  ctx.emit({ type: "status", status: "running" });
+  const args = parseArgsFromContent(update.content);
+  if (update.locations && Array.isArray(update.locations)) {
+    args.locations = update.locations;
+  }
+  ctx.emit({
+    type: "tool-call",
+    toolName: toolKindStr || "unknown",
+    args,
+    callId: toolCallId
+  });
+}
+function completeToolCall(toolCallId, toolKind, content, ctx) {
+  const startTime = ctx.toolCallStartTimes.get(toolCallId);
+  const duration = formatDuration(startTime);
+  const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
+  ctx.activeToolCalls.delete(toolCallId);
+  ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
+  const timeout = ctx.toolCallTimeouts.get(toolCallId);
+  if (timeout) {
+    clearTimeout(timeout);
+    ctx.toolCallTimeouts.delete(toolCallId);
+  }
+  ctx.log(`Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - ${duration}. Active: ${ctx.activeToolCalls.size}`);
+  ctx.emit({ type: "tool-result", toolName: toolKindStr, result: content, callId: toolCallId });
+  if (ctx.activeToolCalls.size === 0) {
+    ctx.clearIdleTimeout();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, idleTimeoutMs);
+  }
+}
+function failToolCall(toolCallId, status, toolKind, content, ctx) {
+  const startTime = ctx.toolCallStartTimes.get(toolCallId);
+  const duration = formatDuration(startTime);
+  const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
+  ctx.activeToolCalls.delete(toolCallId);
+  ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
+  const timeout = ctx.toolCallTimeouts.get(toolCallId);
+  if (timeout) {
+    clearTimeout(timeout);
+    ctx.toolCallTimeouts.delete(toolCallId);
+  }
+  const errorDetail = extractErrorDetail(content);
+  ctx.log(`Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - ${duration}. Active: ${ctx.activeToolCalls.size}`);
+  ctx.emit({
+    type: "tool-result",
+    toolName: toolKindStr,
+    result: errorDetail ? { error: errorDetail, status } : { error: `Tool call ${status}`, status },
+    callId: toolCallId
+  });
+  if (ctx.activeToolCalls.size === 0) {
+    ctx.clearIdleTimeout();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, idleTimeoutMs);
+  }
+}
+function handleToolCallUpdate(update, ctx) {
+  const status = update.status;
+  const toolCallId = update.toolCallId;
+  if (!toolCallId) return { handled: false };
+  const toolKind = update.kind || "unknown";
+  let toolCallCountSincePrompt = ctx.toolCallCountSincePrompt;
+  if (status === "in_progress" || status === "pending") {
+    if (!ctx.activeToolCalls.has(toolCallId)) {
+      toolCallCountSincePrompt++;
+      startToolCall(toolCallId, toolKind, update, ctx, "tool_call_update");
+    }
+  } else if (status === "completed") {
+    completeToolCall(toolCallId, toolKind, update.content, ctx);
+  } else if (status === "failed" || status === "cancelled") {
+    failToolCall(toolCallId, status, toolKind, update.content, ctx);
+  }
+  return { handled: true, toolCallCountSincePrompt };
+}
+function handleToolCall(update, ctx) {
+  const toolCallId = update.toolCallId;
+  const status = update.status;
+  const isInProgress = !status || status === "in_progress" || status === "pending";
+  if (!toolCallId || !isInProgress) return { handled: false };
+  if (ctx.activeToolCalls.has(toolCallId)) return { handled: true };
+  startToolCall(toolCallId, update.kind, update, ctx, "tool_call");
+  return { handled: true };
+}
+function handleLegacyMessageChunk(update, ctx) {
+  if (!update.messageChunk) return { handled: false };
+  const chunk = update.messageChunk;
+  if (chunk.textDelta) {
+    ctx.emit({ type: "model-output", textDelta: chunk.textDelta });
+    return { handled: true };
+  }
+  return { handled: false };
+}
+function handlePlanUpdate(update, ctx) {
+  if (!update.plan) return { handled: false };
+  ctx.emit({ type: "event", name: "plan", payload: update.plan });
+  return { handled: true };
+}
+function handleThinkingUpdate(update, ctx) {
+  if (!update.thinking) return { handled: false };
+  ctx.emit({ type: "event", name: "thinking", payload: update.thinking });
+  return { handled: true };
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const RETRY_CONFIG = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 5e3
+};
+function nodeToWebStreams(stdin, stdout) {
+  const writable = new WritableStream({
+    write(chunk) {
+      return new Promise((resolve, reject) => {
+        const ok = stdin.write(chunk, (err) => {
+          if (err) reject(err);
+        });
+        if (ok) resolve();
+        else stdin.once("drain", resolve);
+      });
+    },
+    close() {
+      return new Promise((resolve) => {
+        stdin.end(resolve);
+      });
+    },
+    abort(reason) {
+      stdin.destroy(reason instanceof Error ? reason : new Error(String(reason)));
+    }
+  });
+  const readable = new ReadableStream({
+    start(controller) {
+      stdout.on("data", (chunk) => {
+        controller.enqueue(new Uint8Array(chunk));
+      });
+      stdout.on("end", () => {
+        controller.close();
+      });
+      stdout.on("error", (err) => {
+        controller.error(err);
+      });
+    },
+    cancel() {
+      stdout.destroy();
+    }
+  });
+  return { writable, readable };
+}
+async function withRetry(operation, opts) {
+  let lastError = null;
+  const log = opts.log || (() => {
+  });
+  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof Error) {
+        lastError = error;
+      } else if (typeof error === "object" && error !== null) {
+        const obj = error;
+        const msg = typeof obj.message === "string" ? obj.message : JSON.stringify(error);
+        lastError = new Error(msg);
+      } else {
+        lastError = new Error(String(error));
+      }
+      const shouldRetry = opts.shouldRetry ? opts.shouldRetry(lastError) : true;
+      if (attempt < opts.maxAttempts && shouldRetry) {
+        const delayMs = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
+        log(`${opts.operationName} failed (attempt ${attempt}/${opts.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
+        await delay(delayMs);
+      } else {
+        break;
+      }
+    }
+  }
+  throw lastError;
+}
+class AcpBackend {
+  constructor(options) {
+    this.options = options;
+    this.transport = options.transportHandler ?? new DefaultTransport(options.agentName);
+    this.log = options.log || ((...args) => {
+    });
+  }
+  listeners = [];
+  process = null;
+  connection = null;
+  acpSessionId = null;
+  disposed = false;
+  activeToolCalls = /* @__PURE__ */ new Set();
+  toolCallTimeouts = /* @__PURE__ */ new Map();
+  toolCallStartTimes = /* @__PURE__ */ new Map();
+  toolCallIdToNameMap = /* @__PURE__ */ new Map();
+  recentPromptHadChangeTitle = false;
+  toolCallCountSincePrompt = 0;
+  idleTimeout = null;
+  transport;
+  log;
+  // Promise resolver for waitForIdle
+  idleResolver = null;
+  waitingForResponse = false;
+  onMessage(handler) {
+    this.listeners.push(handler);
+  }
+  offMessage(handler) {
+    const index = this.listeners.indexOf(handler);
+    if (index !== -1) this.listeners.splice(index, 1);
+  }
+  emit(msg) {
+    if (this.disposed) return;
+    for (const listener of this.listeners) {
+      try {
+        listener(msg);
+      } catch {
+      }
+    }
+  }
+  /** Get the underlying child process (for cleanup) */
+  getProcess() {
+    return this.process;
+  }
+  async startSession(initialPrompt) {
+    if (this.disposed) throw new Error("Backend has been disposed");
+    const sessionId = randomUUID();
+    this.emit({ type: "status", status: "starting" });
+    let startupStatusErrorEmitted = false;
+    try {
+      const args = this.options.args || [];
+      let spawnCommand = this.options.command;
+      let spawnArgs = args;
+      let isoEnv = {};
+      let isoCleanupFiles = [];
+      if (this.options.isolationConfig) {
+        const wrapped = wrapWithIsolation(spawnCommand, spawnArgs, this.options.isolationConfig);
+        spawnCommand = wrapped.command;
+        spawnArgs = wrapped.args;
+        if (wrapped.env) isoEnv = wrapped.env;
+        if (wrapped.cleanupFiles) isoCleanupFiles = wrapped.cleanupFiles;
+        this.log(`[ACP] Isolation: ${this.options.isolationConfig.method}`);
+      }
+      const spawnEnv = { ...process.env, ...this.options.env, ...isoEnv };
+      if (process.platform === "win32") {
+        const fullCommand = [spawnCommand, ...spawnArgs].join(" ");
+        this.process = spawn("cmd.exe", ["/c", fullCommand], {
+          cwd: this.options.cwd,
+          env: spawnEnv,
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
+        });
+      } else {
+        this.process = spawn(spawnCommand, spawnArgs, {
+          cwd: this.options.cwd,
+          env: spawnEnv,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
+      if (isoCleanupFiles.length > 0) {
+        this.process.on("exit", async () => {
+          const { rm } = await import('node:fs/promises');
+          for (const f of isoCleanupFiles) rm(f, { force: true }).catch(() => {
+          });
+        });
+      }
+      if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
+        throw new Error("Failed to create stdio pipes");
+      }
+      let startupFailure = null;
+      let startupFailureSettled = false;
+      let rejectStartupFailure = null;
+      const startupFailurePromise = new Promise((_, reject) => {
+        rejectStartupFailure = (error) => {
+          if (startupFailureSettled) return;
+          startupFailureSettled = true;
+          startupFailure = error;
+          reject(error);
+        };
+      });
+      const signalStartupFailure = (error) => {
+        rejectStartupFailure?.(error);
+      };
+      this.process.stderr.on("data", (data) => {
+        const text = data.toString();
+        if (!text.trim()) return;
+        const hasActiveInvestigation = this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false;
+        const context = {
+          activeToolCalls: this.activeToolCalls,
+          hasActiveInvestigation
+        };
+        this.log(`[ACP] stderr: ${text.trim()}`);
+        if (this.transport.handleStderr) {
+          const result = this.transport.handleStderr(text, context);
+          if (result.message) this.emit(result.message);
+        }
+      });
+      this.process.on("error", (err) => {
+        signalStartupFailure(err);
+        this.log(`[ACP] Process error: ${err.message}`);
+        startupStatusErrorEmitted = true;
+        this.emit({ type: "status", status: "error", detail: err.message });
+      });
+      this.process.on("exit", (code, signal) => {
+        this.process = null;
+        if (this.disposed) return;
+        if (code !== 0 && code !== null) {
+          signalStartupFailure(new Error(`Exit code: ${code}`));
+          this.log(`[ACP] Process exited: code=${code}, signal=${signal}`);
+          this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
+        } else if (code === null && this.waitingForResponse) {
+          this.log(`[ACP] Process killed by signal: ${signal} (mid-turn)`);
+          this.waitingForResponse = false;
+          if (this.idleResolver) {
+            this.idleResolver();
+            this.idleResolver = null;
+          }
+          this.emit({ type: "status", status: "stopped", detail: `Process killed by signal: ${signal}` });
+        } else if (code === 0 && this.waitingForResponse) {
+          this.log(`[ACP] Process exited cleanly but response was pending \u2014 emitting idle`);
+          this.emitIdleStatus();
+        }
+      });
+      const streams = nodeToWebStreams(this.process.stdin, this.process.stdout);
+      const transport = this.transport;
+      const logFn = this.log;
+      const filteredReadable = new ReadableStream({
+        async start(controller) {
+          const reader = streams.readable.getReader();
+          const decoder = new TextDecoder();
+          const encoder = new TextEncoder();
+          let buffer = "";
+          let filteredCount = 0;
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                if (buffer.trim()) {
+                  const filtered = transport.filterStdoutLine?.(buffer);
+                  if (filtered === void 0) controller.enqueue(encoder.encode(buffer));
+                  else if (filtered !== null) controller.enqueue(encoder.encode(filtered));
+                  else filteredCount++;
+                }
+                if (filteredCount > 0) {
+                  logFn(`[ACP] Filtered ${filteredCount} non-JSON lines from ${transport.agentName} stdout`);
+                }
+                controller.close();
+                break;
+              }
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split("\n");
+              buffer = lines.pop() || "";
+              for (const line of lines) {
+                if (!line.trim()) continue;
+                const filtered = transport.filterStdoutLine?.(line);
+                if (filtered === void 0) controller.enqueue(encoder.encode(line + "\n"));
+                else if (filtered !== null) controller.enqueue(encoder.encode(filtered + "\n"));
+                else filteredCount++;
+              }
+            }
+          } catch (error) {
+            controller.error(error);
+          } finally {
+            reader.releaseLock();
+          }
+        }
+      });
+      const stream = ndJsonStream(streams.writable, filteredReadable);
+      const client = {
+        sessionUpdate: async (params) => {
+          this.handleSessionUpdate(params);
+        },
+        requestPermission: async (params) => {
+          const extendedParams = params;
+          const toolCall = extendedParams.toolCall;
+          let toolName = toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool";
+          const toolCallId = toolCall?.id || randomUUID();
+          const permissionId = toolCallId;
+          let input = {};
+          if (toolCall) {
+            input = toolCall.input || toolCall.arguments || toolCall.content || {};
+          } else {
+            input = extendedParams.input || extendedParams.arguments || extendedParams.content || {};
+          }
+          const context = {
+            recentPromptHadChangeTitle: this.recentPromptHadChangeTitle,
+            toolCallCountSincePrompt: this.toolCallCountSincePrompt
+          };
+          toolName = this.transport.determineToolName?.(toolName, toolCallId, input, context) ?? toolName;
+          this.toolCallCountSincePrompt++;
+          const options = extendedParams.options || [];
+          this.log(`[ACP] Permission request: tool=${toolName}, toolCallId=${toolCallId}`);
+          this.emit({
+            type: "permission-request",
+            id: permissionId,
+            reason: toolName,
+            payload: {
+              ...params,
+              permissionId,
+              toolCallId,
+              toolName,
+              input,
+              options: options.map((opt) => ({
+                id: opt.optionId,
+                name: opt.name,
+                kind: opt.kind
+              }))
+            }
+          });
+          if (this.options.permissionHandler) {
+            try {
+              const result = await this.options.permissionHandler.handleToolCall(toolCallId, toolName, input);
+              let optionId = "cancel";
+              if (result.decision === "approved" || result.decision === "approved_for_session") {
+                const proceedOnceOption2 = options.find(
+                  (opt) => opt.optionId === "proceed_once" || opt.name?.toLowerCase().includes("once")
+                );
+                const proceedAlwaysOption = options.find(
+                  (opt) => opt.optionId === "proceed_always" || opt.name?.toLowerCase().includes("always")
+                );
+                if (result.decision === "approved_for_session" && proceedAlwaysOption) {
+                  optionId = proceedAlwaysOption.optionId || "proceed_always";
+                } else if (proceedOnceOption2) {
+                  optionId = proceedOnceOption2.optionId || "proceed_once";
+                } else if (options.length > 0) {
+                  optionId = options[0].optionId || "proceed_once";
+                }
+                this.emit({
+                  type: "tool-result",
+                  toolName,
+                  result: { status: "approved", decision: result.decision },
+                  callId: permissionId
+                });
+              } else {
+                const cancelOption = options.find(
+                  (opt) => opt.optionId === "cancel" || opt.name?.toLowerCase().includes("cancel")
+                );
+                if (cancelOption) optionId = cancelOption.optionId || "cancel";
+                this.emit({
+                  type: "tool-result",
+                  toolName,
+                  result: { status: "denied", decision: result.decision },
+                  callId: permissionId
+                });
+              }
+              return { outcome: { outcome: "selected", optionId } };
+            } catch (error) {
+              this.log("[ACP] Error in permission handler:", error);
+              return { outcome: { outcome: "selected", optionId: "cancel" } };
+            }
+          }
+          const proceedOnceOption = options.find(
+            (opt) => opt.optionId === "proceed_once" || typeof opt.name === "string" && opt.name.toLowerCase().includes("once")
+          );
+          const defaultOptionId = proceedOnceOption?.optionId || (options.length > 0 && options[0].optionId ? options[0].optionId : "proceed_once");
+          return { outcome: { outcome: "selected", optionId: defaultOptionId } };
+        }
+      };
+      this.connection = new ClientSideConnection(
+        (agent) => client,
+        stream
+      );
+      const initRequest = {
+        protocolVersion: 1,
+        clientCapabilities: {
+          fs: { readTextFile: false, writeTextFile: false }
+        },
+        clientInfo: { name: "svamp-cli", version: "0.1.0" }
+      };
+      const initTimeout = this.transport.getInitTimeout();
+      this.log(`[ACP] Initializing connection (timeout: ${initTimeout}ms)...`);
+      const isNonRetryableStartupError = (error) => {
+        const maybeErr = error;
+        if (startupFailure && error === startupFailure) return true;
+        if (maybeErr.code === "ENOENT" || maybeErr.code === "EACCES" || maybeErr.code === "EPIPE") return true;
+        if (maybeErr.code === "DISPOSED") return true;
+        const msg = error.message.toLowerCase();
+        if (msg.includes("api key") || msg.includes("not configured") || msg.includes("401") || msg.includes("403")) return true;
+        return false;
+      };
+      await withRetry(
+        async () => {
+          if (this.disposed) throw Object.assign(new Error("Backend disposed during startup retry"), { code: "DISPOSED" });
+          let timeoutHandle = null;
+          try {
+            const result = await Promise.race([
+              startupFailurePromise,
+              this.connection.initialize(initRequest).then((res) => {
+                if (timeoutHandle) {
+                  clearTimeout(timeoutHandle);
+                  timeoutHandle = null;
+                }
+                return res;
+              }),
+              new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                  reject(new Error(`Initialize timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                }, initTimeout);
+              })
+            ]);
+            return result;
+          } finally {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+          }
+        },
+        {
+          operationName: "Initialize",
+          maxAttempts: RETRY_CONFIG.maxAttempts,
+          baseDelayMs: RETRY_CONFIG.baseDelayMs,
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !isNonRetryableStartupError(error),
+          log: this.log
+        }
+      );
+      this.log(`[ACP] Initialize completed`);
+      const mcpServers = this.options.mcpServers ? Object.entries(this.options.mcpServers).map(([name, config]) => {
+        if (config.type === "http" && config.url) {
+          return { name, url: config.url };
+        }
+        return {
+          name,
+          command: config.command || "",
+          args: config.args || [],
+          env: config.env ? Object.entries(config.env).map(([envName, envValue]) => ({ name: envName, value: envValue })) : []
+        };
+      }) : [];
+      const newSessionRequest = {
+        cwd: this.options.cwd,
+        mcpServers
+      };
+      this.log(`[ACP] Creating new session...`);
+      const sessionResponse = await withRetry(
+        async () => {
+          if (this.disposed) throw Object.assign(new Error("Backend disposed during startup retry"), { code: "DISPOSED" });
+          let timeoutHandle = null;
+          try {
+            const result = await Promise.race([
+              startupFailurePromise,
+              this.connection.newSession(newSessionRequest).then((res) => {
+                if (timeoutHandle) {
+                  clearTimeout(timeoutHandle);
+                  timeoutHandle = null;
+                }
+                return res;
+              }),
+              new Promise((_, reject) => {
+                timeoutHandle = setTimeout(() => {
+                  reject(new Error(`New session timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
+                }, initTimeout);
+              })
+            ]);
+            return result;
+          } finally {
+            if (timeoutHandle) clearTimeout(timeoutHandle);
+          }
+        },
+        {
+          operationName: "NewSession",
+          maxAttempts: RETRY_CONFIG.maxAttempts,
+          baseDelayMs: RETRY_CONFIG.baseDelayMs,
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !isNonRetryableStartupError(error),
+          log: this.log
+        }
+      );
+      this.acpSessionId = sessionResponse.sessionId;
+      this.log(`[ACP] Session created: ${this.acpSessionId}`);
+      this.emitInitialSessionMetadata(sessionResponse);
+      this.emitIdleStatus();
+      if (initialPrompt) {
+        this.sendPrompt(sessionId, initialPrompt).catch((error) => {
+          this.log("[ACP] Error sending initial prompt:", error);
+          this.emit({ type: "status", status: "error", detail: String(error) });
+        });
+      }
+      return { sessionId };
+    } catch (error) {
+      this.log("[ACP] Error starting session:", error);
+      if (!startupStatusErrorEmitted) {
+        this.emit({
+          type: "status",
+          status: "error",
+          detail: error instanceof Error ? error.message : String(error)
+        });
+      }
+      throw error;
+    }
+  }
+  createHandlerContext() {
+    return {
+      transport: this.transport,
+      activeToolCalls: this.activeToolCalls,
+      toolCallStartTimes: this.toolCallStartTimes,
+      toolCallTimeouts: this.toolCallTimeouts,
+      toolCallIdToNameMap: this.toolCallIdToNameMap,
+      idleTimeout: this.idleTimeout,
+      toolCallCountSincePrompt: this.toolCallCountSincePrompt,
+      emit: (msg) => this.emit(msg),
+      emitIdleStatus: () => this.emitIdleStatus(),
+      clearIdleTimeout: () => {
+        if (this.idleTimeout) {
+          clearTimeout(this.idleTimeout);
+          this.idleTimeout = null;
+        }
+      },
+      setIdleTimeout: (callback, ms) => {
+        this.idleTimeout = setTimeout(() => {
+          callback();
+          this.idleTimeout = null;
+        }, ms);
+      },
+      log: this.log
+    };
+  }
+  emitInitialSessionMetadata(sessionResponse) {
+    if (Array.isArray(sessionResponse.configOptions)) {
+      this.emit({
+        type: "event",
+        name: "config_options_update",
+        payload: { configOptions: sessionResponse.configOptions }
+      });
+    }
+    if (sessionResponse.modes) {
+      this.emit({ type: "event", name: "modes_update", payload: sessionResponse.modes });
+      this.emit({ type: "event", name: "current_mode_update", payload: { currentModeId: sessionResponse.modes.currentModeId } });
+    }
+    if (sessionResponse.models) {
+      this.emit({ type: "event", name: "models_update", payload: sessionResponse.models });
+    }
+  }
+  handleSessionUpdate(params) {
+    const notification = params;
+    const update = notification.update;
+    if (!update) return;
+    const sessionUpdateType = update.sessionUpdate;
+    const updateType = sessionUpdateType;
+    this.log(`[ACP] sessionUpdate: ${sessionUpdateType}`);
+    const ctx = this.createHandlerContext();
+    if (sessionUpdateType === "agent_message_chunk") {
+      handleAgentMessageChunk(update, ctx);
+      return;
+    }
+    if (sessionUpdateType === "tool_call_update") {
+      const result = handleToolCallUpdate(update, ctx);
+      if (result.toolCallCountSincePrompt !== void 0) {
+        this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
+      }
+      return;
+    }
+    if (sessionUpdateType === "agent_thought_chunk") {
+      handleAgentThoughtChunk(update, ctx);
+      return;
+    }
+    if (sessionUpdateType === "tool_call") {
+      handleToolCall(update, ctx);
+      return;
+    }
+    if (sessionUpdateType === "available_commands_update") {
+      const commands = update.availableCommands;
+      if (Array.isArray(commands)) {
+        this.emit({ type: "event", name: "available_commands", payload: commands });
+      }
+      return;
+    }
+    if (updateType === "config_option_update" || updateType === "config_options_update") {
+      const configOptions = update.configOptions;
+      if (Array.isArray(configOptions)) {
+        this.emit({ type: "event", name: "config_options_update", payload: { configOptions } });
+      }
+      return;
+    }
+    if (updateType === "current_mode_update") {
+      const currentModeId = update.currentModeId;
+      if (typeof currentModeId === "string" && currentModeId.length > 0) {
+        this.emit({ type: "event", name: "current_mode_update", payload: { currentModeId } });
+      }
+      return;
+    }
+    handleLegacyMessageChunk(update, ctx);
+    handlePlanUpdate(update, ctx);
+    handleThinkingUpdate(update, ctx);
+  }
+  emitIdleStatus() {
+    const resolver = this.idleResolver;
+    this.idleResolver = null;
+    this.waitingForResponse = false;
+    this.emit({ type: "status", status: "idle" });
+    if (resolver) {
+      const newPromptInFlight = this.waitingForResponse;
+      resolver();
+      if (newPromptInFlight) {
+        this.waitingForResponse = true;
+      }
+    }
+  }
+  async sendPrompt(sessionId, prompt) {
+    const promptHasChangeTitle = this.options.hasChangeTitleInstruction?.(prompt) ?? false;
+    this.toolCallCountSincePrompt = 0;
+    this.recentPromptHadChangeTitle = promptHasChangeTitle;
+    if (this.disposed) throw new Error("Backend has been disposed");
+    if (!this.connection || !this.acpSessionId) throw new Error("Session not started");
+    this.emit({ type: "status", status: "running" });
+    this.waitingForResponse = true;
+    try {
+      this.log(`[ACP] Sending prompt (length: ${prompt.length})`);
+      const contentBlock = { type: "text", text: prompt };
+      const promptRequest = {
+        sessionId: this.acpSessionId,
+        prompt: [contentBlock]
+      };
+      await this.connection.prompt(promptRequest);
+      this.log("[ACP] Prompt request sent");
+    } catch (error) {
+      this.log("[ACP] Error sending prompt:", error);
+      this.waitingForResponse = false;
+      let errorDetail;
+      if (error instanceof Error) {
+        errorDetail = error.message;
+      } else if (typeof error === "object" && error !== null) {
+        const errObj = error;
+        errorDetail = typeof errObj.message === "string" ? errObj.message : String(error);
+      } else {
+        errorDetail = String(error);
+      }
+      this.emit({ type: "status", status: "error", detail: errorDetail });
+      throw error;
+    }
+  }
+  async waitForResponseComplete(timeoutMs = 12e4) {
+    if (!this.waitingForResponse) return;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.idleResolver = null;
+        this.waitingForResponse = false;
+        reject(new Error("Timeout waiting for response to complete"));
+      }, timeoutMs);
+      this.idleResolver = () => {
+        clearTimeout(timeout);
+        this.idleResolver = null;
+        this.waitingForResponse = false;
+        resolve();
+      };
+    });
+  }
+  async cancel(sessionId) {
+    if (!this.connection || !this.acpSessionId) return;
+    this.waitingForResponse = false;
+    if (this.idleResolver) {
+      this.idleResolver();
+      this.idleResolver = null;
+    }
+    try {
+      await this.connection.cancel({ sessionId: this.acpSessionId });
+      this.emit({ type: "status", status: "cancelled", detail: "Cancelled by user" });
+    } catch (error) {
+      this.log("[ACP] Error cancelling:", error);
+    }
+  }
+  async respondToPermission(requestId, approved) {
+    this.log(`[ACP] Permission response (UI only): ${requestId} = ${approved}`);
+    this.emit({ type: "permission-response", id: requestId, approved });
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.log("[ACP] Disposing backend");
+    this.disposed = true;
+    if (this.connection && this.acpSessionId) {
+      try {
+        await Promise.race([
+          this.connection.cancel({ sessionId: this.acpSessionId }),
+          new Promise((resolve) => setTimeout(resolve, 2e3))
+        ]);
+      } catch {
+      }
+    }
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          try {
+            if (this.process) this.process.kill("SIGKILL");
+          } catch {
+          }
+          resolve();
+        }, 1e3);
+        const done = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        this.process?.once("exit", done);
+        this.process?.once("close", done);
+      });
+      this.process = null;
+    }
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+    this.listeners = [];
+    this.connection = null;
+    this.acpSessionId = null;
+    this.activeToolCalls.clear();
+    for (const timeout of this.toolCallTimeouts.values()) clearTimeout(timeout);
+    this.toolCallTimeouts.clear();
+    this.toolCallStartTimes.clear();
+    this.toolCallIdToNameMap.clear();
+  }
+}
+
+export { AcpBackend };