@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.2

package/chunks/{chunk-XVTCSVBK.js → chunk-WDVV3LRM.js}

@@ -1245,118 +1245,6 @@ init_esbuild_shims();
 import { basename as basename3, join as join5 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
-// packages/channels/base/dist/BlockStreamer.js
-init_esbuild_shims();
-var BlockStreamer = class {
-  static {
-    __name(this, "BlockStreamer");
-  }
-  buffer = "";
-  idleTimer = null;
-  sending = Promise.resolve();
-  opts;
-  /** Number of blocks emitted so far. */
-  blockCount = 0;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /** Feed a new text chunk from the agent stream. */
-  push(chunk) {
-    this.buffer += chunk;
-    this.clearIdleTimer();
-    this.checkEmit();
-    if (this.buffer.length > 0 && this.opts.idleMs > 0) {
-      this.idleTimer = setTimeout(() => this.onIdle(), this.opts.idleMs);
-    }
-  }
-  /** Flush all remaining buffered text. Awaits all pending sends. */
-  async flush() {
-    this.clearIdleTimer();
-    if (this.buffer.length > 0) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-    await this.sending;
-  }
-  /** Drop buffered text and cancel future idle emission. */
-  stop() {
-    this.clearIdleTimer();
-    this.buffer = "";
-  }
-  /** Await already-queued sends without emitting the buffered text. */
-  async drain() {
-    await this.sending;
-  }
-  // ---------------------------------------------------------------------------
-  // Internal
-  // ---------------------------------------------------------------------------
-  checkEmit() {
-    while (this.buffer.length >= this.opts.maxChars) {
-      const bp = this.findBreakPoint(this.buffer, this.opts.maxChars);
-      this.emitBlock(this.buffer.slice(0, bp));
-      this.buffer = this.buffer.slice(bp);
-    }
-    if (this.buffer.length >= this.opts.minChars) {
-      const bp = this.findBlockBoundary(this.buffer);
-      if (bp > 0) {
-        this.emitBlock(this.buffer.slice(0, bp));
-        this.buffer = this.buffer.slice(bp);
-      }
-    }
-  }
-  onIdle() {
-    this.idleTimer = null;
-    if (this.buffer.length >= this.opts.minChars) {
-      this.emitBlock(this.buffer);
-      this.buffer = "";
-    }
-  }
-  emitBlock(text) {
-    const trimmed = text.trim();
-    if (!trimmed)
-      return;
-    const block = /\n[^\S\n]*$/.test(text) ? `${trimmed}
-` : trimmed;
-    this.blockCount++;
-    this.sending = this.sending.then(() => this.opts.send(block)).catch(() => {
-    });
-  }
-  /**
-   * Find the last paragraph boundary (\n\n) in the buffer.
-   * Returns the position after the boundary, or -1 if no suitable boundary
-   * exists at or after minChars.
-   */
-  findBlockBoundary(text) {
-    const last = text.lastIndexOf("\n\n");
-    if (last < 0 || last < this.opts.minChars)
-      return -1;
-    return last + 2;
-  }
-  /**
-   * Find the best break point at or before maxPos.
-   * Prefers paragraph break > newline > space > maxPos.
-   */
-  findBreakPoint(text, maxPos) {
-    const sub = text.slice(0, maxPos);
-    const para = sub.lastIndexOf("\n\n");
-    if (para > 0)
-      return para + 2;
-    const nl = sub.lastIndexOf("\n");
-    if (nl > 0)
-      return nl + 1;
-    const sp = sub.lastIndexOf(" ");
-    if (sp > 0)
-      return sp + 1;
-    return maxPos;
-  }
-  clearIdleTimer() {
-    if (this.idleTimer !== null) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-  }
-};
-
 // packages/channels/base/dist/ChannelProactiveDeliveryError.js
 init_esbuild_shims();
 var CHANNEL_PROACTIVE_DELIVERY_ERROR_CODE = "channel_proactive_delivery_error";
@@ -4330,6 +4218,45 @@ function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 __name(isRecord2, "isRecord");
+var PERMISSION_COPY = {
+  en: {
+    toolUse: "Tool use",
+    allowOnce: "Allow once",
+    allowAlwaysProject: "always allow for this project",
+    allowAlwaysUser: "always allow for this user",
+    allowAlways: "always allow",
+    deny: "Deny",
+    required: "Permission required to run a tool",
+    request: "Request:",
+    tool: "Tool:",
+    action: "Action:",
+    parameters: "Parameters:",
+    replyWith: "Reply with:"
+  },
+  zh: {
+    toolUse: "\u5DE5\u5177\u8C03\u7528",
+    allowOnce: "\u4EC5\u5141\u8BB8\u672C\u6B21",
+    allowAlwaysProject: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u9879\u76EE",
+    allowAlwaysUser: "\u59CB\u7EC8\u5141\u8BB8\u6B64\u7528\u6237",
+    allowAlways: "\u59CB\u7EC8\u5141\u8BB8",
+    deny: "\u62D2\u7EDD",
+    required: "\u8FD0\u884C\u5DE5\u5177\u9700\u8981\u6388\u6743",
+    request: "\u8BF7\u6C42\uFF1A",
+    tool: "\u5DE5\u5177\uFF1A",
+    action: "\u64CD\u4F5C\uFF1A",
+    parameters: "\u53C2\u6570\uFF1A",
+    replyWith: "\u56DE\u590D\u4EE5\u4E0B\u547D\u4EE4\uFF1A"
+  }
+};
+function localizedScopedAlwaysLabel(label, stockLabel, localizedLabel) {
+  if (label === stockLabel)
+    return localizedLabel;
+  const scopeSeparator = ": ";
+  if (!label.startsWith(stockLabel + scopeSeparator))
+    return void 0;
+  return `${localizedLabel}\uFF1A${label.slice(stockLabel.length + scopeSeparator.length)}`;
+}
+__name(localizedScopedAlwaysLabel, "localizedScopedAlwaysLabel");
 var COMMAND_TOKEN_CHARS = "a-zA-Z0-9_:-";
 var PARSE_COMMAND_RE = new RegExp(`^\\/([${COMMAND_TOKEN_CHARS}]+)(?:@\\S+)?\\s*(.*)`, "s");
 var COMMAND_TOKEN_RE = new RegExp(`^[${COMMAND_TOKEN_CHARS}]+(?:@\\S+)?$`);
@@ -4373,6 +4300,7 @@ var ChannelBase = class {
   proxy;
   /** Adapter-owned persistent state directory, when supplied by the runtime. */
   stateDir;
+  locale;
   channelMemory;
   memoryIntentClassifier;
   channelMemoryRecallObserver;
@@ -4706,6 +4634,10 @@ No answer is available from the current conversation context.`;
       if (presentation && await presentation) {
         return;
       }
+      const permissionPresentation = this.tryPresentPermission(pending);
+      if (permissionPresentation && await permissionPresentation) {
+        return;
+      }
       const text = this.formatPermissionRequest(pending);
       if (target.threadId !== void 0 && this.supportsProactiveSend() && this.supportsProactiveTarget(target)) {
         await this.pushProactive(target, text, pending.sourceLabel);
@@ -4786,6 +4718,103 @@ No answer is available from the current conversation context.`;
       }
     })();
   }
