@qwen-code/qwen-code 0.19.11 → 0.19.12-preview.0

package/chunks/{chunk-YLSSEUAM.js → chunk-675SVDMD.js}

@@ -4,44 +4,51 @@ import {
   handleAtCommand,
   resolveAtCommandQuery,
   sanitizeDisplayText
-} from "./chunk-HASK4LMI.js";
+} from "./chunk-IKLWU6YS.js";
 import {
   isAtCommand,
   isBtwCommand,
   isSlashCommand,
-  normalizePartList,
-  recordGoalStatusItem
-} from "./chunk-THXDQSTA.js";
+  normalizePartList
+} from "./chunk-IQRQVPGN.js";
 import {
+  findLastSafeSplitPoint,
   fitPendingSlice,
+  getEnclosingFenceInfo,
+  splitFencedMarkdown,
   useSessionStats
-} from "./chunk-BYB3GF2T.js";
+} from "./chunk-JCYMQU5F.js";
 import {
   SHELL_COMMAND_NAME,
   isCollapsibleTool
-} from "./chunk-NVTQZXR7.js";
+} from "./chunk-6QGZVKOO.js";
+import {
+  themeManager
+} from "./chunk-XAAEDML2.js";
+import {
+  recordGoalStatusItem
+} from "./chunk-WACI4VES.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
-import {
-  themeManager
-} from "./chunk-Q6TUALBE.js";
 import {
   formatMemoryUsage
 } from "./chunk-E5Z2AVNV.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-ZIXOTAPZ.js";
+} from "./chunk-2DZ7E27L.js";
 import {
   t
-} from "./chunk-4AGTGMCQ.js";
+} from "./chunk-3PE7OY2G.js";
 import {
   AutonomousLoopTickResolver,
   CoreToolScheduler,
   ShellExecutionService,
   activeGoalEquals,
+  clampInlineMediaPart,
   clearActiveGoal,
   compactToolResultDisplayForHistory,
+  convertToFunctionErrorResponse,
   createDuplicateProviderToolCallResponse,
   detectAutonomousSentinel,
   findRepeatedDuplicateProviderToolCall,
@@ -54,13 +61,15 @@ import {
   promptIdContext,
   refreshMemoryAfterManagedWrite,
   setActiveGoal
-} from "./chunk-NJOFRXTM.js";
+} from "./chunk-6TDA4EVC.js";
 import {
   ApiCancelEvent,
   ConversationFinishedEvent,
   UserPromptEvent,
   UserRetryEvent,
+  formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
+  getFullTurnVisionModelSelector,
   hasImageParts,
   logApiCancel,
   logConversationFinishedEvent,
@@ -69,27 +78,27 @@ import {
   runVisionBridge,
   shouldRunVisionBridge,
   splitImageParts
-} from "./chunk-MQOVXZAF.js";
+} from "./chunk-YN2I5I42.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-FBU7WRZI.js";
+} from "./chunk-LPHGXXZX.js";
 import {
   ToolNames,
   isShellProgressData
-} from "./chunk-JGUT3LWZ.js";
+} from "./chunk-ANRANWVE.js";
 import {
   getUnsupportedImageFormatWarning,
   isSupportedImageMimeType
 } from "./chunk-FEOZBUMT.js";
 import {
   FinishReason
-} from "./chunk-4LD5APFL.js";
+} from "./chunk-TYQMGACW.js";
 import {
   UnauthorizedError,
   createDebugLogger,
   getErrorMessage,
   isNodeError
-} from "./chunk-7NFB7LBQ.js";
+} from "./chunk-UE5TZ55T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -107,31 +116,6 @@ function useDualOutput() {
 }
 __name(useDualOutput, "useDualOutput");
 
