happy-imou-cloud 2.0.3 → 2.0.5

package/dist/{index-LYPXVO_L.cjs → index-Dc92gnxM.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-D9dIR956.cjs');
-var persistence = require('./persistence-PzKU0QCa.cjs');
+var api = require('./api-DaqnNHfl.cjs');
+var persistence = require('./persistence-D6Y0604_.cjs');
 var z = require('zod');
 var fs$1 = require('fs/promises');
 var os$1 = require('os');
@@ -70,7 +70,7 @@ async function openBrowser(url) {
   }
 }
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-LYPXVO_L.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Dc92gnxM.cjs', document.baseURI).href)));
 const QRCode = require$1("qrcode-terminal/vendor/QRCode");
 const QRErrorCorrectLevel = require$1("qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel");
 const pendingTempFiles = /* @__PURE__ */ new Set();
@@ -693,7 +693,7 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-LYPXVO_L.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-Dc92gnxM.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;
@@ -4527,6 +4527,107 @@ function parseArgsFromContent(content) {
   }
   return {};
 }
+function appendToolOutput(existing, next) {
+  if (!existing || existing.length === 0) {
+    return next;
+  }
+  if (next === existing || existing.endsWith(next)) {
+    return existing;
+  }
+  if (next.startsWith(existing)) {
+    return next;
+  }
+  return `${existing}${next}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasMeaningfulContent(value) {
+  if (value === null || value === void 0) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.length > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (isRecord(value)) {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+}
+function looksLikeToolMetadata(record) {
+  const metadataKeys = [
+    "command",
+    "cmd",
+    "script",
+    "argv",
+    "cwd",
+    "workingDirectory",
+    "description",
+    "title",
+    "parsed_cmd"
+  ];
+  if (metadataKeys.some((key) => key in record)) {
+    return true;
+  }
+  const nestedKeys = ["input", "toolCall", "arguments", "content"];
+  for (const key of nestedKeys) {
+    const nested = record[key];
+    if (isRecord(nested) && looksLikeToolMetadata(nested)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractToolOutputChunk(content) {
+  if (typeof content === "string") {
+    return content.length > 0 ? content : null;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.map((item) => extractToolOutputChunk(item)).filter((item) => Boolean(item));
+    return parts.length > 0 ? parts.join("") : null;
+  }
+  if (!isRecord(content)) {
+    return null;
+  }
+  const outputKeys = ["stdout", "stderr", "output", "text", "message", "data", "error", "reason"];
+  const hasOutputKey = outputKeys.some((key) => key in content);
+  if (!hasOutputKey && looksLikeToolMetadata(content)) {
+    return null;
+  }
+  for (const key of outputKeys) {
+    if (!(key in content)) {
+      continue;
+    }
+    const value = content[key];
+    const formatted2 = typeof value === "string" ? value : formatDisplayMessage(value);
+    if (formatted2.length > 0) {
+      return formatted2;
+    }
+  }
+  const formatted = formatDisplayMessage(content);
+  return formatted.length > 0 ? formatted : null;
+}
+function mergeStreamedOutputWithResult(content, streamedOutput) {
+  if (!streamedOutput || streamedOutput.length === 0) {
+    return content;
+  }
+  if (!hasMeaningfulContent(content)) {
+    return streamedOutput;
+  }
+  if (isRecord(content)) {
+    const hasStructuredOutput = ["stdout", "stderr", "output", "text", "message", "data"].some((key) => key in content);
+    if (!hasStructuredOutput) {
+      return {
+        ...content,
+        stdout: streamedOutput
+      };
+    }
+  }
+  return content;
+}
 function extractErrorDetail(content) {
   if (!content) return void 0;
   if (typeof content === "string") {
@@ -4674,11 +4775,13 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
     clearTimeout(timeout);
     ctx.toolCallTimeouts.delete(toolCallId);
   }
+  const streamedOutput = ctx.toolCallOutputs.get(toolCallId);
+  ctx.toolCallOutputs.delete(toolCallId);
   api.logger.debug(`[AcpBackend] \u2705 Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - Duration: ${duration}. Active tool calls: ${ctx.activeToolCalls.size}`);
   ctx.emit({
     type: "tool-result",
     toolName: toolKindStr,
-    result: content,
+    result: mergeStreamedOutputWithResult(content, streamedOutput),
     callId: toolCallId
   });
   if (ctx.activeToolCalls.size === 0) {
@@ -4720,6 +4823,8 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   }
   const durationStr = formatDuration(startTime);
   api.logger.debug(`[AcpBackend] \u274C Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - Duration: ${durationStr}. Active tool calls: ${ctx.activeToolCalls.size}`);
+  const streamedOutput = ctx.toolCallOutputs.get(toolCallId);
+  ctx.toolCallOutputs.delete(toolCallId);
   const errorDetail = extractErrorDetail(content);
   if (errorDetail) {
     api.logger.debug(`[AcpBackend] \u274C Tool call error details: ${errorDetail.substring(0, 500)}`);
@@ -4729,7 +4834,11 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   ctx.emit({
     type: "tool-result",
     toolName: toolKindStr,
-    result: errorDetail ? { error: errorDetail, status } : { error: `Tool call ${status}`, status },
+    result: streamedOutput ? {
+      stdout: streamedOutput,
+      error: errorDetail || `Tool call ${status}`,
+      status
+    } : errorDetail ? { error: errorDetail, status } : { error: `Tool call ${status}`, status },
     callId: toolCallId
   });
   if (ctx.activeToolCalls.size === 0) {
@@ -4745,8 +4854,13 @@ function handleToolCallUpdate(update, ctx) {
     api.logger.debug("[AcpBackend] Tool call update without toolCallId:", update);
     return { handled: false };
   }
-  const toolKind = update.kind || "unknown";
+  const toolKind = update.kind || ctx.toolCallIdToNameMap.get(toolCallId) || "unknown";
   let toolCallCountSincePrompt = ctx.toolCallCountSincePrompt;
+  const outputChunk = extractToolOutputChunk(update.content);
+  if (outputChunk) {
+    const nextOutput = appendToolOutput(ctx.toolCallOutputs.get(toolCallId), outputChunk);
+    ctx.toolCallOutputs.set(toolCallId, nextOutput);
+  }
   if (status === "in_progress" || status === "pending") {
     if (!ctx.activeToolCalls.has(toolCallId)) {
       toolCallCountSincePrompt++;
@@ -4950,15 +5064,17 @@ async function withRetry(operation, options) {
       return await operation();
     } catch (error) {
       lastError = normalizeAcpError(error);
-      if (attempt < options.maxAttempts) {
-        const delayMs = Math.min(
-          options.baseDelayMs * Math.pow(2, attempt - 1),
-          options.maxDelayMs
-        );
-        api.logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
-        options.onRetry?.(attempt, lastError);
-        await api.delay(delayMs);
+      const retryable = options.shouldRetry?.(lastError) ?? true;
+      if (!retryable || attempt >= options.maxAttempts) {
+        throw lastError;
       }
+      const delayMs = Math.min(
+        options.baseDelayMs * Math.pow(2, attempt - 1),
+        options.maxDelayMs
+      );
+      api.logger.debug(`[AcpBackend] ${options.operationName} failed (attempt ${attempt}/${options.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
+      options.onRetry?.(attempt, lastError);
+      await api.delay(delayMs);
     }
   }
   throw lastError;
@@ -4995,6 +5111,11 @@ function normalizeAcpError(error) {
   }
   return normalized;
 }