+  tryPresentPermission(pending) {
+    const active = this.activePrompts.get(pending.sessionId);
+    const toolCall = pending.request.toolCall;
+    const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
+    const isUserQuestion = meta?.["qwenInteractionKind"] === "user_question" || meta?.["toolName"] === "ask_user_question" || toolCall["kind"] === "ask_user_question";
+    const decisions = this.permissionPresentationDecisions(pending);
+    if (!active || active.loopPrompt || !active.owner || isUserQuestion || !decisions) {
+      return void 0;
+    }
+    const precedingSegment = this.closeOutputSegment(pending.sessionId, active, pending.target);
+    let respondInvoked = false;
+    const context = {
+      requestId: pending.requestId,
+      sessionId: pending.sessionId,
+      runId: active.runId,
+      owner: active.owner,
+      target: pending.target,
+      ...precedingSegment ? { precedingSegmentId: precedingSegment.segmentId } : {},
+      title: this.permissionTitle(pending.request.toolCall),
+      decisions,
+      onSettled: /* @__PURE__ */ __name((listener) => {
+        if (pending.settled) {
+          listener(pending.settled);
+          return () => {
+          };
+        }
+        pending.settlementListeners.add(listener);
+        return () => {
+          pending.settlementListeners.delete(listener);
+        };
+      }, "onSettled"),
+      respond: /* @__PURE__ */ __name((decision) => {
+        const response = this.permissionPresentationResponse(pending, decision);
+        if (!response)
+          return Promise.resolve(false);
+        respondInvoked = true;
+        return this.respondToUserInput(pending, response);
+      }, "respond")
+    };
+    pending.permissionPresented = true;
+    return (async () => {
+      try {
+        if (precedingSegment) {
+          await this.notifyOutputSegmentEnd(pending.target.chatId, pending.sessionId, precedingSegment, "input_requested");
+        }
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        const result = await this.presentPermissionRequest(context);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        if (result.kind === "presented" || result.kind === "handled" && respondInvoked) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      } catch (err) {
+        process.stderr.write(`[${this.name}] permission presentation failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
+`);
+        if (this.pendingPermissions.get(pending.requestId) !== pending) {
+          return true;
+        }
+        pending.permissionPresented = false;
+        return false;
+      }
+    })();
+  }
+  permissionPresentationDecisions(pending) {
+    const allowOnce = this.approvalOption(pending);
+    if (!allowOnce)
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    const allowAlways = this.approvalAlwaysOption(pending);
+    return [
+      {
+        kind: "allow_once",
+        label: sanitizeQuotedText(this.permissionOptionLabel(allowOnce, copy.allowOnce), 80)
+      },
+      ...allowAlways ? [
+        {
+          kind: "allow_always",
+          label: sanitizeQuotedText(allowAlways.label, 80)
+        }
+      ] : [],
+      {
+        kind: "deny",
+        label: sanitizeQuotedText(this.permissionOptionLabel(this.denialOption(pending), copy.deny), 80)
+      }
+    ];
+  }
+  permissionPresentationResponse(pending, decision) {
+    if (decision === "deny")
+      return this.denialResponse(pending);
+    const optionId = decision === "allow_once" ? this.approvalOptionId(pending) : this.approvalAlwaysOption(pending)?.optionId;
+    return optionId ? { outcome: { outcome: "selected", optionId } } : void 0;
+  }
   normalizeUserQuestions(pending) {
     const toolCall = pending.request.toolCall;
     const meta = isRecord2(toolCall["_meta"]) ? toolCall["_meta"] : void 0;
@@ -4830,7 +4859,8 @@ No answer is available from the current conversation context.`;
   }
   async respondToUserInput(pending, response) {
     if (pending.responsePromise) {
-      return pending.responsePromise;
+      await pending.responsePromise;
+      return false;
     }
     if (this.pendingPermissions.get(pending.requestId) !== pending || !this.bridge.respondToPermission) {
       return false;
@@ -4883,6 +4913,7 @@ No answer is available from the current conversation context.`;
     this.config = config;
     this.messagePrefix = config.messagePrefix?.trim() || void 0;
     this.bridge = bridge;
+    this.locale = options?.locale ?? "en";
     this.proxy = options?.proxy;
     this.stateDir = options?.stateDir;
     this.identity = Object.freeze(this.resolveIdentity(name, config));
@@ -4945,6 +4976,9 @@ No answer is available from the current conversation context.`;
   async presentUserInputRequest(_context) {
     return { kind: "unsupported" };
   }
+  async presentPermissionRequest(_context) {
+    return { kind: "unsupported" };
+  }
   emitTaskLifecycle(event) {
     try {
       const result = this.onTaskLifecycle(event);
@@ -5837,7 +5871,6 @@ ${promptText}` : promptText;
         return false;
       }
       active.cancelled = true;
