happy-imou-cloud 2.1.2 → 2.1.4

package/dist/{index-Des7I5WX.mjs → index-D72RMo5Z.mjs}

@@ -1,6 +1,6 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
-import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, q as decodeBase64, r as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-Cxifhw5r.mjs';
-import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-6d4U4Sh8.mjs';
+import { l as logger, e as encodeBase64, c as configuration, k as buildAuthenticatedHeaders, S as SigningBootstrapRequiredError, m as SIGNING_BOOTSTRAP_REQUIRED_MESSAGE, n as encodeBase64Url, h as delay, o as buildClientHeaders, q as decodeBase64, r as HAPPY_CLOUD_DAEMON_PORT, p as packageJson, A as ApiClient, t as HeadTailPreviewBuffer, u as getLatestDaemonLog } from './api-l8X03rs-.mjs';
+import { writeCredentialsLegacy, writeCredentialsDataKey, readCredentials, readSettings, updateSettings, readDaemonState, clearDaemonState, acquireDaemonLock, writeDaemonState, releaseDaemonLock, validateProfileForAgent, getProfileEnvironmentVariables, clearCredentials, clearMachineId } from './persistence-CyFjFOlN.mjs';
 import { z } from 'zod';
 import fs, { writeFile as writeFile$1, rename, unlink as unlink$1 } from 'fs/promises';
 import os, { homedir } from 'os';
@@ -4842,6 +4842,296 @@ function truncateDisplayMessage(value, maxLength) {
   return `${formatted.substring(0, maxLength)}...`;
 }
 