-// packages/cli/src/utils/midTurnUserMessage.ts
-init_esbuild_shims();
-var MID_TURN_USER_MESSAGE_PREFIX = "\n[User message received during tool execution]: ";
-function prefixMidTurnUserMessageParts(parts, displayText) {
-  const partArray = normalizePartList(parts);
-  if (partArray.length === 0) {
-    return [{ text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` }];
-  }
-  const [firstPart, ...rest] = partArray;
-  if ("text" in firstPart && typeof firstPart.text === "string") {
-    return [
-      {
-        ...firstPart,
-        text: `${MID_TURN_USER_MESSAGE_PREFIX}${firstPart.text}`
-      },
-      ...rest
-    ];
-  }
-  return [
-    { text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` },
-    ...partArray
-  ];
-}
-__name(prefixMidTurnUserMessageParts, "prefixMidTurnUserMessageParts");
-
 // packages/cli/src/ui/hooks/useGeminiStream.ts
 init_esbuild_shims();
 var import_react5 = __toESM(require_react(), 1);
@@ -424,103 +408,6 @@ ${finalOutput}`;
   return { handleShellCommand, activeShellPtyId };
 }, "useShellCommandProcessor");
 
-// packages/cli/src/ui/utils/markdownUtilities.ts
-init_esbuild_shims();
-var findNextFence = /* @__PURE__ */ __name((content, from) => {
-  const backtick = content.indexOf("```", from);
-  const tilde = content.indexOf("~~~", from);
-  if (backtick === -1 && tilde === -1) return null;
-  let index;
-  let char;
-  if (tilde === -1 || backtick !== -1 && backtick < tilde) {
-    index = backtick;
-    char = "`";
-  } else {
-    index = tilde;
-    char = "~";
-  }
-  let length = 0;
-  while (content[index + length] === char) length++;
-  return { index, char, length };
-}, "findNextFence");
-var isIndexInsideCodeBlock = /* @__PURE__ */ __name((content, indexToTest) => {
-  let openChar = "";
-  let openLen = 0;
-  let searchPos = 0;
-  while (searchPos < content.length) {
-    const fence = findNextFence(content, searchPos);
-    if (!fence || fence.index >= indexToTest) break;
-    if (openChar === "") {
-      openChar = fence.char;
-      openLen = fence.length;
-    } else if (fence.char === openChar && fence.length >= openLen) {
-      openChar = "";
-      openLen = 0;
-    }
-    searchPos = fence.index + fence.length;
-  }
-  return openChar !== "";
-}, "isIndexInsideCodeBlock");
-var findEnclosingCodeBlockStart = /* @__PURE__ */ __name((content, index) => {
-  let openChar = "";
-  let openLen = 0;
-  let openIndex = -1;
-  let searchPos = 0;
-  while (searchPos < content.length) {
-    const fence = findNextFence(content, searchPos);
-    if (!fence || fence.index >= index) break;
-    if (openChar === "") {
-      openChar = fence.char;
-      openLen = fence.length;
-      openIndex = fence.index;
-    } else if (fence.char === openChar && fence.length >= openLen) {
-      openChar = "";
-      openLen = 0;
-      openIndex = -1;
-    }
-    searchPos = fence.index + fence.length;
-  }
-  return openChar !== "" ? openIndex : -1;
-}, "findEnclosingCodeBlockStart");
-var findLastSafeSplitPoint = /* @__PURE__ */ __name((content, idealMaxLength) => {
-  const hasLengthCap = idealMaxLength !== void 0;
-  const searchEnd = hasLengthCap ? Math.min(Math.max(idealMaxLength, 0), content.length) : content.length;
-  if (hasLengthCap && content.length <= searchEnd) {
-    return content.length;
-  }
-  const enclosingBlockStart = findEnclosingCodeBlockStart(content, searchEnd);
-  if (enclosingBlockStart !== -1) {
-    return hasLengthCap && enclosingBlockStart === 0 ? searchEnd : enclosingBlockStart;
-  }
-  let searchStartIndex = searchEnd;
-  while (searchStartIndex >= 0) {
-    const dnlIndex = content.lastIndexOf("\n\n", searchStartIndex);
-    if (dnlIndex === -1) {
-      break;
-    }
-    const potentialSplitPoint = dnlIndex + 2;
-    if (potentialSplitPoint <= searchEnd && !isIndexInsideCodeBlock(content, potentialSplitPoint)) {
-      return potentialSplitPoint;
-    }
-    searchStartIndex = dnlIndex - 1;
-  }
-  if (hasLengthCap) {
-    searchStartIndex = searchEnd;
-    while (searchStartIndex >= 0) {
-      const nlIndex = content.lastIndexOf("\n", searchStartIndex);
-      if (nlIndex === -1) {
-        break;
-      }
-      const potentialSplitPoint = nlIndex + 1;
-      if (potentialSplitPoint <= searchEnd && !isIndexInsideCodeBlock(content, potentialSplitPoint)) {
-        return potentialSplitPoint;
-      }
-      searchStartIndex = nlIndex - 1;
-    }
-  }
-  return hasLengthCap ? searchEnd : content.length;
-}, "findLastSafeSplitPoint");
-
 // packages/cli/src/ui/hooks/useStateAndRef.ts
 init_esbuild_shims();
 var import_react3 = __toESM(require_react(), 1);