-      this.stopActiveStreaming(active, sessionId, reason);
       this.dropCollectBuffer(sessionId);
       this.removePendingPermissionsForSession(sessionId, "run_cancelled");
       this.emitTaskCancellation(active, sessionId, reason);
@@ -6144,14 +6177,15 @@ ${promptText}` : promptText;
     return { kind: "found", pending: matching[0] };
   }
   canEnvelopeAnswerPendingPermission(envelope, pending) {
-    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
+    return pending.target.chatId === envelope.chatId && pending.target.threadId === envelope.threadId && (!pending.userInputPresented && !pending.permissionPresented || pending.target.senderId === envelope.senderId) && (this.isSharedSessionTarget(pending.target) || pending.target.senderId === envelope.senderId);
   }
   formatPermissionRequest(pending) {
     const { toolCall } = pending.request;
+    const copy = PERMISSION_COPY[this.locale];
     const parameters = this.permissionParameterSummary(toolCall);
-    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), "allow once");
+    const approveLabel = this.permissionOptionLabel(this.approvalOption(pending), copy.allowOnce.toLocaleLowerCase(this.locale));
     const alwaysOption = this.approvalAlwaysOption(pending);
-    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), "deny");
+    const denyLabel = this.permissionOptionLabel(this.denialOption(pending), copy.deny.toLocaleLowerCase(this.locale));
     const requestSuffix = pending.taskName ? ` ${pending.requestId}` : "";
     const replyPadding = pending.taskName ? { approve: "          ", always: "   ", deny: "             " } : { approve: "        ", always: " ", deny: "           " };
     const replies = [
@@ -6162,14 +6196,14 @@ ${promptText}` : promptText;
       `${this.prefixedCommand(`/deny${requestSuffix}`)}${replyPadding.deny}${denyLabel}`
     ];
     return [
-      "Permission required to run a tool",
-      ...pending.taskName ? [`Request: ${pending.requestId}`] : [],
+      copy.required,
+      ...pending.taskName ? [`${copy.request} ${pending.requestId}`] : [],
       "",
-      `Tool: ${this.permissionToolName(toolCall)}`,
-      `Action: ${this.permissionTitle(toolCall)}`,
-      ...parameters ? [`Parameters: ${parameters}`] : [],
+      `${copy.tool} ${this.permissionToolName(toolCall)}`,
+      `${copy.action} ${this.permissionTitle(toolCall)}`,
+      ...parameters ? [`${copy.parameters} ${parameters}`] : [],
       "",
-      "Reply with:",
+      copy.replyWith,
       ...replies
     ].join("\n");
   }
