happy-imou-cloud 2.0.22 → 2.1.0

package/dist/{index-CqCEZDFi.cjs → index-BQmJ4NAa.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var api = require('./api-DP-RQUao.cjs');
-var persistence = require('./persistence-yVTbf_Ng.cjs');
+var api = require('./api-Bd-MnOS4.cjs');
+var persistence = require('./persistence-BL06LLVz.cjs');
 var z = require('zod');
 var fs$2 = require('fs/promises');
 var os$1 = require('os');
@@ -72,7 +72,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-CqCEZDFi.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-BQmJ4NAa.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();
@@ -695,7 +695,7 @@ function setupCleanupHandlers() {
   });
 }
 
-const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CqCEZDFi.cjs', document.baseURI).href))));
+const __dirname$2 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-BQmJ4NAa.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$2, "..");
   return path;
@@ -2541,16 +2541,36 @@ function createTrackedSessionFromRemoteIndexEntry(entry) {
     pid: entry.sessionIndex?.hostPid ?? 0
   };
 }
+async function archiveStaleRemoteSession(userScopedObserver, session) {
+  if (!userScopedObserver || !session.sessionIndex) {
+    api.logger.debug(
+      `[REMOTE SESSION INDEX] Stale remote session ${session.id} cannot be archived because user-scoped observer is unavailable`
+    );
+    return false;
+  }
+  const archived = userScopedObserver.syncSessionRuntimeIndex(session.id, {
+    ...session.sessionIndex,
+    lifecycleState: "archived"
+  }, {
+    markInactive: true
+  });
+  if (archived) {
+    api.logger.debug(`[REMOTE SESSION INDEX] Archived stale remote session ${session.id}`);
+  }
+  return archived;
+}
 async function recoverTrackedSessionsFromRemoteIndex({
   api: api$1,
   machineId,
   trackedSessionPids,
   trackSession,
+  userScopedObserver,
   lookupHappyProcessByPid = findHappyProcessByPid
 }) {
   const sessions = await api$1.listSessionsIndex();
   const alreadyTracked = new Set(trackedSessionPids);
   let recoveredCount = 0;
+  let archivedStaleCount = 0;
   let skippedStaleCount = 0;
   for (const session of sessions) {
     const sessionIndex = session.sessionIndex;
@@ -2579,7 +2599,12 @@ async function recoverTrackedSessionsFromRemoteIndex({
     }
     const sessionPidIsAlive = lookupResult !== null && !NON_SESSION_PROCESS_TYPES$1.has(lookupResult.type);
     if (!sessionPidIsAlive) {
-      skippedStaleCount++;
+      const archived = await archiveStaleRemoteSession(userScopedObserver, session);
+      if (archived) {
+        archivedStaleCount++;
+      } else {
+        skippedStaleCount++;
+      }
       continue;
     }
     trackSession(pid, createTrackedSessionFromRemoteIndexEntry(session));
@@ -2589,6 +2614,7 @@ async function recoverTrackedSessionsFromRemoteIndex({
   }
   return {
     recoveredCount,
+    archivedStaleCount,
     skippedStaleCount
   };
 }
@@ -3315,11 +3341,12 @@ async function startDaemon() {
         trackedSessionPids: pidToTrackedSession.keys(),
         trackSession: (pid, trackedSession) => {
           pidToTrackedSession.set(pid, trackedSession);
-        }
+        },
+        userScopedObserver
       });
-      if (recoveryResult.recoveredCount > 0 || recoveryResult.skippedStaleCount > 0) {
+      if (recoveryResult.recoveredCount > 0 || recoveryResult.archivedStaleCount > 0 || recoveryResult.skippedStaleCount > 0) {
         api.logger.debug(
-          `[DAEMON RUN] Remote session index recovery ${label} completed: recovered=${recoveryResult.recoveredCount}, skippedStale=${recoveryResult.skippedStaleCount}`
+          `[DAEMON RUN] Remote session index recovery ${label} completed: recovered=${recoveryResult.recoveredCount}, archivedStale=${recoveryResult.archivedStaleCount}, skippedStale=${recoveryResult.skippedStaleCount}`
         );
       }
     };
@@ -4840,10 +4867,10 @@ function truncateDisplayMessage(value, maxLength) {
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
   init: 6e4,
-  /** Default tool call timeout: 2 minutes */
-  toolCall: 12e4,
-  /** Think tool timeout: 30 seconds */
-  think: 3e4
+  /** Default tool call timeout: 10 minutes */
+  toolCall: 10 * 6e4,
+  /** Think tool timeout: 2 minutes */
+  think: 2 * 6e4
 };
 class DefaultTransport {
   agentName;
@@ -4920,7 +4947,7 @@ class DefaultTransport {
     return toolName;
   }
   getPostPromptNoUpdatesTimeoutMs() {
-    return 3e4;
+    return 2 * 6e4;
   }
 }
 
@@ -4930,11 +4957,11 @@ const GEMINI_TIMEOUTS = {
   /** Gemini ACP can swallow an initialize request sent too early after spawn */
   initDelay: 2500,
   /** Standard tool call timeout */
-  toolCall: 12e4,
+  toolCall: 10 * 6e4,
   /** Investigation tools (codebase_investigator) can run for a long time */
-  investigation: 6e5,
+  investigation: 30 * 6e4,
   /** Think tools are usually quick */
-  think: 3e4,
+  think: 2 * 6e4,
   /** Idle detection after last message chunk */
   idle: 500
 };
@@ -5131,6 +5158,21 @@ class GeminiTransport {
 }
 const geminiTransport = new GeminiTransport();
 
+const DEFAULT_CODEX_EXECUTE_TIMEOUT_MS = 30 * 6e4;
+function readPositiveIntegerEnv$1(name) {
+  const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
+  if (!raw) {
+    return null;
+  }
+  const value = Number(raw);
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+    return null;
+  }
+  return value;
+}
+function resolveCodexExecuteTimeoutMs() {
+  return readPositiveIntegerEnv$1("HAPPY_CODEX_EXECUTE_TIMEOUT_MS") ?? readPositiveIntegerEnv$1("HAPPIER_CODEX_EXECUTE_TIMEOUT_MS") ?? DEFAULT_CODEX_EXECUTE_TIMEOUT_MS;
+}
 class CodexTransport extends DefaultTransport {
   constructor() {
     super("codex");
@@ -5141,6 +5183,12 @@ class CodexTransport extends DefaultTransport {
   getIdleTimeout() {
     return 800;
   }
+  getToolCallTimeout(toolCallId, toolKind) {
+    if (toolKind === "execute") {
+      return resolveCodexExecuteTimeoutMs();
+    }
+    return super.getToolCallTimeout(toolCallId, toolKind);
+  }
 }
 new CodexTransport();
 
@@ -5171,7 +5219,7 @@ class CursorTransport extends DefaultTransport {
 const cursorTransport = new CursorTransport();
 
 const DEFAULT_IDLE_TIMEOUT_MS = 500;
-const DEFAULT_TOOL_CALL_TIMEOUT_MS = 12e4;
+const DEFAULT_TOOL_CALL_TIMEOUT_MS = 10 * 6e4;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_HEAD_BYTES = 2e3;
 const DEFAULT_TOOL_CALL_OUTPUT_PREVIEW_TAIL_BYTES = 4e3;
 function parseArgsFromContent(content) {
@@ -5431,41 +5479,14 @@ function startToolCall(toolCallId, toolKind, update, ctx, source) {
   }
   const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
   if (!ctx.toolCallTimeouts.has(toolCallId)) {
-    const timeout = setTimeout(() => {
-      const duration = formatDuration(ctx.toolCallStartTimes.get(toolCallId));
-      const timeoutLabel = formatToolCallTimeoutLimit(timeoutMs);
-      const timeoutDetail = `Tool call ${realToolName} timed out after ${timeoutLabel}`;
-      api.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${source}): ${toolCallId} (${toolKind}) after ${timeoutLabel} - Duration: ${duration}, failing current turn`);
-      ctx.activeToolCalls.delete(toolCallId);
-      ctx.toolCallStartTimes.delete(toolCallId);
-      ctx.toolCallTimeouts.delete(toolCallId);
-      ctx.clearIdleTimeout();
-      const streamedOutput = renderToolOutput(ctx.toolCallOutputs.get(toolCallId));
-      ctx.toolCallOutputs.delete(toolCallId);
-      ctx.emit({
-        type: "tool-result",
-        toolName: realToolName,
-        result: streamedOutput ? {
-          stdout: streamedOutput,
-          error: timeoutDetail,
-          status: "failed",
-          timedOut: true
-        } : {
-          error: timeoutDetail,
-          status: "failed",
-          timedOut: true
-        },
-        callId: toolCallId
-      });
-      ctx.emit({
-        type: "status",
-        status: "error",
-        detail: timeoutDetail
-      });
-      ctx.failPendingResponseWait(new Error(timeoutDetail));
-    }, timeoutMs);
-    ctx.toolCallTimeouts.set(toolCallId, timeout);
-    api.logger.debug(`[AcpBackend] \u23F1\uFE0F Set timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
+    ctx.armToolCallTimeout({
+      toolCallId,
+      toolKind,
+      toolName: realToolName,
+      timeoutMs,
+      source
+    });
+    api.logger.debug(`[AcpBackend] \u23F1\uFE0F Set no-progress timeout for ${toolCallId}: ${(timeoutMs / 1e3).toFixed(0)}s${isInvestigation ? " (investigation tool)" : ""}`);
   } else {
     api.logger.debug(`[AcpBackend] Timeout already set for ${toolCallId}, skipping`);
   }
@@ -5491,11 +5512,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
   const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
-  }
+  ctx.clearToolCallTimeout(toolCallId);
   const streamedOutput = renderToolOutput(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}`);
@@ -5534,10 +5551,8 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   }
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
+  const clearedTimeout = ctx.clearToolCallTimeout(toolCallId);
+  if (clearedTimeout) {
     api.logger.debug(`[AcpBackend] Cleared timeout for ${toolCallId} (tool call ${status})`);
   } else {
     api.logger.debug(`[AcpBackend] No timeout found for ${toolCallId} (tool call ${status}) - timeout may not have been set`);
@@ -5860,7 +5875,7 @@ const RETRY_CONFIG = {
   /** Maximum delay between retries in ms */
   maxDelayMs: 5e3
 };
-const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 3e4;
+const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS = 2 * 6e4;
 function readPositiveIntegerEnv(name) {
   const raw = typeof process.env[name] === "string" ? process.env[name].trim() : "";
   if (!raw) {
@@ -6169,6 +6184,7 @@ class AcpBackend {
   /** Track active tool calls to prevent duplicate events */
   activeToolCalls = /* @__PURE__ */ new Set();
   toolCallTimeouts = /* @__PURE__ */ new Map();
+  toolCallTimeoutSpecs = /* @__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 */
@@ -6193,6 +6209,12 @@ class AcpBackend {
   waitingForResponse = false;
   /** First fatal prompt-level error observed for the current turn */
   responseCompletionError = null;
+  /** Resettable no-progress timeout while waiting for a turn to finish */
+  responseWaitTimeout = null;
+  /** Current inactivity threshold used by waitForResponseComplete */
+  responseWaitTimeoutMs = null;
+  /** Timestamp of the last meaningful response progress for the current turn */
+  responseLastProgressAt = null;
   /** Fallback completion when prompt returns but the agent emits no session updates */
   postPromptCompletionIdleTimeout = null;
   /** Whether at least one session/update arrived after the current prompt */
@@ -6226,12 +6248,110 @@ class AcpBackend {
       this.postPromptCompletionIdleTimeout = null;
     }
   }
+  clearResponseWaitTimeout() {
+    if (this.responseWaitTimeout) {
+      clearTimeout(this.responseWaitTimeout);
+      this.responseWaitTimeout = null;
+    }
+  }
+  resetResponseWaitTracking() {
+    this.clearResponseWaitTimeout();
+    this.responseWaitTimeoutMs = null;
+    this.responseLastProgressAt = null;
+  }
+  armResponseWaitTimeout(timeoutMs) {
+    this.responseWaitTimeoutMs = timeoutMs;
+    this.clearResponseWaitTimeout();
+    const lastProgressAt = this.responseLastProgressAt ?? Date.now();
+    const elapsedMs = Math.max(0, Date.now() - lastProgressAt);
+    const remainingMs = Math.max(1, timeoutMs - elapsedMs);
+    this.responseWaitTimeout = setTimeout(() => {
+      this.responseWaitTimeout = null;
+      this.responseWaitTimeoutMs = null;
+      this.failPendingResponseWait(new Error("Timeout waiting for response to complete"));
+    }, remainingMs);
+  }
+  scheduleToolCallTimeout(toolCallId) {
+    const spec = this.toolCallTimeoutSpecs.get(toolCallId);
+    if (!spec) {
+      return;
+    }
+    const existing = this.toolCallTimeouts.get(toolCallId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timeout = setTimeout(() => {
+      const duration = formatDuration(this.toolCallStartTimes.get(toolCallId));
+      const timeoutLabel = formatToolCallTimeoutLimit(spec.timeoutMs);
+      const timeoutDetail = `Tool call ${spec.toolName} timed out after ${timeoutLabel}`;
+      api.logger.debug(`[AcpBackend] \u23F1\uFE0F Tool call TIMEOUT (from ${spec.source}): ${toolCallId} (${spec.toolKind}) after ${timeoutLabel} without progress - Duration: ${duration}, failing current turn`);
+      this.activeToolCalls.delete(toolCallId);
+      this.toolCallStartTimes.delete(toolCallId);
+      this.clearToolCallTimeout(toolCallId);
+      this.clearIdleTimeoutState();
+      const streamedOutput = renderToolOutput(this.toolCallOutputs.get(toolCallId));
+      this.toolCallOutputs.delete(toolCallId);
+      this.emit({
+        type: "tool-result",
+        toolName: spec.toolName,
+        result: streamedOutput ? {
+          stdout: streamedOutput,
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        } : {
+          error: timeoutDetail,
+          status: "failed",
+          timedOut: true
+        },
+        callId: toolCallId
+      });
+      this.emit({
+        type: "status",
+        status: "error",
+        detail: timeoutDetail
+      });
+      this.failPendingResponseWait(new Error(timeoutDetail));
+    }, spec.timeoutMs);
+    this.toolCallTimeouts.set(toolCallId, timeout);
+  }
+  armToolCallTimeout(spec) {
+    this.toolCallTimeoutSpecs.set(spec.toolCallId, spec);
+    this.scheduleToolCallTimeout(spec.toolCallId);
+  }
+  clearToolCallTimeout(toolCallId) {
+    const timeout = this.toolCallTimeouts.get(toolCallId);
+    const hadTimeout = Boolean(timeout);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.toolCallTimeouts.delete(toolCallId);
+    }
+    this.toolCallTimeoutSpecs.delete(toolCallId);
+    return hadTimeout;
+  }
+  refreshActiveToolCallTimeouts() {
+    for (const toolCallId of this.activeToolCalls) {
+      if (this.toolCallTimeoutSpecs.has(toolCallId)) {
+        this.scheduleToolCallTimeout(toolCallId);
+      }
+    }
+  }
+  markResponseProgress(opts = {}) {
+    this.responseLastProgressAt = Date.now();
+    if (opts.refreshToolTimeouts !== false) {
+      this.refreshActiveToolCallTimeouts();
+    }
+    if (this.waitingForResponse && this.responseWaitTimeoutMs != null) {
+      this.armResponseWaitTimeout(this.responseWaitTimeoutMs);
+    }
+  }
   clearToolCallTracking() {
     this.activeToolCalls.clear();
     for (const timeout of this.toolCallTimeouts.values()) {
       clearTimeout(timeout);
     }
     this.toolCallTimeouts.clear();
+    this.toolCallTimeoutSpecs.clear();
     this.toolCallStartTimes.clear();
     this.toolCallIdToNameMap.clear();
     this.toolCallOutputs.clear();
@@ -6241,6 +6361,7 @@ class AcpBackend {
     this.responseCompletionOutcome = null;
     this.responseCompletionError = null;
     this.sawSessionUpdateSincePrompt = false;
+    this.resetResponseWaitTracking();
     this.clearIdleTimeoutState();
     this.clearPostPromptCompletionIdleTimeout();
     this.clearToolCallTracking();
@@ -6252,6 +6373,7 @@ class AcpBackend {
     this.responseCompletionError = error;
     this.responseCompletionOutcome = null;
     this.waitingForResponse = false;
+    this.resetResponseWaitTracking();
     this.clearPostPromptCompletionIdleTimeout();
     if (this.idleRejecter) {
       this.idleRejecter(error);
@@ -6261,6 +6383,7 @@ class AcpBackend {
   }
   settleResponseWaiter(outcome) {
     const hasActiveWaiter = Boolean(this.idleResolver || this.idleRejecter);
+    this.resetResponseWaitTracking();
     if (!this.waitingForResponse && !hasActiveWaiter) {
       return;
     }
@@ -6732,6 +6855,8 @@ ${recentStderrExcerpt}`);
       emit: (msg) => this.emit(msg),
       emitIdleStatus: () => this.emitIdleStatus(),
       failPendingResponseWait: (error) => this.failPendingResponseWait(error),
+      armToolCallTimeout: (spec) => this.armToolCallTimeout(spec),
+      clearToolCallTimeout: (toolCallId) => this.clearToolCallTimeout(toolCallId),
       clearIdleTimeout: () => {
         if (this.idleTimeout) {
           clearTimeout(this.idleTimeout);
@@ -6772,6 +6897,7 @@ ${recentStderrExcerpt}`);
     this.clearPostPromptCompletionIdleTimeout();
     for (const update of updates) {
       const sessionUpdateType = update.sessionUpdate;
+      this.markResponseProgress();
       if (sessionUpdateType !== "agent_message_chunk" && sessionUpdateType !== "tool_call_update") {
         api.logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
           sessionUpdate: sessionUpdateType,
@@ -6835,6 +6961,7 @@ ${recentStderrExcerpt}`);
     this.resetResponseTrackingForNewPrompt();
     this.emit({ type: "status", status: "running" });
     this.waitingForResponse = true;
+    this.markResponseProgress({ refreshToolTimeouts: false });
     try {
       api.logger.debug(`[AcpBackend] Sending prompt (length: ${prompt.length}): ${prompt.substring(0, 100)}...`);
       api.logger.debug(`[AcpBackend] Full prompt: ${prompt}`);
@@ -6895,7 +7022,7 @@ ${recentStderrExcerpt}`);
    * Wait for the response to complete (idle status after all chunks received)
    * Call this after sendPrompt to wait for Gemini to finish responding
    */
-  async waitForResponseComplete(timeoutMs = 12e4) {
+  async waitForResponseComplete(timeoutMs = 10 * 6e4) {
     if (this.responseCompletionError) {
       throw this.responseCompletionError;
     }
@@ -6911,26 +7038,19 @@ ${recentStderrExcerpt}`);
       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);
       };
+      this.armResponseWaitTimeout(timeoutMs);
     });
   }
   /**
@@ -7745,7 +7865,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CqCEZDFi.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-BQmJ4NAa.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -8416,7 +8536,7 @@ class ClaudeCodeBackend {
       api.logger.debug("[ClaudeRuntimeBackend] Error interrupting Claude query:", error);
     }
   }
-  async waitForResponseComplete(timeoutMs = 12e4) {
+  async waitForResponseComplete(timeoutMs = 10 * 6e4) {
     if (this.responseCompletionOutcome) {
       const outcome = this.responseCompletionOutcome;
       if (outcome.kind === "rejected") {
@@ -8996,11 +9116,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-BuI6OOEv.cjs'); });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-D2ZEXue8.cjs'); });
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-1jTTmCvq.cjs'); });
+    const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-Dz_1ho8d.cjs'); });
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9009,7 +9129,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-1gJRE8oT.cjs'); });
+    const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-Dfu6LltX.cjs'); });
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9085,7 +9205,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-BZphfJrt.cjs'); });
+      const { renderRuntimeProviders } = await Promise.resolve().then(function () { return require('./command-DoDmHNxR.cjs'); });
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9263,8 +9383,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-yVTbf_Ng.cjs'); });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-DP-RQUao.cjs'); }).then(function (n) { return n.api; });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-BL06LLVz.cjs'); });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./api-Bd-MnOS4.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();