@@ -621,10 +508,60 @@ function useReactToolScheduler(onComplete, config, getPreferredEditor, onEditorC
     ]
   );
   const schedule = (0, import_react4.useCallback)(
-    (request, signal) => {
-      void scheduler.schedule(request, signal);
+    (request, signal, modelOverride) => {
+      if (!modelOverride?.endsWith("\0")) {
+        void scheduler.schedule(request, signal);
+        return;
+      }
+      void (async () => {
+        try {
+          const runtimeView = await config.getBaseLlmClient().resolveForModel(modelOverride.slice(0, -1), {
+            failClosed: true
+          });
+          await scheduler.schedule(request, signal, runtimeView);
+        } catch (error) {
+          debugLogger2.error(
+            `Full-turn tool scheduling failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+          const message = "Full-turn tool scheduling failed. The tool was not executed.";
+          const requests = Array.isArray(request) ? request : [request];
+          const completedCalls = requests.map(
+            (toolRequest) => {
+              const toolError = new Error(message);
+              const responseParts = convertToFunctionErrorResponse(
+                toolRequest.name,
+                toolRequest.callId,
+                message,
+                message
+              );
+              config.getChatRecordingService()?.recordToolResult(responseParts, {
+                callId: toolRequest.callId,
+                status: "error",
+                resultDisplay: message,
+                error: toolError,
+                errorType: "unhandled_exception" /* UNHANDLED_EXCEPTION */
+              });
+              return {
+                status: "error",
+                request: toolRequest,
+                response: {
+                  callId: toolRequest.callId,
+                  responseParts,
+                  resultDisplay: message,
+                  error: toolError,
+                  errorType: "unhandled_exception" /* UNHANDLED_EXCEPTION */,
+                  contentLength: message.length
+                }
+              };
+            }
+          );
+          setToolCallsForDisplay((prev) => [...prev, ...completedCalls]);
+          await allToolCallsCompleteHandler(completedCalls);
+          return;
+        }
+      })();
     },
-    [scheduler]
+    [allToolCallsCompleteHandler, config, scheduler]
   );
   const markToolsAsSubmitted = (0, import_react4.useCallback)(
     (callIdsToMark) => {
@@ -957,7 +894,7 @@ function charIndexAfterLine(text, keptLines) {
   return -1;
 }
 __name(charIndexAfterLine, "charIndexAfterLine");
-var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config, isConfigInitialized, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, midTurnDrainRef, logger, availableTerminalHeightRef, terminalWidthRef) => {
+var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, config, isConfigInitialized, settings, onDebugMessage, handleSlashCommand, shellModeActive, getPreferredEditor, onAuthError, performMemoryRefresh, modelSwitchedFromQuotaError, setModelSwitchedFromQuotaError, onEditorClose, onCancelSubmit, setShellInputFocused, terminalWidth, terminalHeight, midTurnDrainRef, logger, availableTerminalHeightRef, terminalWidthRef, midTurnRestoreRef) => {
   const [initError, setInitError] = (0, import_react5.useState)(null);
   const abortControllerRef = (0, import_react5.useRef)(null);
   const flushBufferedStreamEventsRef = (0, import_react5.useRef)(/* @__PURE__ */ new Set());
@@ -1241,10 +1178,45 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   ]);
   const applyVisionBridgeIfNeeded = (0, import_react5.useCallback)(
     async (parts, timestamp, signal) => {
-      if (parts === null || !hasImageParts(parts) || !shouldRunVisionBridge(config)) {
+      if (parts === null || !hasImageParts(parts)) {
+        return { parts, shouldProceed: true };
+      }
+      if (modelOverrideRef.current?.endsWith("\0")) {
+        return { parts, shouldProceed: true };
+      }
+      if (inlineModelOverrideActiveRef.current) {
         return { parts, shouldProceed: true };
       }
+      if (!shouldRunVisionBridge(config)) {
+        return { parts, shouldProceed: true };
+      }
+      if (signal.aborted) {
+        return { parts: null, shouldProceed: false };
+      }
       debugLogger3.debug("vision bridge: gate matched, running conversion");
+      const fullTurnModel = config.getDefaultVisionBridgeModel();
+      if (fullTurnModel?.agentCapable) {
+        const fullTurnParts = (Array.isArray(parts) ? parts : [parts]).map(
+          (part) => typeof part === "string" ? { text: part } : clampInlineMediaPart(part)
+        );
+        if (!hasImageParts(fullTurnParts)) {
+          return { parts: fullTurnParts, shouldProceed: true };
+        }
+        applyModelOverride(
+          modelOverrideRef,
+          inlineModelOverrideActiveRef,
+          getFullTurnVisionModelSelector(fullTurnModel),
+          false
+        );
+        addItem(
+          {
+            type: "vision_notice" /* VISION_NOTICE */,
+            text: formatFullTurnVisionNotice(fullTurnModel)
+          },
+          timestamp
+        );
+        return { parts: fullTurnParts, shouldProceed: true };
+      }
       const bridgeResult = await runVisionBridge({ config, parts, signal });
       debugLogger3.debug(
         `vision bridge: status=${bridgeResult.status} applied=${bridgeResult.applied} model=${bridgeResult.modelId ?? "(none)"}`
@@ -1330,6 +1302,15 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
                   );
                 }
               }
+              const bridgeResult2 = await applyVisionBridgeIfNeeded(
+                localQueryToSendToGemini,
+                userMessageTimestamp,
+                abortSignal
+              );
+              if (!bridgeResult2.shouldProceed) {
+                return { queryToSend: null, shouldProceed: false };
+              }
+              localQueryToSendToGemini = bridgeResult2.parts;
               return {
                 queryToSend: localQueryToSendToGemini,
                 shouldProceed: true
@@ -1441,8 +1422,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           STREAM_PENDING_ITEM_MAX_CHARS
         );
         const safeSplitPoint = splitPoint > 0 && splitPoint < newGeminiMessageBuffer.length ? splitPoint : STREAM_PENDING_ITEM_MAX_CHARS;
-        const beforeText = newGeminiMessageBuffer.substring(0, safeSplitPoint);
-        const afterText = newGeminiMessageBuffer.substring(safeSplitPoint);
+        const { before: beforeText, after: afterText } = splitFencedMarkdown(
+          newGeminiMessageBuffer,
+          safeSplitPoint
+        );
         commitItem(
           {
             type: nextPendingType,
@@ -1476,12 +1459,21 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             break;
           }
         }
-        if (boundaryLine < 0) break;
-        const target = charIndexAfterLine(
-          newGeminiMessageBuffer,
-          boundaryLine + 1
-        );
-        if (target <= 0) break;
+        let target;
+        if (boundaryLine < 0) {
+          const capIndex = charIndexAfterLine(
+            newGeminiMessageBuffer,
+            keptLines
+          );
+          const fenceInfo = capIndex > 0 ? getEnclosingFenceInfo(newGeminiMessageBuffer, capIndex) : null;
+          if (!fenceInfo || fenceInfo.lang?.toLowerCase() === "mermaid") {
+            break;
+          }
+          target = capIndex;
+        } else {
+          target = charIndexAfterLine(newGeminiMessageBuffer, boundaryLine + 1);
+          if (target <= 0) break;
+        }
         const splitPoint = findLastSafeSplitPoint(
           newGeminiMessageBuffer,
           target
@@ -1489,8 +1481,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         if (splitPoint <= 0 || splitPoint >= newGeminiMessageBuffer.length) {
           break;
         }
-        const beforeText = newGeminiMessageBuffer.substring(0, splitPoint);
-        const afterText = newGeminiMessageBuffer.substring(splitPoint);
+        const { before: beforeText, after: afterText } = splitFencedMarkdown(
+          newGeminiMessageBuffer,
+          splitPoint
+        );
         commitItem(
           {
             type: nextPendingType,
@@ -1592,8 +1586,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       );
       while (newThoughtBuffer.length > STREAM_PENDING_ITEM_MAX_CHARS) {
         const safeSplitPoint = splitPoint > 0 && splitPoint < newThoughtBuffer.length ? splitPoint : STREAM_PENDING_ITEM_MAX_CHARS;
-        const beforeText = newThoughtBuffer.substring(0, safeSplitPoint);
-        const afterText = newThoughtBuffer.substring(safeSplitPoint);
+        const { before: beforeText, after: afterText } = splitFencedMarkdown(
+          newThoughtBuffer,
+          safeSplitPoint
+        );
         addItem(
           buildThoughtItem(pendingThoughtType, beforeText),
           userMessageTimestamp
@@ -1873,6 +1869,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           kind: "checking",
           condition: activeGoal.condition,
           iterations: activeGoal.iterations,
+          // Carried so a transcript truncated past its `set` card can still
+          // restore the goal's original start time.
+          setAt: activeGoal.setAt,
           lastReason: activeGoal.lastReason ?? value.reasons[value.reasons.length - 1]
         };
         addItem(item, userMessageTimestamp);
@@ -2212,7 +2211,11 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           }
         }
         if (executableToolCallRequests.length > 0) {
-          scheduleToolCalls(executableToolCallRequests, signal);
+          scheduleToolCalls(
+            executableToolCallRequests,
+            signal,
+            modelOverrideRef.current
+          );
         }
       }
       return 0 /* Completed */;
@@ -2244,20 +2247,185 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       dualOutput
     ]
   );
+  const resolveSteeredMessages = (0, import_react5.useCallback)(
+    async (messages, signal) => {
+      const resolvedMessages = [];
+      const resolvedForRecording = [];
+      const timestamp = Date.now();
+      for (let index = 0; index < messages.length; index += 1) {
+        if (signal.aborted) break;
+        const message = messages[index];
+        const sideEffects = [];
+        let resolvedQuery = [{ text: message }];
+        if (isAtCommand(message)) {
+          const timeout = new AbortController();
+          const atCommandSignal = AbortSignal.any([signal, timeout.signal]);
+          const timeoutId = setTimeout(() => {
+            timeout.abort(
+              new Error(MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MESSAGE)
+            );
+          }, MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MS);
+          try {
+            const atCommandResult = await resolveWithAbort(
+              atCommandSignal,
+              () => resolveAtCommandQuery({
+                query: message,
+                config,
+                onDebugMessage,
+                messageId: timestamp + index,
+                signal: atCommandSignal
+              })
+            );
+            const shouldSkipMessage = !atCommandResult.shouldProceed && (atCommandResult.toolDisplays?.length ?? 0) > 0;
+            if (atCommandResult.shouldProceed && atCommandResult.processedQuery !== null) {
+              resolvedQuery = atCommandResult.processedQuery;
+            } else if (atCommandResult.toolDisplays?.length) {
+              const toolDisplays = atCommandResult.toolDisplays;
+              const showToolDisplays = /* @__PURE__ */ __name(() => addItem(
+                { type: "tool_group", tools: toolDisplays },
+                timestamp + index
+              ), "showToolDisplays");
+              if (shouldSkipMessage) showToolDisplays();
+              else sideEffects.push(showToolDisplays);
+            }
+            if (atCommandResult.recording) {
+              const recordAtCommand = /* @__PURE__ */ __name(() => config.getChatRecordingService?.()?.recordAtCommand?.({
+                filesRead: atCommandResult.recording.filesRead,
+                status: atCommandResult.recording.status,
+                ...atCommandResult.recording.message ? { message: atCommandResult.recording.message } : {},
+                userText: message
+              }), "recordAtCommand");
+              if (shouldSkipMessage) recordAtCommand();
+              else sideEffects.push(recordAtCommand);
+            }
+            if (shouldSkipMessage) continue;
+          } catch (error) {
+            const errorMessage = getErrorMessage(error);
+            onDebugMessage(
+              `Failed to resolve mid-turn @ command: ${errorMessage}`
+            );
+            if (!signal.aborted) {
+              addItem(
+                {
+                  type: "warning" /* WARNING */,
+                  text: `Could not attach file: ${errorMessage}`
+                },
+                Date.now()
+              );
+            }
+            continue;
+          } finally {
+            clearTimeout(timeoutId);
+          }
+          if (signal.aborted) break;
+        }
+        const bridgeResult = await applyVisionBridgeIfNeeded(
+          resolvedQuery,
+          timestamp + index,
+          signal
+        );
+        if (!bridgeResult.shouldProceed) {
+          if (signal.aborted) break;
+          continue;
+        }
+        const messageParts = normalizePartList(
+          bridgeResult.parts ?? resolvedQuery
+        );
+        const formatCheck = checkImageFormatsSupport(messageParts);
+        if (formatCheck.hasUnsupportedFormats) {
+          sideEffects.push(
+            () => addItem(
+              {
+                type: "info" /* INFO */,
+                text: getUnsupportedImageFormatWarning()
+              },
+              Date.now()
+            )
+          );
+        }
+        if (resolvedMessages.length > 0 && messageParts.length > 0) {
+          resolvedMessages.push({ text: "\n\n" });
+        }
+        resolvedMessages.push(...messageParts);
+        resolvedForRecording.push({
+          message,
+          parts: messageParts,
+          sideEffects
+        });
+      }
+      if (signal.aborted) return void 0;
+      return {
+        parts: resolvedMessages,
+        accept: /* @__PURE__ */ __name(() => {
+          for (const { message, parts, sideEffects } of resolvedForRecording) {
+            for (const sideEffect of sideEffects) sideEffect();
+            config.getChatRecordingService?.()?.recordMidTurnUserMessage(parts, message);
+            addItem(
+              { type: "notification" /* NOTIFICATION */, text: message },
+              Date.now()
+            );
+          }
+        }, "accept")
+      };
+    },
+    [addItem, applyVisionBridgeIfNeeded, config, onDebugMessage]
+  );
+  const resolveDrainedSteerMessages = (0, import_react5.useCallback)(
+    async (messages, signal) => {
+      try {
+        const resolved = await resolveSteeredMessages(messages, signal);
+        if (signal.aborted) {
+          midTurnRestoreRef?.current?.(messages);
+          return void 0;
+        }
+        if (!resolved || resolved.parts.length === 0) return void 0;
+        let settled = false;
+        return {
+          parts: resolved.parts,
+          accept: /* @__PURE__ */ __name(() => {
+            if (settled) return;
+            settled = true;
+            resolved.accept();
+          }, "accept"),
+          restore: /* @__PURE__ */ __name(() => {
+            if (settled) return;
+            settled = true;
+            midTurnRestoreRef?.current?.(messages);
+          }, "restore")
+        };
+      } catch (error) {
+        midTurnRestoreRef?.current?.(messages);
+        onDebugMessage(
+          `Failed to prepare steer input: ${getErrorMessage(error)}`
+        );
+        return void 0;
+      }
+    },
+    [midTurnRestoreRef, onDebugMessage, resolveSteeredMessages]
+  );
+  const drainSteerAtBoundary = (0, import_react5.useCallback)(
+    async (signal) => {
+      const messages = midTurnDrainRef?.current?.() ?? [];
+      if (messages.length === 0) return void 0;
+      return resolveDrainedSteerMessages(messages, signal);
+    },
+    [midTurnDrainRef, resolveDrainedSteerMessages]
+  );
   const submitQuery = (0, import_react5.useCallback)(
     async (query, submitType = "userQuery" /* UserQuery */, prompt_id, metadata) => {
       const allowConcurrentBtwDuringResponse = submitType === "userQuery" /* UserQuery */ && streamingState === "responding" /* Responding */ && typeof query === "string" && isBtwCommand(query);
-      if (isSubmittingQueryRef.current && submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
+      const isTurnContinuation = submitType === "toolResult" /* ToolResult */ || submitType === "steer" /* Steer */;
+      if (isSubmittingQueryRef.current && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
         metadata?.onDeliveryFailed?.();
         return;
       }
-      if ((streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */) && submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
+      if ((streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */) && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
         metadata?.onDeliveryFailed?.();
         return;
       }
       isSubmittingQueryRef.current = true;
       loopDetectedRef.current = false;
-      if (submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
+      if (!isTurnContinuation && !allowConcurrentBtwDuringResponse) {
         lastTurnUserItemRef.current = null;
         turnSawContentEventRef.current = false;
         handledProviderToolCallIdsRef.current.clear();
@@ -2266,7 +2434,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         immediateDuplicateToolResponsesRef.current = null;
       }
       const userMessageTimestamp = Date.now();
-      if (submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
+      if (!isTurnContinuation && submitType !== "notification" /* Notification */ && !allowConcurrentBtwDuringResponse) {
         setModelSwitchedFromQuotaError(false);
         const droppingInlineOverrideOnRetry = submitType === "retry" /* Retry */ && inlineModelOverrideActiveRef.current;
         if (submitType !== "retry" /* Retry */ || inlineModelOverrideActiveRef.current) {
@@ -2351,7 +2519,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         setIsResponding(true);
         setInitError(null);
         setIsReceivingContent(false);
-        if (submitType !== "toolResult" /* ToolResult */) {
+        if (!isTurnContinuation) {
           streamingResponseLengthRef.current = 0;
         }
         try {
@@ -2369,7 +2537,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             {
               type: submitType,
               notificationDisplayText: metadata?.notificationDisplayText,
-              modelOverride: modelOverrideRef.current
+              modelOverride: modelOverrideRef.current,
+              steerInput: metadata?.steerInput,
+              ...!allowConcurrentBtwDuringResponse && midTurnDrainRef ? { getSteerInput: drainSteerAtBoundary } : {}
             }
           );
           const processingStatus = await processGeminiStreamEvents(
@@ -2399,7 +2569,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           if (retryCountdownTimerRef.current) {
             clearRetryCountdown();
           }
-          if (loopDetectedRef.current) {
+          const loopDetected = loopDetectedRef.current;
+          if (loopDetected) {
             loopDetectedRef.current = false;
             handleLoopDetectedEvent();
           }
@@ -2482,7 +2653,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       pendingRetryErrorItemRef,
       setPendingRetryErrorItem,
       setPendingThoughtItem,
-      dualOutput
+      dualOutput,
+      drainSteerAtBoundary,
+      midTurnDrainRef
     ]
   );
   const retryLastPrompt = (0, import_react5.useCallback)(async () => {
@@ -2676,11 +2849,11 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       const promptId = prompt_ids[0] ?? pendingDuplicatePromptId;
       for (const toolCall of geminiTools) {
         if ("modelOverride" in toolCall.response) {
-          if (inlineModelOverrideActiveRef.current) {
+          if (inlineModelOverrideActiveRef.current || modelOverrideRef.current?.endsWith("\0")) {
             debugLogger3.debug(
               `skill-tool model override (${String(
                 toolCall.response.modelOverride
-              )}) blocked: inline override active`
+              )}) blocked: ${inlineModelOverrideActiveRef.current ? "inline override active" : "full-turn override active"}`
             );
           } else {
             applyModelOverride(
@@ -2750,115 +2923,20 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         return;
       }
       const drained = turnCancelledRef.current || abortControllerRef.current?.signal.aborted ? [] : midTurnDrainRef?.current?.() ?? [];
+      let drainedSteer;
       if (drained.length > 0) {
-        const midTurnTimestamp = Date.now();
         const midTurnAbort = abortControllerRef.current ?? new AbortController();
         const shouldTrackMidTurnAbort = !abortControllerRef.current;
         if (shouldTrackMidTurnAbort) {
           auxiliaryAbortRefsRef.current.add(midTurnAbort);
         }
         try {
-          for (let index = 0; index < drained.length; index += 1) {
-            if (midTurnAbort.signal.aborted) {
-              break;
-            }
-            const msg = drained[index];
-            let resolvedMidTurnQuery = [{ text: msg }];
-            if (isAtCommand(msg)) {
-              const atCommandTimeout = new AbortController();
-              const atCommandSignal = AbortSignal.any([
-                midTurnAbort.signal,
-                atCommandTimeout.signal
-              ]);
-              const atCommandTimeoutId = setTimeout(() => {
-                atCommandTimeout.abort(
-                  new Error(MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MESSAGE)
-                );
-              }, MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MS);
-              try {
-                const atCommandResult = await resolveWithAbort(
-                  atCommandSignal,
-                  () => resolveAtCommandQuery({
-                    query: msg,
-                    config,
-                    onDebugMessage,
-                    messageId: midTurnTimestamp + index,
-                    signal: atCommandSignal
-                  })
-                );
-                const shouldSkipMidTurnMessage = !atCommandResult.shouldProceed && (atCommandResult.toolDisplays?.length ?? 0) > 0;
-                if (atCommandResult.shouldProceed && atCommandResult.processedQuery !== null) {
-                  resolvedMidTurnQuery = atCommandResult.processedQuery;
-                } else if (atCommandResult.toolDisplays?.length) {
-                  addItem(
-                    { type: "tool_group", tools: atCommandResult.toolDisplays },
-                    midTurnTimestamp + index
-                  );
-                }
-                if (atCommandResult.recording) {
-                  config.getChatRecordingService?.()?.recordAtCommand?.({
-                    filesRead: atCommandResult.recording.filesRead,
-                    status: atCommandResult.recording.status,
-                    ...atCommandResult.recording.message ? { message: atCommandResult.recording.message } : {},
-                    userText: msg
-                  });
-                }
-                if (shouldSkipMidTurnMessage) {
-                  continue;
-                }
-              } catch (error) {
-                const errorMessage = getErrorMessage(error);
-                onDebugMessage(
-                  `Failed to resolve mid-turn @ command: ${errorMessage}`
-                );
-                if (!midTurnAbort.signal.aborted) {
-                  addItem(
-                    {
-                      type: "warning" /* WARNING */,
-                      text: `Could not attach file: ${errorMessage}`
-                    },
-                    Date.now()
-                  );
-                }
-                continue;
-              } finally {
-                clearTimeout(atCommandTimeoutId);
-              }
-              if (midTurnAbort.signal.aborted) {
-                break;
-              }
-            }
-            const bridgeResult = await applyVisionBridgeIfNeeded(
-              resolvedMidTurnQuery,
-              midTurnTimestamp + index,
-              midTurnAbort.signal
-            );
-            if (!bridgeResult.shouldProceed) {
-              if (midTurnAbort.signal.aborted) {
-                break;
-              }
-              continue;
-            }
-            resolvedMidTurnQuery = bridgeResult.parts ?? resolvedMidTurnQuery;
-            const midTurnUserMessageParts = prefixMidTurnUserMessageParts(
-              resolvedMidTurnQuery,
-              msg
-            );
-            const formatCheck = checkImageFormatsSupport(
-              midTurnUserMessageParts
-            );
-            if (formatCheck.hasUnsupportedFormats) {
-              addItem(
-                {
-                  type: "info" /* INFO */,
-                  text: getUnsupportedImageFormatWarning()
-                },
-                Date.now()
-              );
-            }
-            responsesToSend.push(...midTurnUserMessageParts);
-            config.getChatRecordingService?.()?.recordMidTurnUserMessage(midTurnUserMessageParts, msg);
-            addItem({ type: "notification" /* NOTIFICATION */, text: msg }, Date.now());
+          drainedSteer = await resolveDrainedSteerMessages(
+            drained,
+            midTurnAbort.signal
+          );
+          if (drainedSteer) {
+            responsesToSend.push(...drainedSteer.parts);
           }
         } finally {
           if (shouldTrackMidTurnAbort) {
@@ -2868,9 +2946,14 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         }
       }
       if (turnCancelledRef.current || abortControllerRef.current?.signal.aborted) {
+        drainedSteer?.restore();
         return;
       }
-      submitQuery(responsesToSend, "toolResult" /* ToolResult */, promptId);
+      void submitQuery(responsesToSend, "toolResult" /* ToolResult */, promptId, {
+        steerInput: drainedSteer,
+        onDelivered: drainedSteer?.accept,
+        onDeliveryFailed: drainedSteer?.restore
+      });
     },
     [
       submitQuery,
@@ -2882,8 +2965,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       midTurnDrainRef,
       addItem,
       dualOutput,
-      onDebugMessage,
-      applyVisionBridgeIfNeeded
+      resolveDrainedSteerMessages
     ]
   );
   const pendingHistoryItems = (0, import_react5.useMemo)(
@@ -3189,7 +3271,6 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
 }, "useGeminiStream");
 
 export {
-  prefixMidTurnUserMessageParts,
   DualOutputContext,
   useDualOutput,
   classifyApiError,
@@ -3200,11 +3281,6 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
-/**
- * @license
- * Copyright 2026 Qwen
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2025 Google LLC