@@ -6181,7 +6215,7 @@ ${promptText}` : promptText;
   }
   permissionTitle(toolCall) {
     const rawTitle = typeof toolCall.title === "string" ? toolCall.title : void 0;
-    return sanitizeQuotedText(rawTitle || "", 160).trim() || "Tool use";
+    return sanitizeQuotedText(rawTitle || "", 160).trim() || PERMISSION_COPY[this.locale].toolUse;
   }
   permissionToolName(toolCall) {
     const rawToolCall = toolCall;
@@ -6221,7 +6255,31 @@ ${promptText}` : promptText;
   permissionOptionLabel(option, fallback) {
     const rawLabel = typeof option?.name === "string" ? option.name : "";
     const label = sanitizeQuotedText(rawLabel, 160).trim();
-    return label || fallback;
+    if (!label)
+      return fallback;
+    return this.localizedPermissionOptionLabel(option, label) ?? label;
+  }
+  localizedPermissionOptionLabel(option, label) {
+    if (this.locale !== "zh")
+      return void 0;
+    const copy = PERMISSION_COPY[this.locale];
+    if (option?.kind === "allow_always") {
+      if (option.optionId === "proceed_always_project") {
+        return localizedScopedAlwaysLabel(label, "Always Allow in project", copy.allowAlwaysProject);
+      }
+      if (option.optionId === "proceed_always_user") {
+        return localizedScopedAlwaysLabel(label, "Always Allow for user", copy.allowAlwaysUser);
+      }
+      if (option.optionId === "proceed_always" && label === "Allow All Edits") {
+        return copy.allowAlways;
+      }
+      return void 0;
+    }
+    if (label === "Allow" || label === "Allow once")
+      return copy.allowOnce;
+    if (label === "Deny" || label === "Reject")
+      return copy.deny;
+    return void 0;
   }
   approvalOption(pending) {
     const options = pending.request.options;
@@ -6245,13 +6303,14 @@ ${promptText}` : promptText;
     return options.find((option) => option.optionId === `proceed_always_${scope}`);
   }
   approvalAlwaysLabel(option) {
+    const copy = PERMISSION_COPY[this.locale];
     if (option.optionId === "proceed_always_project") {
-      return "always allow for this project";
+      return copy.allowAlwaysProject;
     }
     if (option.optionId === "proceed_always_user") {
-      return "always allow for this user";
+      return copy.allowAlwaysUser;
     }
-    return "always allow";
+    return copy.allowAlways;
   }
   denialResponse(pending) {
     const option = this.denialOption(pending);
@@ -6317,7 +6376,7 @@ ${requestList}`);
     }
     let accepted;
     try {
-      accepted = pending.userInputPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
+      accepted = pending.userInputPresented || pending.permissionPresented ? await this.respondToUserInput(pending, response) : await this.bridge.respondToPermission(pending.requestId, response);
     } catch (err) {
       this.removePendingPermission(pending.requestId);
       process.stderr.write(`[${this.name}] permission response failed for request ${sanitizeLogText(pending.requestId, 128)}: ${this.lifecycleError(err)}
@@ -7629,17 +7688,8 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
     const active = this.activePrompts.get(sessionId);
     return active?.senderName || active?.senderId || target.senderId || "agent";
   }
-  stopActiveStreaming(active, sessionId, reason) {
-    try {
-      active.stopStreaming?.();
-    } catch (err) {
-      process.stderr.write(`[${this.name}] stopStreaming threw during ${reason} for session ${sessionId}: ${err instanceof Error ? err.message : err}
-`);
-    }
-  }
   /**
-   * Cancel the active turn and wait (bounded) for it to wind down. Stops the
-   * BlockStreamer so buffered text can't leak via the idle timer, then fires a
+   * Cancel the active turn and wait (bounded) for it to wind down. Fires a
    * best-effort cancelSession (NOT awaited — a wedged child/daemon can leave the
    * request pending forever). Returns true if active.done settled first, false
    * if the CLEAR_CANCEL_TIMEOUT_MS bound won (the turn never wound down). Used by
@@ -7650,7 +7700,6 @@ ${sanitizePromptText(entry.text).trim()}` : `No channel memory entry ${intent.id
    */
   async cancelAndAwaitActive(active, sessionId) {
     active.cancelled = true;
-    this.stopActiveStreaming(active, sessionId, "cancel");
     void this.bridge.cancelSession(sessionId).catch((err) => {
       process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (clear/await): ${err instanceof Error ? err.message : err}
 `);
@@ -8340,7 +8389,6 @@ ${promptText}`;
           if (firstCancellation) {
             process.stderr.write(`[${this.name}] steer: cancelled active turn for ${envelope.senderId} in session ${sessionId}
 `);
-            this.stopActiveStreaming(active, sessionId, "steer");
             void this.bridge.cancelSession(sessionId).catch((err) => {
               process.stderr.write(`[${this.name}] cancelSession failed for session=${sessionId} (steer): ${err instanceof Error ? err.message : err}
 `);
@@ -8375,7 +8423,6 @@ ${promptText}`;
     }
     const prev = this.sessionQueues.get(sessionId) ?? Promise.resolve();
     const generation = namedTurn?.generation ?? this.sessionGenerations.get(sessionId) ?? 0;