+const DEFAULT_RESPONSE_WAIT_TIMEOUT_MS = 10 * 6e4;
+const DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS$1 = 2 * 6e4;
+const TIMEOUT_FAST_WORDS = ["fast", "quick", "low", "minimal", "light", "shallow", "short", "economy"];
+const TIMEOUT_BALANCED_WORDS = ["balanced", "medium", "normal", "default", "standard", "auto"];
+const TIMEOUT_DEEP_WORDS = ["deep", "high", "max", "maximum", "extended", "long", "intense", "thorough"];
+const CACHE_OFF_WORDS = ["off", "none", "disabled", "disable", "false"];
+const CACHE_DEFAULT_WORDS = ["default", "auto", "balanced", "standard", "normal"];
+const CACHE_AGGRESSIVE_WORDS = ["aggressive", "enabled", "enable", "on", "high", "max", "maximum", "full", "always"];
+const TIMEOUT_OPTION_HINTS = ["timeout", "latency", "speed", "effort", "thought", "thinking", "reasoning", "reason", "depth"];
+const CACHE_OPTION_HINTS = ["cache", "caching", "cached", "reuse", "replay"];
+function normalizeAgentKey(agentName) {
+  return agentName.replace(/[^a-z0-9]+/gi, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function readEnvValue(env, names) {
+  for (const name of names) {
+    const raw = env[name]?.trim();
+    if (raw) {
+      return raw;
+    }
+  }
+  return null;
+}
+function readTimeoutProfile(agentName, env) {
+  const agentKey = normalizeAgentKey(agentName);
+  const raw = readEnvValue(env, [
+    `HAPPY_${agentKey}_ACP_TIMEOUT_PROFILE`,
+    `HAPPIER_${agentKey}_ACP_TIMEOUT_PROFILE`,
+    "HAPPY_ACP_TIMEOUT_PROFILE",
+    "HAPPIER_ACP_TIMEOUT_PROFILE"
+  ])?.toLowerCase();
+  if (!raw) {
+    return { value: "balanced", source: "default" };
+  }
+  if (["fast", "quick", "low", "minimal", "light", "shallow"].includes(raw)) {
+    return { value: "fast", source: "env" };
+  }
+  if (["deep", "high", "max", "maximum", "extended", "long", "thorough"].includes(raw)) {
+    return { value: "deep", source: "env" };
+  }
+  return { value: "balanced", source: "env" };
+}
+function readCachePolicy(agentName, env) {
+  const agentKey = normalizeAgentKey(agentName);
+  const raw = readEnvValue(env, [
+    `HAPPY_${agentKey}_ACP_CACHE_POLICY`,
+    `HAPPIER_${agentKey}_ACP_CACHE_POLICY`,
+    "HAPPY_ACP_CACHE_POLICY",
+    "HAPPIER_ACP_CACHE_POLICY"
+  ])?.toLowerCase();
+  if (!raw) {
+    return { value: "default", source: "default" };
+  }
+  if (["off", "none", "disabled", "disable", "false"].includes(raw)) {
+    return { value: "off", source: "env" };
+  }
+  if (["aggressive", "enabled", "enable", "on", "high", "max", "maximum", "full", "always"].includes(raw)) {
+    return { value: "aggressive", source: "env" };
+  }
+  return { value: "default", source: "env" };
+}
+function normalizeText(value) {
+  return (value ?? "").toLowerCase();
+}
+function tokenize(...parts) {
+  return parts.map((part) => normalizeText(part)).join(" ").split(/[^a-z0-9]+/g).filter(Boolean);
+}
+function includesAny(tokens, expected) {
+  return expected.some((candidate) => tokens.includes(candidate));
+}
+function isSelectSessionConfigOption(option) {
+  return option.type === "select";
+}
+function isBooleanSessionConfigOption(option) {
+  return option.type === "boolean";
+}
+function flattenSelectOptions(options) {
+  const flattened = [];
+  for (const option of options) {
+    if (Array.isArray(option.options)) {
+      flattened.push(...option.options);
+      continue;
+    }
+    flattened.push(option);
+  }
+  return flattened;
+}
+function classifyConfigOption(option) {
+  const tokens = tokenize(option.id, option.name, option.description, option.category);
+  if (option.category === "thought_level" || includesAny(tokens, TIMEOUT_OPTION_HINTS)) {
+    return "timeout";
+  }
+  if (includesAny(tokens, CACHE_OPTION_HINTS)) {
+    return "cache";
+  }
+  return null;
+}
+function scoreTimeoutChoice(option, profile, currentValue) {
+  const tokens = tokenize(option.value, option.name, option.description);
+  let score = 0;
+  if (profile === "fast" && includesAny(tokens, TIMEOUT_FAST_WORDS)) {
+    score += 4;
+  }
+  if (profile === "balanced" && includesAny(tokens, TIMEOUT_BALANCED_WORDS)) {
+    score += 4;
+  }
+  if (profile === "deep" && includesAny(tokens, TIMEOUT_DEEP_WORDS)) {
+    score += 4;
+  }
+  if (profile === "balanced" && option.value === currentValue) {
+    score += 2;
+  }
+  return score;
+}
+function scoreCacheChoice(option, policy, currentValue) {
+  const tokens = tokenize(option.value, option.name, option.description);
+  let score = 0;
+  if (policy === "off" && includesAny(tokens, CACHE_OFF_WORDS)) {
+    score += 4;
+  }
+  if (policy === "default" && includesAny(tokens, CACHE_DEFAULT_WORDS)) {
+    score += 4;
+  }
+  if (policy === "aggressive" && includesAny(tokens, CACHE_AGGRESSIVE_WORDS)) {
+    score += 4;
+  }
+  if (policy === "default" && option.value === currentValue) {
+    score += 2;
+  }
+  return score;
+}
+function chooseTimeoutValue(option, profile) {
+  if (!isSelectSessionConfigOption(option)) {
+    return null;
+  }
+  const candidates = flattenSelectOptions(option.options);
+  let best = null;
+  for (const candidate of candidates) {
+    const score = scoreTimeoutChoice(candidate, profile, option.currentValue);
+    if (score <= 0) {
+      continue;
+    }
+    if (!best || score > best.score) {
+      best = { value: candidate.value, score };
+    }
+  }
+  return best?.value ?? null;
+}
+function chooseCacheValue(option, policy) {
+  if (isBooleanSessionConfigOption(option)) {
+    if (policy === "off") {
+      return false;
+    }
+    if (policy === "aggressive") {
+      return true;
+    }
+    return null;
+  }
+  if (!isSelectSessionConfigOption(option)) {
+    return null;
+  }
+  const candidates = flattenSelectOptions(option.options);
+  let best = null;
+  for (const candidate of candidates) {
+    const score = scoreCacheChoice(candidate, policy, option.currentValue);
+    if (score <= 0) {
+      continue;
+    }
+    if (!best || score > best.score) {
+      best = { value: candidate.value, score };
+    }
+  }
+  return best?.value ?? null;
+}
+function buildSetSessionConfigOptionRequest(options) {
+  if (typeof options.value === "boolean") {
+    return {
+      sessionId: options.sessionId,
+      configId: options.configId,
+      type: "boolean",
+      value: options.value
+    };
+  }
+  return {
+    sessionId: options.sessionId,
+    configId: options.configId,
+    value: options.value
+  };
+}
+function resolveAcpSessionPreferences(options) {
+  const mergedEnv = {
+    ...process.env,
+    ...options.env ?? {}
+  };
+  const timeout = readTimeoutProfile(options.agentName, mergedEnv);
+  const cache = readCachePolicy(options.agentName, mergedEnv);
+  return {
+    agentName: options.agentName,
+    timeoutProfile: timeout.value,
+    timeoutSource: timeout.source,
+    cachePolicy: cache.value,
+    cacheSource: cache.source
+  };
+}
+function scaleAcpTimeoutMs(baseMs, kind, profile) {
+  if (profile === "balanced") {
+    return baseMs;
+  }
+  const multipliers = profile === "fast" ? {
+    init: 0.75,
+    tool: 0.75,
+    investigation: 0.75,
+    think: 0.5,
+    execute: 0.75
+  } : {
+    init: 1.5,
+    tool: 1.5,
+    investigation: 1.5,
+    think: 2,
+    execute: 1.5
+  };
+  const minimums = {
+    init: 15e3,
+    tool: 6e4,
+    investigation: 5 * 6e4,
+    think: 15e3,
+    execute: 2 * 6e4
+  };
+  return Math.max(minimums[kind], Math.round(baseMs * multipliers[kind]));
+}
+function resolveAcpResponseWaitTimeoutMs(profile) {
+  if (profile === "fast") {
+    return 5 * 6e4;
+  }
+  if (profile === "deep") {
+    return 20 * 6e4;
+  }
+  return DEFAULT_RESPONSE_WAIT_TIMEOUT_MS;
+}
+function resolveAcpPostPromptNoUpdatesTimeoutMs(baseMs, profile) {
+  if (profile === "fast") {
+    return Math.max(3e4, Math.min(baseMs, 45e3));
+  }
+  if (profile === "deep") {
+    return Math.max(baseMs, 4 * 6e4);
+  }
+  return baseMs || DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS$1;
+}
+function buildAcpSessionConfigPresetPlan(options) {
+  const plan = [];
+  for (const option of options.configOptions ?? []) {
+    const kind = classifyConfigOption(option);
+    if (kind === "timeout" && options.preferences.timeoutSource === "env") {
+      const targetValue = chooseTimeoutValue(option, options.preferences.timeoutProfile);
+      if (targetValue && targetValue !== option.currentValue) {
+        plan.push({
+          kind,
+          optionId: option.id,
+          optionName: option.name,
+          currentValue: option.currentValue,
+          targetValue,
+          request: buildSetSessionConfigOptionRequest({
+            sessionId: options.sessionId,
+            configId: option.id,
+            value: targetValue
+          })
+        });
+      }
+      continue;
+    }
+    if (kind === "cache" && options.preferences.cacheSource === "env") {
+      const targetValue = chooseCacheValue(option, options.preferences.cachePolicy);
+      if (targetValue && targetValue !== option.currentValue) {
+        plan.push({
+          kind,
+          optionId: option.id,
+          optionName: option.name,
+          currentValue: option.currentValue,
+          targetValue,
+          request: buildSetSessionConfigOptionRequest({
+            sessionId: options.sessionId,
+            configId: option.id,
+            value: targetValue
+          })
+        });
+      }
+    }
+  }
+  return plan;
+}
+
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */
   init: 6e4,
@@ -4855,11 +5145,14 @@ class DefaultTransport {
   constructor(agentName = "generic-acp") {
     this.agentName = agentName;
   }
+  getTimeoutProfile() {
+    return resolveAcpSessionPreferences({ agentName: this.agentName }).timeoutProfile;
+  }
   /**
    * Default init timeout: 60 seconds
    */
   getInitTimeout() {
-    return DEFAULT_TIMEOUTS.init;
+    return scaleAcpTimeoutMs(DEFAULT_TIMEOUTS.init, "init", this.getTimeoutProfile());
   }
   getInitDelayMs() {
     return 0;
@@ -4908,9 +5201,9 @@ class DefaultTransport {
    */
   getToolCallTimeout(_toolCallId, toolKind) {
     if (toolKind === "think") {
-      return DEFAULT_TIMEOUTS.think;
+      return scaleAcpTimeoutMs(DEFAULT_TIMEOUTS.think, "think", this.getTimeoutProfile());
     }
-    return DEFAULT_TIMEOUTS.toolCall;
+    return scaleAcpTimeoutMs(DEFAULT_TIMEOUTS.toolCall, "tool", this.getTimeoutProfile());
   }
   /**
    * Default: no tool name extraction (return null)
@@ -4925,7 +5218,7 @@ class DefaultTransport {
     return toolName;
   }
   getPostPromptNoUpdatesTimeoutMs() {
-    return 2 * 6e4;
+    return resolveAcpPostPromptNoUpdatesTimeoutMs(2 * 6e4, this.getTimeoutProfile());
   }
 }
 
@@ -4962,11 +5255,14 @@ const AVAILABLE_MODELS = [
 ];
 class GeminiTransport {
   agentName = "gemini";
+  getTimeoutProfile() {
+    return resolveAcpSessionPreferences({ agentName: this.agentName }).timeoutProfile;
+  }
   /**
    * Gemini CLI needs 2 minutes for first start (model download, warm-up)
    */
   getInitTimeout() {
-    return GEMINI_TIMEOUTS.init;
+    return scaleAcpTimeoutMs(GEMINI_TIMEOUTS.init, "init", this.getTimeoutProfile());
   }
   getInitDelayMs() {
     return GEMINI_TIMEOUTS.initDelay;
@@ -5049,12 +5345,12 @@ class GeminiTransport {
    */
   getToolCallTimeout(toolCallId, toolKind) {
     if (this.isInvestigationTool(toolCallId, toolKind)) {
-      return GEMINI_TIMEOUTS.investigation;
+      return scaleAcpTimeoutMs(GEMINI_TIMEOUTS.investigation, "investigation", this.getTimeoutProfile());
     }
     if (toolKind === "think") {
-      return GEMINI_TIMEOUTS.think;
+      return scaleAcpTimeoutMs(GEMINI_TIMEOUTS.think, "think", this.getTimeoutProfile());
     }
-    return GEMINI_TIMEOUTS.toolCall;
+    return scaleAcpTimeoutMs(GEMINI_TIMEOUTS.toolCall, "tool", this.getTimeoutProfile());
   }
   /**
    * Get idle detection timeout
@@ -5148,22 +5444,20 @@ function readPositiveIntegerEnv$1(name) {
   }
   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");
   }
   getInitTimeout() {
-    return 3e4;
+    return scaleAcpTimeoutMs(3e4, "init", this.getTimeoutProfile());
   }
   getIdleTimeout() {
     return 800;
   }
   getToolCallTimeout(toolCallId, toolKind) {
     if (toolKind === "execute") {
-      return resolveCodexExecuteTimeoutMs();
+      const explicit = readPositiveIntegerEnv$1("HAPPY_CODEX_EXECUTE_TIMEOUT_MS") ?? readPositiveIntegerEnv$1("HAPPIER_CODEX_EXECUTE_TIMEOUT_MS");
+      return explicit ?? scaleAcpTimeoutMs(DEFAULT_CODEX_EXECUTE_TIMEOUT_MS, "execute", this.getTimeoutProfile());
     }
     return super.getToolCallTimeout(toolCallId, toolKind);
   }
@@ -5175,7 +5469,7 @@ class ClaudeTransport extends DefaultTransport {
     super("claude");
   }
   getInitTimeout() {
-    return 15e3;
+    return scaleAcpTimeoutMs(15e3, "init", this.getTimeoutProfile());
   }
   getIdleTimeout() {
     return 600;
@@ -5188,7 +5482,7 @@ class CursorTransport extends DefaultTransport {
     super("cursor");
   }
   getInitTimeout() {
-    return 2e4;
+    return scaleAcpTimeoutMs(2e4, "init", this.getTimeoutProfile());
   }
   getIdleTimeout() {
     return 700;
@@ -5335,6 +5629,9 @@ function extractToolOutputChunk(content) {
   const formatted = formatDisplayMessage(content);
   return formatted.length > 0 ? formatted : null;
 }
+function hasVisibleToolCallProgress(content) {
+  return extractToolOutputChunk(content) !== null;
+}
 function mergeStreamedOutputWithResult(content, streamedOutput) {
   if (!streamedOutput || streamedOutput.length === 0) {
     return content;
@@ -5866,14 +6163,14 @@ function readPositiveIntegerEnv(name) {
   return value;
 }
 function resolvePostPromptNoUpdatesTimeoutMs(transport) {
-  const transportValue = transport.getPostPromptNoUpdatesTimeoutMs?.();
-  if (typeof transportValue === "number" && Number.isFinite(transportValue) && transportValue > 0) {
-    return Math.trunc(transportValue);
-  }
   const envValue = readPositiveIntegerEnv("HAPPY_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS");
   if (envValue != null) {
     return envValue;
   }
+  const transportValue = transport.getPostPromptNoUpdatesTimeoutMs?.();
+  if (typeof transportValue === "number" && Number.isFinite(transportValue) && transportValue > 0) {
+    return Math.trunc(transportValue);
+  }
   return DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS;
 }
 function getSessionUpdates(params) {
@@ -5890,6 +6187,15 @@ function getSessionUpdates(params) {
 function asNonNegativeFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 }
+function shouldRefreshProgressForToolCallUpdate(update, wasToolCallActive, isToolCallActive) {
+  if (!wasToolCallActive && isToolCallActive) {
+    return true;
+  }
+  if (update.status === "completed" || update.status === "failed" || update.status === "cancelled") {
+    return true;
+  }
+  return hasVisibleToolCallProgress(update.content);
+}
 function extractUsageTokens(record) {
   const used = asNonNegativeFiniteNumber(record.used);
   const size = asNonNegativeFiniteNumber(record.size);
@@ -6153,6 +6459,10 @@ class AcpBackend {
   constructor(options) {
     this.options = options;
     this.transport = options.transportHandler ?? new DefaultTransport(options.agentName);
+    this.sessionPreferences = resolveAcpSessionPreferences({
+      agentName: options.agentName,
+      env: options.env
+    });
   }
   listeners = [];
   process = null;
@@ -6199,6 +6509,8 @@ class AcpBackend {
   sawSessionUpdateSincePrompt = false;
   /** Transport handler for agent-specific behavior */
   transport;
+  sessionPreferences;
+  sessionConfigOptions = null;
   /** Keep a short rolling stderr buffer so startup failures can surface the real cause. */
   recentStderrLines = [];
   recordRecentStderr(text) {
@@ -6214,6 +6526,60 @@ class AcpBackend {
   getRecentStderrExcerpt() {
     return this.recentStderrLines.slice(-6).join("\n");
   }
+  updateSessionConfigOptions(configOptions) {
+    this.sessionConfigOptions = Array.isArray(configOptions) ? configOptions : null;
+  }
+  syncSessionConfigOptionsFromUpdate(update) {
+    const configOptions = update.configOptions;
+    if (!Array.isArray(configOptions)) {
+      return false;
+    }
+    this.updateSessionConfigOptions(configOptions);
+    return true;
+  }
+  async applySessionConfigPresets() {
+    if (!this.connection || !this.acpSessionId) {
+      return;
+    }
+    const presetPlan = buildAcpSessionConfigPresetPlan({
+      sessionId: this.acpSessionId,
+      configOptions: this.sessionConfigOptions,
+      preferences: this.sessionPreferences
+    });
+    if (presetPlan.length === 0) {
+      return;
+    }
+    logger.debug(
+      `[AcpBackend] Applying ${presetPlan.length} ACP session config preset(s) for ${this.sessionPreferences.agentName}`
+    );
+    for (const preset of presetPlan) {
+      try {
+        logger.debug(
+          `[AcpBackend] Setting ACP session config ${preset.optionId} from ${String(preset.currentValue)} to ${String(preset.targetValue)}`
+        );
+        const response = await this.connection.setSessionConfigOption(preset.request);
+        this.updateSessionConfigOptions(response.configOptions);
+      } catch (error) {
+        logger.warn(
+          `[AcpBackend] Failed to apply ACP session config preset ${preset.optionId}:`,
+          error
+        );
+      }
+    }
+  }
+  getPostPromptNoUpdatesTimeoutMs() {
+    const explicitTimeout = readPositiveIntegerEnv("HAPPY_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS") ?? readPositiveIntegerEnv("HAPPIER_ACP_POST_PROMPT_NO_UPDATES_TIMEOUT_MS");
+    if (explicitTimeout != null) {
+      return explicitTimeout;
+    }
+    if (this.sessionPreferences.timeoutSource === "env") {
+      return resolveAcpPostPromptNoUpdatesTimeoutMs(
+        DEFAULT_POST_PROMPT_NO_UPDATES_TIMEOUT_MS,
+        this.sessionPreferences.timeoutProfile
+      );
+    }
+    return resolvePostPromptNoUpdatesTimeoutMs(this.transport);
+  }
   clearIdleTimeoutState() {
     if (this.idleTimeout) {
       clearTimeout(this.idleTimeout);
@@ -6787,7 +7153,9 @@ ${recentStderrExcerpt}`);
         }
       );
       this.acpSessionId = sessionResponse.sessionId;
+      this.updateSessionConfigOptions(sessionResponse.configOptions);
       logger.debug(`[AcpBackend] Session created: ${this.acpSessionId}`);
+      await this.applySessionConfigPresets();
       this.emitIdleStatus();
       if (initialPrompt) {
         this.sendPrompt(sessionId, initialPrompt).catch((error) => {
@@ -6875,7 +7243,6 @@ ${recentStderrExcerpt}`);
     this.clearPostPromptCompletionIdleTimeout();
     for (const update of updates) {
       const sessionUpdateType = update.sessionUpdate;
-      this.markResponseProgress();
       if (sessionUpdateType !== "agent_message_chunk" && sessionUpdateType !== "tool_call_update") {
         logger.debug(`[AcpBackend] Received session update: ${sessionUpdateType}`, JSON.stringify({
           sessionUpdate: sessionUpdateType,
@@ -6887,8 +7254,12 @@ ${recentStderrExcerpt}`);
         }, null, 2));
       }
       const ctx = this.createHandlerContext();
+      const toolCallId = update.toolCallId;
+      const wasToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
       if (sessionUpdateType === "agent_message_chunk") {
-        handleAgentMessageChunk(update, ctx);
+        if (handleAgentMessageChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "tool_call_update") {
@@ -6896,20 +7267,36 @@ ${recentStderrExcerpt}`);
         if (result.toolCallCountSincePrompt !== void 0) {
           this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
         }
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (shouldRefreshProgressForToolCallUpdate(update, wasToolCallActive, isToolCallActive)) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "agent_thought_chunk") {
-        handleAgentThoughtChunk(update, ctx);
+        if (handleAgentThoughtChunk(update, ctx).handled) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "tool_call") {
-        handleToolCall(update, ctx);
+        const result = handleToolCall(update, ctx);
+        const isToolCallActive = typeof toolCallId === "string" && this.activeToolCalls.has(toolCallId);
+        if (result.handled && !wasToolCallActive && isToolCallActive) {
+          this.markResponseProgress();
+        }
         continue;
       }
       if (sessionUpdateType === "usage_update") {
         this.emitUsageTelemetry(update, "acp-usage-update");
         continue;
       }
+      if (sessionUpdateType === "config_option_update") {
+        if (this.syncSessionConfigOptionsFromUpdate(update)) {
+          this.markResponseProgress({ refreshToolTimeouts: false });
+        }
+        continue;
+      }
       if (sessionUpdateType === "task_complete") {
         this.emitUsageTelemetry(update.usage, "acp-session-usage");
         ctx.clearIdleTimeout();
@@ -6921,8 +7308,19 @@ ${recentStderrExcerpt}`);
       const handledPlan = handlePlanUpdate(update, ctx).handled;
       const handledThinking = handleThinkingUpdate(update, ctx).handled;
       const handledUsage = this.emitUsageTelemetry(update.usage, "acp-session-usage");
+      if (handledLegacy || handledPlan || handledThinking) {
+        this.markResponseProgress();
+      }
       const updateTypeStr = sessionUpdateType;
-      const handledTypes = ["agent_message_chunk", "tool_call_update", "agent_thought_chunk", "tool_call", "usage_update", "task_complete"];
+      const handledTypes = [
+        "agent_message_chunk",
+        "tool_call_update",
+        "agent_thought_chunk",
+        "tool_call",
+        "usage_update",
+        "config_option_update",
+        "task_complete"
+      ];
       if (updateTypeStr && !handledTypes.includes(updateTypeStr) && !handledLegacy && !handledPlan && !handledThinking && !handledUsage) {
         logger.debug(`[AcpBackend] Unhandled session update type: ${updateTypeStr}`, JSON.stringify(update, null, 2));
       }
@@ -6955,7 +7353,7 @@ ${recentStderrExcerpt}`);
       await this.connection.prompt(promptRequest);
       logger.debug("[AcpBackend] Prompt request sent to ACP connection");
       if (this.waitingForResponse && this.activeToolCalls.size === 0 && this.sawSessionUpdateSincePrompt === false) {
-        const noUpdatesTimeoutMs = resolvePostPromptNoUpdatesTimeoutMs(this.transport);
+        const noUpdatesTimeoutMs = this.getPostPromptNoUpdatesTimeoutMs();
         this.postPromptCompletionIdleTimeout = setTimeout(() => {
           this.postPromptCompletionIdleTimeout = null;
           if (this.responseCompletionError || !this.waitingForResponse) {
@@ -7000,7 +7398,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 = 10 * 6e4) {
+  async waitForResponseComplete(timeoutMs) {
     if (this.responseCompletionError) {
       throw this.responseCompletionError;
     }
@@ -7015,6 +7413,7 @@ ${recentStderrExcerpt}`);
     if (!this.waitingForResponse) {
       return;
     }
+    const effectiveTimeoutMs = timeoutMs ?? resolveAcpResponseWaitTimeoutMs(this.sessionPreferences.timeoutProfile);
     return new Promise((resolve, reject) => {
       this.idleResolver = () => {
         this.idleResolver = null;
@@ -7028,7 +7427,7 @@ ${recentStderrExcerpt}`);
         this.waitingForResponse = false;
         reject(error);
       };
-      this.armResponseWaitTimeout(timeoutMs);
+      this.armResponseWaitTimeout(effectiveTimeoutMs);
     });
   }
   /**
@@ -7107,6 +7506,7 @@ ${recentStderrExcerpt}`);
     this.listeners = [];
     this.connection = null;
     this.acpSessionId = null;
+    this.sessionConfigOptions = null;
     this.clearToolCallTracking();
     this.pendingPermissions.clear();
   }
@@ -9094,11 +9494,11 @@ var launch = /*#__PURE__*/Object.freeze({
 
 const unifiedProviderExecutors = {
   claude: async (opts) => {
-    const { runClaude } = await import('./runClaude-CPV5Uap2.mjs');
+    const { runClaude } = await import('./runClaude-BRhQLKjh.mjs');
     await runClaude(opts.credentials, opts.claudeOptions ?? {});
   },
   codex: async (opts) => {
-    const { runCodex } = await import('./runCodex-CwtLSTMJ.mjs');
+    const { runCodex } = await import('./runCodex-DUs_jBE-.mjs');
     await runCodex({
       credentials: opts.credentials,
       startedBy: opts.startedBy,
@@ -9107,7 +9507,7 @@ const unifiedProviderExecutors = {
     });
   },
   gemini: async (opts) => {
-    const { runGemini } = await import('./runGemini-Bmoxehlh.mjs');
+    const { runGemini } = await import('./runGemini-pmvBZ6qU.mjs');
     await runGemini({
       credentials: opts.credentials,
       startedBy: opts.startedBy
@@ -9183,7 +9583,7 @@ function shouldRunMainClaudeFlow(opts) {
     return;
   } else if (subcommand === "runtime") {
     if (args[1] === "providers") {
-      const { renderRuntimeProviders } = await import('./command-B6LM3Nml.mjs');
+      const { renderRuntimeProviders } = await import('./command-BVCkEMtp.mjs');
       console.log(renderRuntimeProviders());
       return;
     }
@@ -9361,8 +9761,8 @@ function shouldRunMainClaudeFlow(opts) {
       const projectId = args[3];
       try {
         const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return config; });
-        const { readCredentials: readCredentials2 } = await import('./persistence-6d4U4Sh8.mjs');
-        const { ApiClient: ApiClient2 } = await import('./api-Cxifhw5r.mjs').then(function (n) { return n.v; });
+        const { readCredentials: readCredentials2 } = await import('./persistence-CyFjFOlN.mjs');
+        const { ApiClient: ApiClient2 } = await import('./api-l8X03rs-.mjs').then(function (n) { return n.v; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentials2();