@qwen-code/qwen-code 0.19.11-nightly.20260718.767a32484 → 0.19.11

package/chunks/{chunk-3X2CFOUM.js → chunk-YLSSEUAM.js}

@@ -4,49 +4,44 @@ import {
   handleAtCommand,
   resolveAtCommandQuery,
   sanitizeDisplayText
-} from "./chunk-GAQOQMHY.js";
+} from "./chunk-HASK4LMI.js";
 import {
   isAtCommand,
   isBtwCommand,
   isSlashCommand,
   normalizePartList,
   recordGoalStatusItem
-} from "./chunk-QPRDXJIC.js";
+} from "./chunk-THXDQSTA.js";
 import {
-  findLastSafeSplitPoint,
   fitPendingSlice,
-  getEnclosingFenceInfo,
-  splitFencedMarkdown,
   useSessionStats
-} from "./chunk-ZTSDZQZO.js";
+} from "./chunk-BYB3GF2T.js";
 import {
   SHELL_COMMAND_NAME,
   isCollapsibleTool
-} from "./chunk-CZSAIBUB.js";
+} from "./chunk-NVTQZXR7.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
 import {
   themeManager
-} from "./chunk-XAAEDML2.js";
+} from "./chunk-Q6TUALBE.js";
 import {
   formatMemoryUsage
 } from "./chunk-E5Z2AVNV.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-6Z5NRZVU.js";
+} from "./chunk-ZIXOTAPZ.js";
 import {
   t
-} from "./chunk-HIMIG6PI.js";
+} from "./chunk-4AGTGMCQ.js";
 import {
   AutonomousLoopTickResolver,
   CoreToolScheduler,
   ShellExecutionService,
   activeGoalEquals,
-  clampInlineMediaPart,
   clearActiveGoal,
   compactToolResultDisplayForHistory,
-  convertToFunctionErrorResponse,
   createDuplicateProviderToolCallResponse,
   detectAutonomousSentinel,
   findRepeatedDuplicateProviderToolCall,
@@ -59,15 +54,13 @@ import {
   promptIdContext,
   refreshMemoryAfterManagedWrite,
   setActiveGoal
-} from "./chunk-3YJZ6WNY.js";
+} from "./chunk-NJOFRXTM.js";
 import {
   ApiCancelEvent,
   ConversationFinishedEvent,
   UserPromptEvent,
   UserRetryEvent,
-  formatFullTurnVisionNotice,
   formatVisionBridgeNotice,
-  getFullTurnVisionModelSelector,
   hasImageParts,
   logApiCancel,
   logConversationFinishedEvent,
@@ -76,27 +69,27 @@ import {
   runVisionBridge,
   shouldRunVisionBridge,
   splitImageParts
-} from "./chunk-66IT3EY2.js";
+} from "./chunk-MQOVXZAF.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-FUTHTZVV.js";
+} from "./chunk-FBU7WRZI.js";
 import {
   ToolNames,
   isShellProgressData
-} from "./chunk-ANRANWVE.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   getUnsupportedImageFormatWarning,
   isSupportedImageMimeType
 } from "./chunk-FEOZBUMT.js";
 import {
   FinishReason
-} from "./chunk-TYQMGACW.js";
+} from "./chunk-4LD5APFL.js";
 import {
   UnauthorizedError,
   createDebugLogger,
   getErrorMessage,
   isNodeError
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -114,6 +107,31 @@ 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);
@@ -406,6 +424,103 @@ ${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);
@@ -506,60 +621,10 @@ function useReactToolScheduler(onComplete, config, getPreferredEditor, onEditorC
     ]
   );
   const schedule = (0, import_react4.useCallback)(
-    (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;
-        }
-      })();
+    (request, signal) => {
+      void scheduler.schedule(request, signal);
     },
