@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/{chunk-IXEZHTDR.js → chunk-U4DJ5XB3.js}

@@ -461,6 +461,7 @@ init_esbuild_shims();
 var CHANNEL_PROMPT_DISPLAY_TEXT_META_KEY = "qwen.daemon.promptDisplayText";
 var CHANNEL_PROMPT_AUTHORIZATION_META_KEY = "qwen.daemon.channelPromptAuthorization";
 var CHANNEL_PROMPT_META_KEY = "qwen.channel.prompt";
+var CHANNEL_BTW_METHOD = "qwen/control/session/btw";
 var ACP_PRIVATE_PARENT_CAPABILITY_META_KEY = "qwen-code/private-parent-capability";
 var ACP_PRIVATE_PARENT_CAPABILITY_ENV = "QWEN_CODE_PRIVATE_ACP_CAPABILITY";
 function resolvePromptImages(options) {
@@ -761,15 +762,29 @@ var AcpBridge = class extends EventEmitter {
     });
     void this.registerChannelLoopMcpServer();
   }
-  async newSession(cwd, _options, bindingToken) {
+  async applySessionApprovalMode(conn, sessionId, approvalMode) {
+    if (!approvalMode)
+      return;
+    try {
+      await conn.setSessionMode({ sessionId, modeId: approvalMode });
+    } catch (error) {
+      await conn.extMethod("qwen/control/session/close", { sessionId }).catch((closeError) => {
+        process.stderr.write(`[AcpBridge] Failed to close session ${sanitizeLogText(sessionId, 128)} after approval mode error: ${sanitizeLogText(closeError instanceof Error ? closeError.message : String(closeError), 512)}
+`);
+      });
+      throw error;
+    }
+  }
+  async newSession(cwd, options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     const response = await conn.newSession({ cwd, mcpServers: [] });
+    await this.applySessionApprovalMode(conn, response.sessionId, options?.approvalMode);
     this.knownSessionIds.add(response.sessionId);
     this.sessionBindingTokens.set(response.sessionId, bindingToken);
     return response.sessionId;
   }
-  async loadSession(sessionId, cwd, _options, bindingToken) {
+  async loadSession(sessionId, cwd, options, bindingToken) {
     const conn = this.ensureConnection();
     await this.registerChannelLoopMcpServer();
     await conn.unstable_resumeSession({
@@ -777,6 +792,7 @@ var AcpBridge = class extends EventEmitter {
       cwd,
       mcpServers: []
     });
+    await this.applySessionApprovalMode(conn, sessionId, options?.approvalMode);
     this.knownSessionIds.add(sessionId);
     this.sessionBindingTokens.set(sessionId, bindingToken);
     return sessionId;
@@ -829,6 +845,25 @@ var AcpBridge = class extends EventEmitter {
     }
     return chunks.join("") || slashCommandOutput;
   }
+  async btw(sessionId, question, signal) {
+    if (!this.knownSessionIds.has(sessionId)) {
+      throw new Error(`Unknown ACP session ${sessionId}`);
+    }
+    if (signal?.aborted) {
+      throw createAbortError();
+    }
+    const response = await withAbortSignal(this.ensureConnection().extMethod(CHANNEL_BTW_METHOD, {
+      sessionId,
+      question
+    }), signal);
+    if (response["sessionId"] !== sessionId || response["answer"] !== null && typeof response["answer"] !== "string") {
+      throw new Error("Invalid BTW response from ACP agent");
+    }
+    return {
+      sessionId,
+      answer: response["answer"]
+    };
+  }
   async cancelSession(sessionId) {
     const conn = this.ensureConnection();
     try {
@@ -1100,6 +1135,30 @@ async function withTimeout(operation, timeoutMs, message) {
   }
 }
 __name(withTimeout, "withTimeout");
+async function withAbortSignal(operation, signal) {
+  if (!signal)
+    return operation;
+  if (signal.aborted)
+    throw createAbortError();
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = /* @__PURE__ */ __name(() => reject(createAbortError()), "onAbort");
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([operation, aborted]);
+  } finally {
+    if (onAbort)
+      signal.removeEventListener("abort", onAbort);
+  }
+}
+__name(withAbortSignal, "withAbortSignal");
+function createAbortError() {
+  const error = new Error("BTW request aborted");
+  error.name = "AbortError";
+  return error;
+}
+__name(createAbortError, "createAbortError");
 function isSkippedMcpRegistration(result) {
   return typeof result === "object" && result !== null && result.skipped === true;
 }
@@ -3770,6 +3829,7 @@ var LOOP_ADD_RE = /^"([^"]+)"\s+(.+)$/su;
 var MAX_LOOP_JOBS_PER_TARGET = 10;
 var MAX_LOOP_PROMPT_CHARS = 4e3;
 var MAX_DISPLAY_PROJECTION_CHARS = 8e3;
+var CHANNEL_BTW_MAX_INPUT_LENGTH = 4096;
 function parseLoopAddArgs(args) {
   const match = args.trim().match(LOOP_ADD_RE);
   if (!match)
@@ -3840,6 +3900,7 @@ var ChannelBase = class {
   pendingChannelMemoryMutationDeliveries = /* @__PURE__ */ new Map();
   /** Per-session active prompt tracking for dispatch modes. */
   activePrompts = /* @__PURE__ */ new Map();
+  activeBtw = /* @__PURE__ */ new Map();
   /** Per-session message buffer for collect mode. */
   collectBuffers = /* @__PURE__ */ new Map();
   preflightedEnvelopes = /* @__PURE__ */ new WeakSet();
@@ -3934,6 +3995,113 @@ var ChannelBase = class {
   async deliverBackgroundReply(chatId, text, sessionId, sourceLabel) {
     await this.sendResponseMessage(chatId, text, sessionId, sourceLabel);
   }
+  async handleBtw(envelope, sessionId, question, sourceLabel) {
+    const target = this.router.getTarget(sessionId);
+    if (!target || target.channelName !== this.name) {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Could not resolve the current task for /btw.", sourceLabel);
+      return;
+    }
+    const running = this.activeBtw.get(sessionId);
+    if (running) {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${running.id} is still running for this task.`, sourceLabel);
+      return;
+    }
+    const reference = this.namedSessions?.presentation(sessionId);
+    const request = {
+      id: randomUUID3().slice(0, 8),
+      bridge: this.bridge,
+      controller: new AbortController(),
+      target: { ...target },
+      chatId: envelope.chatId,
+      ...envelope.threadId ? { threadId: envelope.threadId } : {},
+      ...sourceLabel ? { sourceLabel } : {},
+      ...reference?.status === "open" ? { taskName: reference.taskName } : {}
+    };
+    this.activeBtw.set(sessionId, request);
+    try {
+      await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW #${request.id} received. The main task will continue.`, sourceLabel);
+    } catch (error) {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.cancelBtw(sessionId);
+      }
+      throw error;
+    }
+    if (!this.isBtwCurrent(sessionId, request)) {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.cancelBtw(sessionId);
+      }
+      return;
+    }
+    void this.deliverBtw(sessionId, question, request).catch((error) => {
+      process.stderr.write(`[${this.name}] BTW delivery failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}
+`);
+    });
+  }
+  async deliverBtw(sessionId, question, request) {
+    let message;
+    try {
+      let result;
+      try {
+        result = await request.bridge.btw(sessionId, question, request.controller.signal);
+        if (result.sessionId !== sessionId) {
+          throw new Error("BTW response session did not match the request");
+        }
+        const answer = result.answer?.trim();
+        message = answer ? `BTW #${request.id}
+
+${answer}` : `BTW #${request.id}
+
+No answer is available from the current conversation context.`;
+      } catch (error) {
+        if (request.controller.signal.aborted)
+          return;
+        process.stderr.write(`[${this.name}] BTW request failed for session ${sanitizeLogText(sessionId, 128)}: ${this.lifecycleError(error)}
+`);
+        message = `BTW #${request.id} failed. Please try again.`;
+      }
+      if (!this.isBtwCurrent(sessionId, request))
+        return;
+      try {
+        await this.sendThreadMessage(request.chatId, request.threadId, message, request.sourceLabel);
+      } catch (error) {
+        try {
+          await this.sendThreadMessage(request.chatId, request.threadId, `BTW #${request.id} failed. Please try again.`, request.sourceLabel);
+        } catch {
+        }
+        throw error;
+      }
+    } finally {
+      if (this.activeBtw.get(sessionId) === request) {
+        this.activeBtw.delete(sessionId);
+      }
+    }
+  }
+  isBtwCurrent(sessionId, request) {
+    if (request.controller.signal.aborted || this.activeBtw.get(sessionId) !== request || this.bridge !== request.bridge || !this.router.isSessionLive(sessionId)) {
+      return false;
+    }
+    const currentTarget = this.router.getTarget(sessionId);
+    if (!currentTarget || !this.sameTaskOwner(request.target, currentTarget) || request.target.threadId !== currentTarget.threadId) {
+      return false;
+    }
+    if (!request.taskName)
+      return true;
+    const reference = this.namedSessions?.presentation(sessionId);
+    return reference?.status === "open" && reference.taskName === request.taskName && this.sameTaskOwner(currentTarget, reference.target) && currentTarget.threadId === reference.target.threadId;
+  }
+  cancelBtw(sessionId) {
+    const request = this.activeBtw.get(sessionId);
+    if (!request)
+      return;
+    this.activeBtw.delete(sessionId);
+    request.controller.abort();
+  }
+  cancelAllBtw() {
+    const requests = Array.from(this.activeBtw.values());
+    this.activeBtw.clear();
+    for (const request of requests)
+      request.controller.abort();
+  }
   async dispatchPermissionRequest(event) {
     const target = this.permissionTargetForEvent(event);
     if (!target) {
@@ -4620,6 +4788,7 @@ var ChannelBase = class {
   }
   /** Replace the bridge instance (used after crash recovery restart). */
   setBridge(bridge) {
+    this.cancelAllBtw();
     if (this.registerBridgeEvents) {
       this.detachBridgeEvents(this.bridge);
     }
@@ -5080,6 +5249,7 @@ ${promptText}` : promptText;
         })
       ]);
       if (!cancelled) {
+        this.cancelBtw(sessionId);
         this.router.removeSessionId(sessionId);
         this.instructedSessions.delete(sessionId);
         this.unattendedMemorySessions.delete(sessionId);
@@ -5202,6 +5372,7 @@ ${promptText}` : promptText;
   onToolCall(_chatId, _event) {
   }
   onSessionDied(sessionId) {
+    this.cancelBtw(sessionId);
     this.router.handleSessionDied(sessionId);
     this.instructedSessions.delete(sessionId);
     this.unattendedMemorySessions.delete(sessionId);
@@ -5431,44 +5602,81 @@ ${promptText}` : promptText;
   }
   formatPermissionRequest(pending) {
     const { toolCall } = pending.request;
-    const title = sanitizeQuotedText(toolCall.title || "Tool use", 160);
+    const parameters = this.permissionParameterSummary(toolCall);
+    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), "allow once");
     const alwaysOption = this.approvalAlwaysOption(pending);
-    if (pending.taskName) {
-      const replies2 = [
-        `/approve ${pending.requestId}          allow once`,
-        ...alwaysOption ? [`/approve-always ${pending.requestId}   ${alwaysOption.label}`] : [],
-        `/deny ${pending.requestId}             deny`
-      ];
-      return [
-        "Permission required to run a tool",
-        `Request: ${pending.requestId}`,
-        "",
-        "Command:",
-        title,
-        "",
-        "Reply with:",
-        ...replies2
-      ].join("\n");
-    }
+    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), "deny");
+    const requestSuffix = pending.taskName ? ` ${pending.requestId}` : "";
+    const replyPadding = pending.taskName ? { approve: "          ", always: "   ", deny: "             " } : { approve: "        ", always: " ", deny: "           " };
     const replies = [
-      "/approve        allow once",
-      ...alwaysOption ? [`/approve-always ${alwaysOption.label}`] : [],
-      "/deny           deny"
+      `/approve${requestSuffix}${replyPadding.approve}${approveLabel}`,
+      ...alwaysOption ? [
+        `/approve-always${requestSuffix}${replyPadding.always}${alwaysOption.label}`
+      ] : [],
+      `/deny${requestSuffix}${replyPadding.deny}${denyLabel}`
     ];
-    const lines = [
+    return [
       "Permission required to run a tool",
+      ...pending.taskName ? [`Request: ${pending.requestId}`] : [],
       "",
-      "Command:",
-      title,
+      `Tool: ${this.permissionToolName(toolCall)}`,
+      `Action: ${this.permissionTitle(toolCall)}`,
+      ...parameters ? [`Parameters: ${parameters}`] : [],
       "",
       "Reply with:",
       ...replies
-    ];
-    return lines.join("\n");
+    ].join("\n");
   }
-  approvalOptionId(pending) {
+  permissionTitle(toolCall) {
+    const rawTitle = typeof toolCall.title === "string" ? toolCall.title : void 0;
+    return sanitizeQuotedText(rawTitle || "", 160).trim() || "Tool use";
+  }
+  permissionToolName(toolCall) {
+    const rawToolCall = toolCall;
+    const meta = isRecord2(rawToolCall["_meta"]) ? rawToolCall["_meta"] : void 0;
+    for (const candidate of [meta?.["toolName"], rawToolCall["kind"]]) {
+      if (typeof candidate !== "string")
+        continue;
+      const name = sanitizeQuotedText(candidate, 120).trim();
+      if (name)
+        return name;
+    }
+    return "unknown";
+  }
+  permissionParameterSummary(toolCall) {
+    const rawToolCall = toolCall;
+    const rawInput = isRecord2(rawToolCall["rawInput"]) ? rawToolCall["rawInput"] : void 0;
+    if (!rawInput)
+      return void 0;
+    const entries = Object.entries(rawInput);
+    if (entries.length === 0)
+      return void 0;
+    const visible = entries.slice(0, 4).map(([key, value]) => {
+      const safeKey = sanitizeQuotedText(key, 48).trim() || "unknown";
+      if (Array.isArray(value)) {
+        return `${safeKey} (${value.length} ${value.length === 1 ? "item" : "items"})`;
+      }
+      if (isRecord2(value)) {
+        return `${safeKey} (object)`;
+      }
+      return safeKey;
+    });
+    if (entries.length > visible.length) {
+      visible.push(`+${entries.length - visible.length} more`);
+    }
+    return visible.join(", ");
+  }
+  permissionOptionLabel(option, fallback) {
+    const rawLabel = typeof option?.name === "string" ? option.name : "";
+    const label = sanitizeQuotedText(rawLabel, 160).trim();
+    return label || fallback;
+  }
+  approvalOption(pending) {
     const options = pending.request.options;
-    return options.find((option) => option.kind === "allow_once")?.optionId ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0)?.optionId;
+    return options.find((option) => option.kind === "allow_once") ?? options.find((option) => option.optionId === "proceed_once" && option.kind === void 0);
+  }
+  approvalOptionId(pending) {
+    return this.approvalOption(pending)?.optionId;
   }
   approvalAlwaysOption(pending) {
     const options = pending.request.options.filter((option2) => option2.kind === "allow_always");
@@ -5478,7 +5686,7 @@ ${promptText}` : promptText;
     }
     return {
       optionId: option.optionId,
-      label: this.approvalAlwaysLabel(option)
+      label: this.permissionOptionLabel(option, this.approvalAlwaysLabel(option))
     };
   }
   findScopedAlwaysOption(options, scope) {
@@ -5494,12 +5702,15 @@ ${promptText}` : promptText;
     return "always allow";
   }
   denialResponse(pending) {
-    const option = pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+    const option = this.denialOption(pending);
     if (option) {
       return { outcome: { outcome: "selected", optionId: option.optionId } };
     }
     return { outcome: { outcome: "cancelled" } };
   }
+  denialOption(pending) {
+    return pending.request.options.find((candidate) => candidate.kind === "reject_once") ?? pending.request.options.find((candidate) => candidate.optionId === "cancel" && candidate.kind === void 0);
+  }
   async handlePermissionResponseCommand(envelope, args, decision) {
     if (!this.isAuthorizedForSharedSession(envelope)) {
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can answer permission requests in this shared session.");
@@ -5520,7 +5731,7 @@ ${promptText}` : promptText;
     if (lookup.kind === "ambiguous") {
       const requestList = lookup.requestIds.slice(0, 6).map((id) => {
         const pending2 = this.pendingPermissions.get(id);
-        const title = pending2 ? `: ${sanitizeQuotedText(pending2.request.toolCall.title || "Tool use", 160)}` : "";
+        const title = pending2 ? `: ${this.permissionTitle(pending2.request.toolCall)}` : "";
         const task = pending2?.taskName ? `Task ${pending2.taskName} \u2014 ` : "";
         return `- ${task}${sanitizeQuotedText(id, 128)}${title}`;
       }).join("\n");
@@ -5729,7 +5940,10 @@ ${requestList}`);
         case "close": {
           if (parts.length !== 1)
             break;
+          const closing = await namedSessions.lookup(owner, parts[0]);
           const result = await namedSessions.close(owner, parts[0]);
+          if (closing)
+            this.cancelBtw(closing.sessionId);
           await this.sendThreadMessage(envelope.chatId, envelope.threadId, result.active ? `Closed task "${result.closed.name}". Selected "${result.active.name}".` : `Closed task "${result.closed.name}". No task is selected.`);
           return true;
         }
@@ -5784,6 +5998,7 @@ ${requestList}`);
       this.clearPendingGroupHistory(envelope);
       if (removedIds.length > 0) {
         for (const id of removedIds) {
+          this.cancelBtw(id);
           if (this.isSharedSession(envelope)) {
             const who = sanitizeSenderName(envelope.senderName || envelope.senderId || "unknown");
             process.stderr.write(`[${this.name}] shared session ${id} cleared by ${who} (sender ${envelope.senderId})
@@ -5846,6 +6061,7 @@ ${requestList}`);
     this.registerCommand("clear", clearHandler);
     this.registerCommand("reset", clearHandler);
     this.registerCommand("new", clearHandler);
+    this.registerCommand("btw", () => Promise.resolve(false));
     if (this.namedSessions) {
       this.registerCommand("sessions", (envelope, args) => this.handleNamedSessionsCommand(envelope, args));
       this.registerCommand("session", (envelope, args) => this.handleNamedSessionCommand(envelope, args));
@@ -5884,6 +6100,9 @@ ${requestList}`);
         "/approve [request-id] \u2014 Approve a pending permission request",
         "/approve-always [request-id] \u2014 Always approve a pending permission request",
         "/deny [request-id] \u2014 Deny a pending permission request",
+        ...this.bridge.btw ? [
+          "/btw <question> \u2014 Ask a side question without interrupting the current task"
+        ] : [],
         ...this.namedSessions ? [
           "/sessions [all] \u2014 List your named tasks",
           "/session current|new|use|close|cancel \u2014 Manage your named tasks"
@@ -5897,6 +6116,7 @@ ${requestList}`);
         "approve",
         "approve-always",
         "deny",
+        "btw",
         "remember-channel",
         "channel-memory",
         "forget-channel",
@@ -5912,7 +6132,10 @@ ${requestList}`);
         }
       }
       const sessionId = await this.currentSessionId(envelope);
-      const agentCommands = sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands;
+      const agentCommands = (sessionId ? this.getAgentCommandsForSession(sessionId) : this.bridge.availableCommands).filter((command) => !this.commands.has(command.name) || // `btw` is registered unconditionally but only handled locally when
+      // the bridge supports it. Without that capability the agent's entry
+      // is the working one, so it must stay listed.
+      command.name === "btw" && !this.bridge.btw);
       if (agentCommands.length > 0) {
         lines.push("", "Agent commands (forwarded to Qwen Code):");
         for (const cmd of agentCommands) {
@@ -7237,12 +7460,13 @@ ${text}`;
       this.onObservedContact(envelope);
     }
     const displayText = sanitizeDisplayText(envelope.displayText ?? envelope.text, MAX_DISPLAY_PROJECTION_CHARS);
-    let memoryIntent = parseChannelMemoryIntent(envelope.text);
+    const parsed = this.parseCommand(envelope.text);
+    let memoryIntent = parsed?.command === "btw" ? null : parseChannelMemoryIntent(envelope.text);
     let memoryIntentFromClassifier = false;
     if (memoryIntent?.kind === "update" || memoryIntent?.kind === "remove") {
       this.deletePendingChannelMemoryMutation(envelope);
     }
-    if (!memoryIntent && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
+    if (!memoryIntent && parsed?.command !== "btw" && this.shouldClassifyChannelMemoryIntent(envelope.text)) {
       memoryIntent = await this.classifyChannelMemoryIntent(envelope);
       memoryIntentFromClassifier = memoryIntent !== null;
     }
@@ -7255,7 +7479,7 @@ ${text}`;
         return;
       }
     }
-    const parsed = this.parseCommand(envelope.text);
+    let btwQuestion;
     if (parsed) {
       const handler = this.commands.get(parsed.command);
       if (handler) {
@@ -7263,6 +7487,25 @@ ${text}`;
         if (handled)
           return;
       }
+      if (parsed.command === "btw" && this.bridge.btw) {
+        if (!this.isAuthorizedForSharedSession(envelope)) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Only authorized members can use /btw in this shared session.");
+          return;
+        }
+        btwQuestion = parsed.args.trim();
+        if (!btwQuestion) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Usage: /btw <question>");
+          return;
+        }
+        if (btwQuestion.length > CHANNEL_BTW_MAX_INPUT_LENGTH) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, `BTW questions are limited to ${CHANNEL_BTW_MAX_INPUT_LENGTH} characters.`);
+          return;
+        }
+        if (envelope.imageBase64 || envelope.attachments?.length) {
+          await this.sendThreadMessage(envelope.chatId, envelope.threadId, "/btw supports text-only questions.");
+          return;
+        }
+      }
     }
     const bangText = envelope.text.trimStart();
     if (bangText.startsWith("!")) {
@@ -7326,6 +7569,10 @@ ${text}`;
       await this.sendThreadMessage(envelope.chatId, envelope.threadId, "Could not identify the selected task. Use /sessions, select it again, and retry.");
       return;
     }
+    if (btwQuestion !== void 0) {
+      await this.handleBtw(envelope, sessionId, btwQuestion, sourceLabel);
+      return;
+    }
     if (bangText.startsWith("!")) {
       const cmd = bangText.slice(1).trim();
       const bridgeShellCommand = this.bridge.shellCommand;
@@ -8284,6 +8531,13 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       }
     }
   }
+  async btw(sessionId, question, signal) {
+    const session = this.ensureSession(sessionId);
+    if (!session.btw) {
+      throw new Error("BTW is not supported by this daemon session");
+    }
+    return session.btw(question, signal ? { signal } : void 0);
+  }
   async shellCommand(sessionId, command, signal) {
     const session = this.ensureSession(sessionId);
     if (!session.shellCommand) {
@@ -8332,7 +8586,7 @@ var DaemonChannelBridge = class extends EventEmitter2 {
       return false;
     }
     try {
-      const accepted = await session.respondToPermission(requestId, response);
+      const accepted = this.options.sessionPermissionVote && typeof session.respondToSessionPermission === "function" ? await session.respondToSessionPermission(requestId, response) : await session.respondToPermission(requestId, response);
       this.requestToSession.delete(requestId);
       if (accepted) {
         this.rememberRespondedPermissionRequest(requestId, sessionId);

package/chunks/{chunk-MZ5A5PQW.js → chunk-UAKRDON5.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-BBYTY46C.js";
+} from "./chunk-NVVJTUSL.js";
 import {
   observeHeadlessToolResultProjection,
   observeHeadlessToolResultWire,
   projectJsonStringToByteBudget
-} from "./chunk-L2OKAIUK.js";
+} from "./chunk-QI27MKNQ.js";
 import {
   parseAndFormatApiError,
   toolResultBoundaryArtifact
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NGKLMNWN.js → chunk-UM2FFKXN.js}

@@ -8,10 +8,10 @@ import {
 } from "./chunk-TXASDT2M.js";
 import {
   t
-} from "./chunk-EU2B4P3D.js";
+} from "./chunk-I4NRYS6A.js";
 import {
   So
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   createDebugLogger
 } from "./chunk-EAHOJF6V.js";

package/chunks/{chunk-5ICKESC3.js → chunk-UPFRILIL.js}

@@ -3,11 +3,11 @@
 import {
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   detectTurnInterruption
-} from "./chunk-NT7LXVV5.js";
+} from "./chunk-JUARRUMA.js";
 import {
   SessionService,
   buildApiHistoryFromConversation
-} from "./chunk-ZBDYI7VM.js";
+} from "./chunk-4F7GQGXB.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-RAEEQEC5.js → chunk-UUASLXHW.js}

@@ -2,18 +2,18 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-YOMKOM7E.js";
+} from "./chunk-MP6YZ4RK.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-ND7TQQPE.js";
+} from "./chunk-C2VWOXHS.js";
 import {
   getMCPServerStatus
-} from "./chunk-FXUSWLBF.js";
+} from "./chunk-GH2S4GD5.js";
 import {
   require_fast_deep_equal
-} from "./chunk-LYSZVCCD.js";
+} from "./chunk-7JMGTOH7.js";
 import {
   createDebugLogger
 } from "./chunk-EAHOJF6V.js";
@@ -29,6 +29,9 @@ import {
 init_esbuild_shims();
 var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
 var debugLogger = createDebugLogger("MCP_HOT_RELOAD");
+var modelProvidersDebugLogger = createDebugLogger(
+  "MODEL_PROVIDERS_HOT_RELOAD"
+);
 function mcpServersEqual(a, b) {
   return (0, import_fast_deep_equal.default)(a ?? {}, b ?? {});
 }
@@ -123,10 +126,56 @@ function registerMcpHotReload(watcher, settings, config, topTierMcpServers) {
   });
 }
 __name(registerMcpHotReload, "registerMcpHotReload");
+function registerModelProvidersHotReload(watcher, settings, config) {
+  modelProvidersDebugLogger.debug(
+    "registered modelProviders hot-reload listener on SettingsWatcher"
+  );
+  let refreshAuthRetryPending = false;
+  const reconcile = /* @__PURE__ */ __name(async () => {
+    const next = settings.merged.modelProviders;
+    const providersUnchanged = (0, import_fast_deep_equal.default)(
+      config.getModelProvidersConfig() ?? {},
+      next ?? {}
+    );
+    if (providersUnchanged && !refreshAuthRetryPending) {
+      return;
+    }
+    if (!providersUnchanged) {
+      modelProvidersDebugLogger.debug(
+        "modelProviders changed \u2014 reloading model registry"
+      );
+      try {
+        config.reloadModelProvidersConfig(next);
+      } catch (err) {
+        modelProvidersDebugLogger.error(
+          `reloadModelProvidersConfig threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        );
+        return;
+      }
+    }
+    const authType = config.getAuthType();
+    if (!authType) {
+      return;
+    }
+    try {
+      await config.refreshAuth(authType, true);
+      refreshAuthRetryPending = false;
+    } catch (err) {
+      refreshAuthRetryPending = true;
+      modelProvidersDebugLogger.error(
+        `refreshAuth after modelProviders reload threw: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+      );
+    }
+  }, "reconcile");
+  void reconcile();
+  return watcher.addChangeListener(reconcile);
+}
+__name(registerModelProvidersHotReload, "registerModelProvidersHotReload");
 
 export {
   recomputeMcpGating,
-  registerMcpHotReload
+  registerMcpHotReload,
+  registerModelProvidersHotReload
 };
 /**
  * @license