-    const useBlockStreaming = this.config.blockStreaming === "on";
     if (namedTurn) {
       namedTurn.claimed = true;
     } else {
@@ -8478,18 +8525,9 @@ ${promptToSend}`;
         process.stderr.write(`[${this.name}] onPromptStart threw for session ${sessionId}: ${this.lifecycleError(err)}
 `);
       }
-      const streamer = useBlockStreaming ? new BlockStreamer({
-        minChars: this.config.blockStreamingChunk?.minChars ?? 400,
-        maxChars: this.config.blockStreamingChunk?.maxChars ?? 1e3,
-        idleMs: this.config.blockStreamingCoalesce?.idleMs ?? 1500,
-        send: /* @__PURE__ */ __name((text) => this.sendResponseMessage(envelope.chatId, text, sessionId, sourceLabel), "send")
-      }) : null;
-      promptState.stopStreaming = () => streamer?.stop();
       const heldChunks = [];
-      let hasStreamedText = false;
       const releaseHeldChunks = /* @__PURE__ */ __name(() => {
         for (const held of heldChunks.splice(0)) {
-          hasStreamedText = true;
           const segment = this.ensureOutputSegment(sessionId, promptState);
           this.emitTaskLifecycle({
             ...this.lifecycleBase(envelope.chatId, sessionId, envelope.messageId),
@@ -8497,7 +8535,6 @@ ${promptToSend}`;
             chunk: held
           });
           this.onResponseChunk(envelope.chatId, held, sessionId, segment);