+function createAcpAbortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
 function enrichAcpError(error, stderrExcerpt) {
   const normalized = normalizeAcpError(error);
   if (!stderrExcerpt.trim()) {
@@ -5006,6 +5127,77 @@ function enrichAcpError(error, stderrExcerpt) {
   }
   return normalized;
 }
+class AcpProcessStartupError extends Error {
+  constructor(message, exitCode, signal) {
+    super(message);
+    this.exitCode = exitCode;
+    this.signal = signal;
+    this.name = "AcpProcessStartupError";
+  }
+}
+function createProcessStartupError(agentName, operationName, code, signal) {
+  if (code !== null) {
+    return new AcpProcessStartupError(
+      `${agentName} exited with code ${code} during ${operationName}`,
+      code,
+      signal
+    );
+  }
+  if (signal) {
+    return new AcpProcessStartupError(
+      `${agentName} exited due to signal ${signal} during ${operationName}`,
+      code,
+      signal
+    );
+  }
+  return new AcpProcessStartupError(
+    `${agentName} exited unexpectedly during ${operationName}`,
+    code,
+    signal
+  );
+}
+async function raceWithProcessExit(childProcess, operation, options) {
+  if (childProcess.exitCode !== null) {
+    throw createProcessStartupError(
+      options.agentName,
+      options.operationName,
+      childProcess.exitCode,
+      childProcess.signalCode ?? null
+    );
+  }
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      childProcess.off("error", handleError);
+      childProcess.off("exit", handleExit);
+    };
+    const settleResolve = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const settleReject = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      reject(normalizeAcpError(error));
+    };
+    const handleError = (error) => {
+      settleReject(error);
+    };
+    const handleExit = (code, signal) => {
+      settleReject(createProcessStartupError(options.agentName, options.operationName, code, signal));
+    };
+    childProcess.once("error", handleError);
+    childProcess.once("exit", handleExit);
+    operation.then(settleResolve, settleReject);
+  });
+}
 class AcpBackend {
   constructor(options) {
     this.options = options;
@@ -5021,6 +5213,8 @@ class AcpBackend {
   toolCallTimeouts = /* @__PURE__ */ new Map();
   /** Track tool call start times for performance monitoring */
   toolCallStartTimes = /* @__PURE__ */ new Map();
+  /** Track streamed tool output between ACP updates and final completion */
+  toolCallOutputs = /* @__PURE__ */ new Map();
   /** Pending permission requests that need response */
   pendingPermissions = /* @__PURE__ */ new Map();
   /** Map from permission request ID to real tool call ID for tracking */
@@ -5031,6 +5225,14 @@ class AcpBackend {
   toolCallCountSincePrompt = 0;
   /** Timeout for emitting 'idle' status after last message chunk */
   idleTimeout = null;
+  /** Promise resolver for waitForResponseComplete */
+  idleResolver = null;
+  /** Promise rejecter for waitForResponseComplete */
+  idleRejecter = null;
+  /** Completion signal captured before waitForResponseComplete is attached */
+  responseCompletionOutcome = null;
+  /** Whether the current prompt is still waiting for completion */
+  waitingForResponse = false;
   /** Transport handler for agent-specific behavior */
   transport;
   /** Keep a short rolling stderr buffer so startup failures can surface the real cause. */
@@ -5048,6 +5250,44 @@ class AcpBackend {
   getRecentStderrExcerpt() {
     return this.recentStderrLines.slice(-6).join("\n");
   }
+  clearIdleTimeoutState() {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+  }
+  clearToolCallTracking() {
+    this.activeToolCalls.clear();
+    for (const timeout of this.toolCallTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.toolCallTimeouts.clear();
+    this.toolCallStartTimes.clear();
+    this.toolCallIdToNameMap.clear();
+    this.toolCallOutputs.clear();
+    this.toolCallCountSincePrompt = 0;
+  }
+  resetResponseTrackingForNewPrompt() {
+    this.responseCompletionOutcome = null;
+    this.clearIdleTimeoutState();
+    this.clearToolCallTracking();
+  }
+  settleResponseWaiter(outcome) {
+    const hasActiveWaiter = Boolean(this.idleResolver || this.idleRejecter);
+    if (!this.waitingForResponse && !hasActiveWaiter) {
+      return;
+    }
+    if (!hasActiveWaiter) {
+      this.waitingForResponse = false;
+      this.responseCompletionOutcome = outcome;
+      return;
+    }
+    if (outcome.kind === "resolved") {
+      this.idleResolver?.();
+      return;
+    }
+    this.idleRejecter?.(outcome.error);
+  }
   onMessage(handler) {
     this.listeners.push(handler);
   }
@@ -5122,10 +5362,15 @@ class AcpBackend {
       });
       this.process.on("error", (err) => {
         api.logger.debug(`[AcpBackend] Process error:`, err);
+        this.settleResponseWaiter({ kind: "rejected", error: err });
         this.emit({ type: "status", status: "error", detail: err.message });
       });
       this.process.on("exit", (code, signal) => {
         if (!this.disposed && code !== 0 && code !== null) {
+          this.settleResponseWaiter({
+            kind: "rejected",
+            error: new Error(`ACP process exited with code ${code}${signal ? ` (${signal})` : ""}`)
+          });
           api.logger.debug(`[AcpBackend] Process exited with code ${code}, signal ${signal}`);
           this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
         }
@@ -5353,20 +5598,27 @@ class AcpBackend {
         async () => {
           let timeoutHandle = null;
           try {
-            const result = await Promise.race([
-              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);
-              })
-            ]);
+            const result = await raceWithProcessExit(
+              this.process,
+              Promise.race([
+                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);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "initialize"
+              }
+            );
             return result;
           } finally {
             if (timeoutHandle) {
@@ -5378,7 +5630,8 @@ class AcpBackend {
           operationName: "Initialize",
           maxAttempts: RETRY_CONFIG.maxAttempts,
           baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
       api.logger.debug(`[AcpBackend] Initialize completed`);
@@ -5397,20 +5650,27 @@ class AcpBackend {
         async () => {
           let timeoutHandle = null;
           try {
-            const result = await Promise.race([
-              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);
-              })
-            ]);
+            const result = await raceWithProcessExit(
+              this.process,
+              Promise.race([
+                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);
+                })
+              ]),
+              {
+                agentName: this.transport.agentName,
+                operationName: "new session"
+              }
+            );
             return result;
           } finally {
             if (timeoutHandle) {
@@ -5422,7 +5682,8 @@ class AcpBackend {
           operationName: "NewSession",
           maxAttempts: RETRY_CONFIG.maxAttempts,
           baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs
+          maxDelayMs: RETRY_CONFIG.maxDelayMs,
+          shouldRetry: (error) => !(error instanceof AcpProcessStartupError)
         }
       );
       this.acpSessionId = sessionResponse.sessionId;
@@ -5456,6 +5717,7 @@ class AcpBackend {
       toolCallStartTimes: this.toolCallStartTimes,
       toolCallTimeouts: this.toolCallTimeouts,
       toolCallIdToNameMap: this.toolCallIdToNameMap,
+      toolCallOutputs: this.toolCallOutputs,
       idleTimeout: this.idleTimeout,
       toolCallCountSincePrompt: this.toolCallCountSincePrompt,
       emit: (msg) => this.emit(msg),
@@ -5532,20 +5794,24 @@ class AcpBackend {
         this.emitUsageTelemetry(update, "acp-usage-update");
         continue;
       }
+      if (sessionUpdateType === "task_complete") {
+        this.emitUsageTelemetry(update.usage, "acp-session-usage");
+        ctx.clearIdleTimeout();
+        api.logger.debug("[AcpBackend] task_complete received, emitting idle status");
+        this.emitIdleStatus();
+        continue;
+      }
       const handledLegacy = handleLegacyMessageChunk(update, ctx).handled;
       const handledPlan = handlePlanUpdate(update, ctx).handled;
       const handledThinking = handleThinkingUpdate(update, ctx).handled;
       const handledUsage = this.emitUsageTelemetry(update.usage, "acp-session-usage");
       const updateTypeStr = sessionUpdateType;
-      const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call", "usage_update"];
+      const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call", "usage_update", "task_complete"];
       if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !handledLegacy && !handledPlan && !handledThinking && !handledUsage) {
         api.logger.debug(`[AcpBackend] Unhandled session update type: ${updateTypeStr}`, JSON.stringify(update, null, 2));
       }
     }
   }
-  // Promise resolver for waitForIdle - set when waiting for response to complete
-  idleResolver = null;
-  waitingForResponse = false;
   async sendPrompt(sessionId, prompt) {
     this.toolCallCountSincePrompt = 0;
     if (this.disposed) {
@@ -5554,6 +5820,7 @@ class AcpBackend {
     if (!this.connection || !this.acpSessionId) {
       throw new Error("Session not started");
     }
+    this.resetResponseTrackingForNewPrompt();
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
     try {
@@ -5572,7 +5839,6 @@ class AcpBackend {
       api.logger.debug("[AcpBackend] Prompt request sent to ACP connection");
     } catch (error) {
       api.logger.debug("[AcpBackend] Error sending prompt:", error);
-      this.waitingForResponse = false;
       let errorDetail;
       if (error instanceof Error) {
         errorDetail = error.message;
@@ -5586,6 +5852,10 @@ class AcpBackend {
         status: "error",
         detail: errorDetail
       });
+      this.settleResponseWaiter({
+        kind: "rejected",
+        error: error instanceof Error ? error : normalizeAcpError(error)
+      });
       throw error;
     }
   }
@@ -5594,21 +5864,38 @@ class AcpBackend {
    * Call this after sendPrompt to wait for Gemini to finish responding
    */
   async waitForResponseComplete(timeoutMs = 12e4) {
+    const pendingOutcome = this.responseCompletionOutcome;
+    if (pendingOutcome) {
+      this.responseCompletionOutcome = null;
+      if (pendingOutcome.kind === "rejected") {
+        throw pendingOutcome.error;
+      }
+      return;
+    }
     if (!this.waitingForResponse) {
       return;
     }
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.idleResolver = null;
+        this.idleRejecter = null;
         this.waitingForResponse = false;
         reject(new Error("Timeout waiting for response to complete"));
       }, timeoutMs);
       this.idleResolver = () => {
         clearTimeout(timeout);
         this.idleResolver = null;
+        this.idleRejecter = null;
         this.waitingForResponse = false;
         resolve();
       };
+      this.idleRejecter = (error) => {
+        clearTimeout(timeout);
+        this.idleResolver = null;
+        this.idleRejecter = null;
+        this.waitingForResponse = false;
+        reject(error);
+      };
     });
   }
   /**
@@ -5616,18 +5903,19 @@ class AcpBackend {
    */
   emitIdleStatus() {
     this.emit({ type: "status", status: "idle" });
-    if (this.idleResolver) {
-      api.logger.debug("[AcpBackend] Resolving idle waiter");
-      this.idleResolver();
-    }
+    this.settleResponseWaiter({ kind: "resolved" });
   }
   async cancel(sessionId) {
+    const cancelError = createAcpAbortError("Cancelled by user");
+    this.clearIdleTimeoutState();
+    this.clearToolCallTracking();
+    this.settleResponseWaiter({ kind: "rejected", error: cancelError });
+    this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
     if (!this.connection || !this.acpSessionId) {
       return;
     }
     try {
       await this.connection.cancel({ sessionId: this.acpSessionId });
-      this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
     } catch (error) {
       api.logger.debug("[AcpBackend] Error cancelling:", error);
     }
@@ -5655,6 +5943,10 @@ class AcpBackend {
     if (this.disposed) return;
     api.logger.debug("[AcpBackend] Disposing backend");
     this.disposed = true;
+    this.settleResponseWaiter({
+      kind: "rejected",
+      error: createAcpAbortError("ACP backend disposed")
+    });
     if (this.connection && this.acpSessionId) {
       try {
         await Promise.race([
@@ -5683,19 +5975,11 @@ class AcpBackend {
       });
       this.process = null;
     }
-    if (this.idleTimeout) {
-      clearTimeout(this.idleTimeout);
-      this.idleTimeout = null;
-    }
+    this.clearIdleTimeoutState();
     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.clearToolCallTracking();
     this.pendingPermissions.clear();
   }
 }
@@ -5930,6 +6214,7 @@ function registerGeminiAgent() {
   api.logger.debug("[Gemini] Registered with agent registry");
 }
 
+const DEFAULT_CODEX_ACP_NPX_PACKAGE = "@zed-industries/codex-acp@0.9.5";
 function readFirstEnv(...names) {
   for (const name of names) {
     const raw = process.env[name];
@@ -5984,6 +6269,10 @@ function readCodexAcpNpxMode() {
   }
   return "auto";
 }
+function readCodexAcpNpxPackage() {
+  const configured = readFirstEnv("HAPPY_CODEX_ACP_PACKAGE", "HAPPIER_CODEX_ACP_PACKAGE");
+  return configured || DEFAULT_CODEX_ACP_NPX_PACKAGE;
+}
 function isBinOnPath(baseName) {
   return resolveCommandOnPath(baseName) !== null;
 }
@@ -6049,7 +6338,7 @@ function resolveCodexAcpSpawn(options = {}) {
   }
   return {
     command: resolveNpxCommand(),
-    args: ["--prefer-offline", "-y", "@zed-industries/codex-acp", ...directArgs]
+    args: ["--prefer-offline", "-y", readCodexAcpNpxPackage(), ...directArgs]
   };
 }
 function validateCodexAcpSpawn(options = {}) {
@@ -6336,12 +6625,12 @@ async function ensureUnifiedDaemonStarted() {
 async function executeUnifiedProvider(opts) {
   const credentials = await ensureUnifiedRuntimePrerequisites(opts.credentials);
   if (opts.provider === "claude") {
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-IeRSC5qX.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-gHKFB1UG.cjs'); });
     await runClaude(credentials, opts.claudeOptions ?? {});
     return;
   }
   if (opts.provider === "codex") {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-WRmgSK6L.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-CdjzG1N7.cjs'); });
     await runCodex({
       credentials,
       startedBy: opts.startedBy,
@@ -6351,7 +6640,7 @@ async function executeUnifiedProvider(opts) {
     return;
   }
   if (opts.provider === "gemini") {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-qBh6zs5G.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DxjvRmOc.cjs'); });
     await runGemini({
       credentials,
       startedBy: opts.startedBy
@@ -6393,7 +6682,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-CdXv1zNF.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-D9-hmqVq.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -6571,8 +6860,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-PzKU0QCa.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-D9dIR956.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-D6Y0604_.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DaqnNHfl.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();