-    [allToolCallsCompleteHandler, config, scheduler]
+    [scheduler]
   );
   const markToolsAsSubmitted = (0, import_react4.useCallback)(
     (callIdsToMark) => {
@@ -892,7 +957,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, midTurnRestoreRef) => {
+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) => {
   const [initError, setInitError] = (0, import_react5.useState)(null);
   const abortControllerRef = (0, import_react5.useRef)(null);
   const flushBufferedStreamEventsRef = (0, import_react5.useRef)(/* @__PURE__ */ new Set());
@@ -1176,45 +1241,10 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
   ]);
   const applyVisionBridgeIfNeeded = (0, import_react5.useCallback)(
     async (parts, timestamp, signal) => {
-      if (parts === null || !hasImageParts(parts)) {
-        return { parts, shouldProceed: true };
-      }
-      if (modelOverrideRef.current?.endsWith("\0")) {
-        return { parts, shouldProceed: true };
-      }
-      if (inlineModelOverrideActiveRef.current) {
+      if (parts === null || !hasImageParts(parts) || !shouldRunVisionBridge(config)) {
         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)"}`
@@ -1300,15 +1330,6 @@ 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
@@ -1420,10 +1441,8 @@ 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 { before: beforeText, after: afterText } = splitFencedMarkdown(
-          newGeminiMessageBuffer,
-          safeSplitPoint
-        );
+        const beforeText = newGeminiMessageBuffer.substring(0, safeSplitPoint);
+        const afterText = newGeminiMessageBuffer.substring(safeSplitPoint);
         commitItem(
           {
             type: nextPendingType,
@@ -1457,21 +1476,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             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;
-        }
+        if (boundaryLine < 0) break;
+        const target = charIndexAfterLine(
+          newGeminiMessageBuffer,
+          boundaryLine + 1
+        );
+        if (target <= 0) break;
         const splitPoint = findLastSafeSplitPoint(
           newGeminiMessageBuffer,
           target
@@ -1479,10 +1489,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         if (splitPoint <= 0 || splitPoint >= newGeminiMessageBuffer.length) {
           break;
         }
-        const { before: beforeText, after: afterText } = splitFencedMarkdown(
-          newGeminiMessageBuffer,
-          splitPoint
-        );
+        const beforeText = newGeminiMessageBuffer.substring(0, splitPoint);
+        const afterText = newGeminiMessageBuffer.substring(splitPoint);
         commitItem(
           {
             type: nextPendingType,
@@ -1584,10 +1592,8 @@ 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 { before: beforeText, after: afterText } = splitFencedMarkdown(
-          newThoughtBuffer,
-          safeSplitPoint
-        );
+        const beforeText = newThoughtBuffer.substring(0, safeSplitPoint);
+        const afterText = newThoughtBuffer.substring(safeSplitPoint);
         addItem(
           buildThoughtItem(pendingThoughtType, beforeText),
           userMessageTimestamp
@@ -2206,11 +2212,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           }
         }
         if (executableToolCallRequests.length > 0) {
-          scheduleToolCalls(
-            executableToolCallRequests,
-            signal,
-            modelOverrideRef.current
-          );
+          scheduleToolCalls(executableToolCallRequests, signal);
         }
       }
       return 0 /* Completed */;
@@ -2242,185 +2244,20 @@ 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);
-      const isTurnContinuation = submitType === "toolResult" /* ToolResult */ || submitType === "steer" /* Steer */;
-      if (isSubmittingQueryRef.current && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
+      if (isSubmittingQueryRef.current && submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
         metadata?.onDeliveryFailed?.();
         return;
       }
-      if ((streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */) && !isTurnContinuation && !allowConcurrentBtwDuringResponse) {
+      if ((streamingState === "responding" /* Responding */ || streamingState === "waiting_for_confirmation" /* WaitingForConfirmation */) && submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
         metadata?.onDeliveryFailed?.();
         return;
       }
       isSubmittingQueryRef.current = true;
       loopDetectedRef.current = false;
-      if (!isTurnContinuation && !allowConcurrentBtwDuringResponse) {
+      if (submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
         lastTurnUserItemRef.current = null;
         turnSawContentEventRef.current = false;
         handledProviderToolCallIdsRef.current.clear();
@@ -2429,7 +2266,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         immediateDuplicateToolResponsesRef.current = null;
       }
       const userMessageTimestamp = Date.now();
-      if (!isTurnContinuation && submitType !== "notification" /* Notification */ && !allowConcurrentBtwDuringResponse) {
+      if (submitType !== "toolResult" /* ToolResult */ && !allowConcurrentBtwDuringResponse) {
         setModelSwitchedFromQuotaError(false);
         const droppingInlineOverrideOnRetry = submitType === "retry" /* Retry */ && inlineModelOverrideActiveRef.current;
         if (submitType !== "retry" /* Retry */ || inlineModelOverrideActiveRef.current) {
@@ -2514,7 +2351,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         setIsResponding(true);
         setInitError(null);
         setIsReceivingContent(false);
-        if (!isTurnContinuation) {
+        if (submitType !== "toolResult" /* ToolResult */) {
           streamingResponseLengthRef.current = 0;
         }
         try {
@@ -2532,9 +2369,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
             {
               type: submitType,
               notificationDisplayText: metadata?.notificationDisplayText,
-              modelOverride: modelOverrideRef.current,
-              steerInput: metadata?.steerInput,
-              ...!allowConcurrentBtwDuringResponse && midTurnDrainRef ? { getSteerInput: drainSteerAtBoundary } : {}
+              modelOverride: modelOverrideRef.current
             }
           );
           const processingStatus = await processGeminiStreamEvents(
@@ -2564,8 +2399,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
           if (retryCountdownTimerRef.current) {
             clearRetryCountdown();
           }
-          const loopDetected = loopDetectedRef.current;
-          if (loopDetected) {
+          if (loopDetectedRef.current) {
             loopDetectedRef.current = false;
             handleLoopDetectedEvent();
           }
@@ -2648,9 +2482,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       pendingRetryErrorItemRef,
       setPendingRetryErrorItem,
       setPendingThoughtItem,
-      dualOutput,
-      drainSteerAtBoundary,
-      midTurnDrainRef
+      dualOutput
     ]
   );
   const retryLastPrompt = (0, import_react5.useCallback)(async () => {
@@ -2844,11 +2676,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 || modelOverrideRef.current?.endsWith("\0")) {
+          if (inlineModelOverrideActiveRef.current) {
             debugLogger3.debug(
               `skill-tool model override (${String(
                 toolCall.response.modelOverride
-              )}) blocked: ${inlineModelOverrideActiveRef.current ? "inline override active" : "full-turn override active"}`
+              )}) blocked: inline override active`
             );
           } else {
             applyModelOverride(
@@ -2918,20 +2750,115 @@ 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 {
-          drainedSteer = await resolveDrainedSteerMessages(
-            drained,
-            midTurnAbort.signal
-          );
-          if (drainedSteer) {
-            responsesToSend.push(...drainedSteer.parts);
+          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());
           }
         } finally {
           if (shouldTrackMidTurnAbort) {
@@ -2941,14 +2868,9 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
         }
       }
       if (turnCancelledRef.current || abortControllerRef.current?.signal.aborted) {
-        drainedSteer?.restore();
         return;
       }
-      void submitQuery(responsesToSend, "toolResult" /* ToolResult */, promptId, {
-        steerInput: drainedSteer,
-        onDelivered: drainedSteer?.accept,
-        onDeliveryFailed: drainedSteer?.restore
-      });
+      submitQuery(responsesToSend, "toolResult" /* ToolResult */, promptId);
     },
     [
       submitQuery,
@@ -2960,7 +2882,8 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       midTurnDrainRef,
       addItem,
       dualOutput,
-      resolveDrainedSteerMessages
+      onDebugMessage,
+      applyVisionBridgeIfNeeded
     ]
   );
   const pendingHistoryItems = (0, import_react5.useMemo)(
@@ -3266,6 +3189,7 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
 }, "useGeminiStream");
 
 export {
+  prefixMidTurnUserMessageParts,
   DualOutputContext,
   useDualOutput,
   classifyApiError,
@@ -3276,6 +3200,11 @@ 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