-          streamer?.push(held);
         }
       }, "releaseHeldChunks");
       const onChunk = /* @__PURE__ */ __name((sid, chunk) => {
@@ -8514,10 +8551,8 @@ ${promptToSend}`;
           return;
         }
         heldChunks.length = 0;
-        hasStreamedText = false;
         const segment = this.closeOutputSegment(sessionId, promptState);
         void this.notifyOutputSegmentEnd(envelope.chatId, sessionId, segment, "response_boundary");
-        streamer?.stop();
       }, "onResponseBoundary");
       await this.waitForBridgeRecovery();
       const promptBridge = this.bridge;
@@ -8536,17 +8571,10 @@ ${promptToSend}`;
         }
         if (!promptState.cancelled && response) {
           promptState.deliveryStarted = true;
-          if (streamer) {
-            if (!hasStreamedText) {
-              streamer.push(response);
-            }
-            await streamer.flush();
-          } else {
-            const segment = this.ensureOutputSegment(sessionId, promptState);
-            await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
-            if (segment && promptState.activeSegmentId === segment.segmentId) {
-              promptState.activeSegmentId = void 0;
-            }
+          const segment = this.ensureOutputSegment(sessionId, promptState);
+          await this.onResponseComplete(envelope.chatId, response, sessionId, segment);
+          if (segment && promptState.activeSegmentId === segment.segmentId) {
+            promptState.activeSegmentId = void 0;
           }
         }
         if (!promptState.deliveryStarted) {
@@ -8591,10 +8619,6 @@ ${promptToSend}`;
       } finally {
         promptBridge.off("textChunk", onChunk);
         promptBridge.off("responseBoundary", onResponseBoundary);
-        if (streamer) {
-          streamer.stop();
-          await streamer.drain();
-        }
         const stillCurrent = this.activePrompts.get(sessionId) === promptState;
         if (!promptState.clearEvicted) {
           try {

package/chunks/{chunk-LBKYQ33T.js → chunk-WK7P62DV.js}

@@ -3,7 +3,7 @@
 import {
   buildModelReasoningConfigPreview,
   resolvePersistedReasoningConfigState
-} from "./chunk-2OR32P5M.js";
+} from "./chunk-ZN5TKAVR.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -12,7 +12,7 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-7GZCCHJL.js";
+} from "./chunk-7LTCFO6T.js";
 import {
   snapshotProcessEnv
 } from "./chunk-6RZX2HIH.js";
@@ -21,10 +21,10 @@ import {
 } from "./chunk-FETY36NQ.js";
 import {
   loadSettings
-} from "./chunk-Q2F43WTJ.js";
+} from "./chunk-WBU2PIZ5.js";
 import {
   ModelsConfig
-} from "./chunk-43CI6YWJ.js";
+} from "./chunk-HJ5UJQQL.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
@@ -121,19 +121,25 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
         providers.set(authType, provider);
       }
       const isCurrent = currentAuth === model.authType && currentAcpModelId === modelId;
+      const resolved = modelId.startsWith(ACP_ROUTE_ID_PREFIX) ? void 0 : modelsConfig.getResolvedModel(
+        model.authType,
+        model.id,
+        model.registryBaseUrl ?? model.baseUrl
+      );
       const configOptions = modelId.startsWith(ACP_ROUTE_ID_PREFIX) ? void 0 : buildModelReasoningConfigPreview(
         model.id,
         resolvePersistedReasoningConfigState(
           model.id,
           settings.model?.reasoningEffort,
-          modelsConfig.getResolvedModel(
-            model.authType,
-            model.id,
-            model.registryBaseUrl ?? model.baseUrl
-          )?.generationConfig.thinkingMandatory === true,
+          resolved?.generationConfig.thinkingMandatory === true,
           model.capabilities?.reasoning
         ),
-        model.capabilities?.reasoning
+        model.capabilities?.reasoning,
+        resolved ? {
+          ...resolved.generationConfig,
+          model: model.id,
+          baseUrl: resolved.baseUrl
+        } : void 0
       );
       const providerModel = {
         modelId,

package/chunks/{chunk-ULY4ISY2.js → chunk-WXD7INFV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   formatDuration
-} from "./chunk-3SH53ANB.js";
+} from "./chunk-22GORRNY.js";
 import {
   theme
 } from "./chunk-4LIPOIXS.js";
@@ -36,18 +36,18 @@ import {
 } from "./chunk-CRZBDVP2.js";
 import {
   isGoalCheckpointBookkeepingRecord
-} from "./chunk-BL6B2QS2.js";
+} from "./chunk-GOEVQADN.js";
 import {
   GoalPersistenceUnavailableError,
   getToolResponseDisplayText,
   parseGoalStateRecordPayloadV2
-} from "./chunk-43CI6YWJ.js";
+} from "./chunk-HJ5UJQQL.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   projectUserTranscriptForDisplay
-} from "./chunk-FDOGGKAA.js";
+} from "./chunk-GSFV5RQW.js";
 import {
   ToolDisplayNames
 } from "./chunk-MWIO7MF6.js";
@@ -2419,6 +2419,19 @@ var ICON = {
   CHECK: `\u2713${_VS15}`,
   CROSS: `\u2716${_VS15}`
 };
+var SPINNER_FRAMES = [
+  "\u280B",
+  "\u2819",
+  "\u2839",
+  "\u2838",
+  "\u283C",
+  "\u2834",
+  "\u2826",
+  "\u2827",
+  "\u2807",
+  "\u280F"
+];
+var SPINNER_INTERVAL_MS = 80;
 
 // packages/cli/src/ui/components/shared/ToolStatusIndicator.tsx
 init_esbuild_shims();
@@ -3493,6 +3506,8 @@ export {
   SHELL_COMMAND_NAME,
   SHELL_NAME,
   ICON,
+  SPINNER_FRAMES,
+  SPINNER_INTERVAL_MS,
   wrapAnsi,
   SCREEN_READER_USER_PREFIX,
   SCREEN_READER_MODEL_PREFIX,

package/chunks/{chunk-ZIPYCXQP.js → chunk-WXPPUPHM.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   parseRule
-} from "./chunk-43CI6YWJ.js";
+} from "./chunk-HJ5UJQQL.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";