@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.1

package/chunks/{chunk-MFCWL4LI.js → chunk-LNCNUMJ5.js}

@@ -2,19 +2,23 @@
 "use strict";
 import {
   reportChatRecordingFailureToAdapter
-} from "./chunk-R7TKFIQO.js";
+} from "./chunk-CALNF3Z3.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-RRCNEW2A.js";
+} from "./chunk-3VWPPK5Q.js";
 import {
-  ICON
-} from "./chunk-T7TP5UQL.js";
+  ICON,
+  SHELL_COMMAND_NAME
+} from "./chunk-E7XSUYCZ.js";
 import {
   theme
 } from "./chunk-4LIPOIXS.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
+import {
+  themeManager
+} from "./chunk-2XRE4KE4.js";
 import {
   Box_default,
   Text
@@ -24,35 +28,48 @@ import {
 } from "./chunk-5QWWOFGG.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-UTVIIA7N.js";
+} from "./chunk-FW4E4QPG.js";
 import {
   SettingScope,
   settingExistsInScope
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-66JBCTJF.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
+  INITIAL_FOLLOWUP_STATE,
   Logger,
   applyProviderInstallPlan,
   buildInstallPlan,
+  createFollowupController,
   getDefaultBaseUrlForProtocol,
   getDefaultModelIds,
   resolveBaseUrl,
   shouldShowStep
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-ZU2T5JIS.js";
 import {
   qwenOAuth2Events,
   sanitizeForOsc
-} from "./chunk-VU7O7CGQ.js";
+} from "./chunk-XDNFODER.js";
 import {
+  ShellExecutionService,
   allowEditorTypeInSandbox,
-  checkHasEditorType
-} from "./chunk-TSLRORQR.js";
+  checkHasEditorType,
+  compactToolResultDisplayForHistory,
+  isSignalTermination
+} from "./chunk-PDUMGZ2P.js";
+import {
+  formatMemoryUsage
+} from "./chunk-CHEIIBT3.js";
 import {
   AuthEvent,
-  logAuth
-} from "./chunk-WQBR7LN5.js";
+  PromptSuggestionEvent,
+  logAuth,
+  logPromptSuggestion
+} from "./chunk-6QV7Z74P.js";
+import {
+  isBinary
+} from "./chunk-7VEYUF3N.js";
 import {
   createDebugLogger,
   getErrorMessage
@@ -1002,6 +1019,374 @@ var useAuthCommand = /* @__PURE__ */ __name((settings, config, addItem, onAuthCh
   };
 }, "useAuthCommand");
 
+// packages/cli/src/ui/hooks/shellCommandProcessor.ts
+init_esbuild_shims();
+var import_react4 = __toESM(require_react(), 1);
+import crypto from "node:crypto";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+var OUTPUT_UPDATE_INTERVAL_MS = 1e3;
+var MAX_OUTPUT_LENGTH = 1e4;
+var debugLogger3 = createDebugLogger("SHELL_COMMAND_PROCESSOR");
+function copyString(value) {
+  return value.split("").join("");
+}
+__name(copyString, "copyString");
+function addShellCommandToLlmHistory(llmClient, rawQuery, resultText) {
+  const modelContent = resultText.length > MAX_OUTPUT_LENGTH ? copyString(resultText.substring(0, MAX_OUTPUT_LENGTH)) + "\n... (truncated)" : resultText;
+  llmClient.addHistory({
+    role: "user",
+    parts: [
+      {
+        text: `I ran the following shell command:
+\`\`\`sh
+${rawQuery}
+\`\`\`
+
+This produced the following result:
+\`\`\`
+${modelContent}
+\`\`\``
+      }
+    ]
+  });
+}
+__name(addShellCommandToLlmHistory, "addShellCommandToLlmHistory");
+var useShellCommandProcessor = /* @__PURE__ */ __name((addItemToHistory, setPendingHistoryItem, onExec, onDebugMessage, config, llmClient, setShellInputFocused, terminalWidth, terminalHeight) => {
+  const [activeShellPtyId, setActiveShellPtyId] = (0, import_react4.useState)(null);
+  const handleShellCommand = (0, import_react4.useCallback)(
+    (rawQuery, abortSignal) => {
+      if (typeof rawQuery !== "string" || rawQuery.trim() === "") {
+        return false;
+      }
+      const userMessageTimestamp = Date.now();
+      const callId = `shell-${userMessageTimestamp}`;
+      addItemToHistory(
+        { type: "user_shell", text: rawQuery },
+        userMessageTimestamp
+      );
+      const isWindows = os.platform() === "win32";
+      const targetDir = config.getTargetDir();
+      let commandToExecute = rawQuery;
+      let pwdFilePath;
+      if (!isWindows) {
+        let command = rawQuery.trim();
+        const pwdFileName = `shell_pwd_${crypto.randomBytes(6).toString("hex")}.tmp`;
+        pwdFilePath = path.join(os.tmpdir(), pwdFileName);
+        const trailingBackslashes = /\\+$/.exec(command)?.[0].length ?? 0;
+        if (trailingBackslashes % 2 === 1) {
+          command += "\n";
+        }
+        if (!command.endsWith(";") && !command.endsWith("&")) {
+          command += ";";
+        }
+        commandToExecute = `{ ${command}
+}; __code=$?; pwd > "${pwdFilePath}"; exit $__code`;
+      }
+      const executeCommand = /* @__PURE__ */ __name(async (resolve) => {
+        let lastUpdateTime = Date.now();
+        let cumulativeStdout = "";
+        let isBinaryStream = false;
+        let binaryBytesReceived = 0;
+        const initialToolDisplay = {
+          callId,
+          name: SHELL_COMMAND_NAME,
+          description: rawQuery,
+          status: "Executing" /* Executing */,
+          resultDisplay: "",
+          confirmationDetails: void 0
+        };
+        setPendingHistoryItem({
+          type: "tool_group",
+          tools: [initialToolDisplay],
+          isUserInitiated: true
+        });
+        let executionPid;
+        const abortHandler = /* @__PURE__ */ __name(() => {
+          onDebugMessage(
+            `Aborting shell command (PID: ${executionPid ?? "unknown"})`
+          );
+        }, "abortHandler");
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
+        onDebugMessage(`Executing in ${targetDir}: ${commandToExecute}`);
+        const cleanupShellCommand = /* @__PURE__ */ __name(() => {
+          abortSignal.removeEventListener("abort", abortHandler);
+          if (pwdFilePath && fs.existsSync(pwdFilePath)) {
+            fs.unlinkSync(pwdFilePath);
+          }
+          setActiveShellPtyId(null);
+          setShellInputFocused(false);
+          resolve();
+        }, "cleanupShellCommand");
+        try {
+          const activeTheme = themeManager.getActiveTheme();
+          const shellExecutionConfig = {
+            ...config.getShellExecutionConfig(),
+            terminalWidth,
+            terminalHeight,
+            defaultFg: activeTheme.colors.Foreground,
+            defaultBg: activeTheme.colors.Background
+          };
+          const { pid, result } = await ShellExecutionService.execute(
+            commandToExecute,
+            targetDir,
+            (event) => {
+              let shouldUpdate = false;
+              switch (event.type) {
+                case "data":
+                  if (isBinaryStream) break;
+                  if (config.getShouldUseNodePtyShell()) {
+                    cumulativeStdout = event.chunk;
+                    shouldUpdate = true;
+                  } else if (typeof event.chunk === "string" && typeof cumulativeStdout === "string") {
+                    cumulativeStdout += event.chunk;
+                  }
+                  break;
+                case "binary_detected":
+                  isBinaryStream = true;
+                  shouldUpdate = true;
+                  break;
+                case "binary_progress":
+                  isBinaryStream = true;
+                  binaryBytesReceived = event.bytesReceived;
+                  break;
+                default: {
+                  throw new Error("An unhandled ShellOutputEvent was found.");
+                }
+              }
+              let currentDisplayOutput;
+              if (isBinaryStream) {
+                if (binaryBytesReceived > 0) {
+                  currentDisplayOutput = `[Receiving binary output... ${formatMemoryUsage(
+                    binaryBytesReceived
+                  )} received]`;
+                } else {
+                  currentDisplayOutput = "[Binary output detected. Halting stream...]";
+                }
+              } else {
+                currentDisplayOutput = cumulativeStdout;
+              }
+              if (shouldUpdate || Date.now() - lastUpdateTime > OUTPUT_UPDATE_INTERVAL_MS) {
+                setPendingHistoryItem((prevItem) => {
+                  if (prevItem?.type === "tool_group") {
+                    return {
+                      ...prevItem,
+                      tools: prevItem.tools.map(
+                        (tool) => tool.callId === callId ? {
+                          ...tool,
+                          resultDisplay: typeof currentDisplayOutput === "string" ? compactToolResultDisplayForHistory(
+                            currentDisplayOutput
+                          ) : compactToolResultDisplayForHistory({
+                            ansiOutput: currentDisplayOutput
+                          })
+                        } : tool
+                      )
+                    };
+                  }
+                  return prevItem;
+                });
+                lastUpdateTime = Date.now();
+              }
+            },
+            abortSignal,
+            config.getShouldUseNodePtyShell(),
+            shellExecutionConfig
+          );
+          debugLogger3.debug(terminalHeight, terminalWidth);
+          executionPid = pid;
+          if (pid) {
+            setActiveShellPtyId(pid);
+            setPendingHistoryItem((prevItem) => {
+              if (prevItem?.type === "tool_group") {
+                return {
+                  ...prevItem,
+                  tools: prevItem.tools.map(
+                    (tool) => tool.callId === callId ? { ...tool, ptyId: pid } : tool
+                  )
+                };
+              }
+              return prevItem;
+            });
+          }
+          result.then((result2) => {
+            setPendingHistoryItem(null);
+            let mainContent;
+            if (isBinary(result2.rawOutput)) {
+              mainContent = "[Command produced binary output, which is not shown.]";
+            } else {
+              mainContent = result2.output.trim() || "(Command produced no output)";
+            }
+            let finalOutput = mainContent;
+            let finalStatus = "Success" /* Success */;
+            if (result2.error) {
+              finalStatus = "Error" /* Error */;
+              finalOutput = `${result2.error.message}
+${finalOutput}`;
+            } else if (result2.aborted) {
+              finalStatus = "Canceled" /* Canceled */;
+              finalOutput = `Command was cancelled.
+${finalOutput}`;
+            } else if (isSignalTermination(result2.signal)) {
+              finalStatus = "Error" /* Error */;
+              finalOutput = `Command terminated by signal: ${result2.signal}.
+${finalOutput}`;
+            } else if (result2.exitCode !== 0) {
+              finalStatus = "Error" /* Error */;
+              finalOutput = `Command exited with code ${result2.exitCode}.
+${finalOutput}`;
+            }
+            if (pwdFilePath && fs.existsSync(pwdFilePath)) {
+              const finalPwd = fs.readFileSync(pwdFilePath, "utf8").trim();
+              if (finalPwd && finalPwd !== targetDir) {
+                const warning = `WARNING: shell mode is stateless; the directory change to '${finalPwd}' will not persist.`;
+                finalOutput = `${warning}
+
+${finalOutput}`;
+              }
+            }
+            const finalToolDisplay = {
+              ...initialToolDisplay,
+              status: finalStatus,
+              resultDisplay: compactToolResultDisplayForHistory(finalOutput)
+            };
+            addItemToHistory(
+              {
+                type: "tool_group",
+                tools: [finalToolDisplay],
+                isUserInitiated: true
+              },
+              userMessageTimestamp
+            );
+            addShellCommandToLlmHistory(llmClient, rawQuery, finalOutput);
+          }).catch((err) => {
+            setPendingHistoryItem(null);
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            addItemToHistory(
+              {
+                type: "error",
+                text: `An unexpected error occurred: ${errorMessage}`
+              },
+              userMessageTimestamp
+            );
+          }).finally(() => {
+            cleanupShellCommand();
+          });
+        } catch (err) {
+          setPendingHistoryItem(null);
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          addItemToHistory(
+            {
+              type: "error",
+              text: `An unexpected error occurred: ${errorMessage}`
+            },
+            userMessageTimestamp
+          );
+          cleanupShellCommand();
+        }
+      }, "executeCommand");
+      const execPromise = new Promise((resolve) => {
+        executeCommand(resolve);
+      });
+      onExec(execPromise);
+      return true;
+    },
+    [
+      config,
+      onDebugMessage,
+      addItemToHistory,
+      setPendingHistoryItem,
+      onExec,
+      llmClient,
+      setShellInputFocused,
+      terminalHeight,
+      terminalWidth
+    ]
+  );
+  return { handleShellCommand, activeShellPtyId };
+}, "useShellCommandProcessor");
+
+// packages/cli/src/ui/hooks/useFollowupSuggestions.tsx
+init_esbuild_shims();
+var import_react5 = __toESM(require_react(), 1);
+function useFollowupSuggestionsCLI(options = {}) {
+  const { enabled = true, onAccept, config, isFocused = true } = options;
+  const [state, setState] = (0, import_react5.useState)(INITIAL_FOLLOWUP_STATE);
+  const onAcceptRef = (0, import_react5.useRef)(onAccept);
+  onAcceptRef.current = onAccept;
+  const configRef = (0, import_react5.useRef)(config);
+  configRef.current = config;
+  const firstKeystrokeAtRef = (0, import_react5.useRef)(0);
+  const prevShownAtRef = (0, import_react5.useRef)(0);
+  const wasFocusedWhenShownRef = (0, import_react5.useRef)(true);
+  (0, import_react5.useEffect)(() => {
+    if (state.shownAt > 0 && state.shownAt !== prevShownAtRef.current) {
+      prevShownAtRef.current = state.shownAt;
+      wasFocusedWhenShownRef.current = isFocused;
+      firstKeystrokeAtRef.current = 0;
+    } else if (state.shownAt === 0) {
+      prevShownAtRef.current = 0;
+    }
+  }, [state.shownAt, isFocused]);
+  const recordKeystroke = (0, import_react5.useCallback)(() => {
+    if (firstKeystrokeAtRef.current === 0 && state.isVisible) {
+      firstKeystrokeAtRef.current = Date.now();
+    }
+  }, [state.isVisible]);
+  const onOutcome = (0, import_react5.useCallback)(
+    (params) => {
+      const cfg = configRef.current;
+      if (!cfg) return;
+      logPromptSuggestion(
+        cfg,
+        new PromptSuggestionEvent({
+          outcome: params.outcome,
+          accept_method: params.accept_method,
+          accept_source: params.accept_source,
+          ...params.outcome === "accepted" ? { time_to_accept_ms: params.time_ms } : { time_to_ignore_ms: params.time_ms },
+          // Skip for fallback accepts: the suggestion was never shown via the
+          // timer (shownAt stayed 0), so `prevShownAtRef` still holds a previous
+          // suggestion's timestamp and the delta would be meaningless.
+          ...params.accept_source !== "fallback" && firstKeystrokeAtRef.current > 0 && prevShownAtRef.current > 0 && {
+            time_to_first_keystroke_ms: firstKeystrokeAtRef.current - prevShownAtRef.current
+          },
+          suggestion_length: params.suggestion_length,
+          similarity: params.outcome === "accepted" ? 1 : 0,
+          was_focused_when_shown: wasFocusedWhenShownRef.current
+        })
+      );
+    },
+    []
+  );
+  const controller = (0, import_react5.useMemo)(
+    () => createFollowupController({
+      enabled,
+      onStateChange: setState,
+      getOnAccept: /* @__PURE__ */ __name(() => onAcceptRef.current, "getOnAccept"),
+      onOutcome
+    }),
+    [enabled, onOutcome]
+  );
+  (0, import_react5.useEffect)(() => {
+    if (!enabled) {
+      controller.clear();
+    }
+    return () => controller.cleanup();
+  }, [controller, enabled]);
+  return (0, import_react5.useMemo)(
+    () => ({
+      state,
+      setSuggestion: controller.setSuggestion,
+      accept: controller.accept,
+      dismiss: controller.dismiss,
+      clear: controller.clear,
+      recordKeystroke
+    }),
+    [state, controller, recordKeystroke]
+  );
+}
+__name(useFollowupSuggestionsCLI, "useFollowupSuggestionsCLI");
+
 // packages/cli/src/ui/components/mcp/utils.ts
 init_esbuild_shims();
 
@@ -1234,7 +1619,7 @@ var TableRow = /* @__PURE__ */ __name(({ cells }) => /* @__PURE__ */ (0, import_
 
 // packages/cli/src/ui/auth/useProviderSetupFlow.ts
 init_esbuild_shims();
-var import_react4 = __toESM(require_react(), 1);
+var import_react6 = __toESM(require_react(), 1);
 var STEP_ORDER = [
   "protocol",
   "baseUrl",
@@ -1251,28 +1636,28 @@ function getVisibleSteps(config) {
 }
 __name(getVisibleSteps, "getVisibleSteps");
 function useProviderSetupFlow(onSubmit) {
-  const [provider, setProvider] = (0, import_react4.useState)(null);
-  const [visibleSteps, setVisibleSteps] = (0, import_react4.useState)([]);
-  const [stepIndex, setStepIndex] = (0, import_react4.useState)(0);
-  const [protocol, setProtocol] = (0, import_react4.useState)("openai" /* USE_OPENAI */);
-  const [baseUrl, setBaseUrl] = (0, import_react4.useState)("");
-  const [baseUrlPlaceholder, setBaseUrlPlaceholder] = (0, import_react4.useState)("");
-  const [baseUrlOptionIndex, setBaseUrlOptionIndex] = (0, import_react4.useState)(0);
-  const [baseUrlError, setBaseUrlError] = (0, import_react4.useState)(null);
-  const [apiKey, setApiKey] = (0, import_react4.useState)("");
-  const [apiKeyError, setApiKeyError] = (0, import_react4.useState)(null);
-  const [modelIds, setModelIds] = (0, import_react4.useState)("");
-  const [modelIdsError, setModelIdsError] = (0, import_react4.useState)(null);
-  const [thinkingEnabled, setThinkingEnabled] = (0, import_react4.useState)(false);
-  const [modalityEnabled, setModalityEnabled] = (0, import_react4.useState)(false);
-  const [modalityImage, setModalityImage] = (0, import_react4.useState)(true);
-  const [modalityVideo, setModalityVideo] = (0, import_react4.useState)(true);
-  const [modalityAudio, setModalityAudio] = (0, import_react4.useState)(false);
-  const [modalityPdf, setModalityPdf] = (0, import_react4.useState)(false);
-  const [contextWindowSize, setContextWindowSize] = (0, import_react4.useState)("");
-  const [focusedConfigIndex, setFocusedConfigIndex] = (0, import_react4.useState)(0);
+  const [provider, setProvider] = (0, import_react6.useState)(null);
+  const [visibleSteps, setVisibleSteps] = (0, import_react6.useState)([]);
+  const [stepIndex, setStepIndex] = (0, import_react6.useState)(0);
+  const [protocol, setProtocol] = (0, import_react6.useState)("openai" /* USE_OPENAI */);
+  const [baseUrl, setBaseUrl] = (0, import_react6.useState)("");
+  const [baseUrlPlaceholder, setBaseUrlPlaceholder] = (0, import_react6.useState)("");
+  const [baseUrlOptionIndex, setBaseUrlOptionIndex] = (0, import_react6.useState)(0);
+  const [baseUrlError, setBaseUrlError] = (0, import_react6.useState)(null);
+  const [apiKey, setApiKey] = (0, import_react6.useState)("");
+  const [apiKeyError, setApiKeyError] = (0, import_react6.useState)(null);
+  const [modelIds, setModelIds] = (0, import_react6.useState)("");
+  const [modelIdsError, setModelIdsError] = (0, import_react6.useState)(null);
+  const [thinkingEnabled, setThinkingEnabled] = (0, import_react6.useState)(false);
+  const [modalityEnabled, setModalityEnabled] = (0, import_react6.useState)(false);
+  const [modalityImage, setModalityImage] = (0, import_react6.useState)(true);
+  const [modalityVideo, setModalityVideo] = (0, import_react6.useState)(true);
+  const [modalityAudio, setModalityAudio] = (0, import_react6.useState)(false);
+  const [modalityPdf, setModalityPdf] = (0, import_react6.useState)(false);
+  const [contextWindowSize, setContextWindowSize] = (0, import_react6.useState)("");
+  const [focusedConfigIndex, setFocusedConfigIndex] = (0, import_react6.useState)(0);
   const currentStep = visibleSteps[stepIndex] ?? null;
-  const start = (0, import_react4.useCallback)(
+  const start = (0, import_react6.useCallback)(
     (config, initialProtocol, existingEnv, existingModelIds) => {
       setProvider(config);
       const steps = getVisibleSteps(config);
@@ -1309,12 +1694,12 @@ function useProviderSetupFlow(onSubmit) {
     },
     []
   );
-  const reset = (0, import_react4.useCallback)(() => {
+  const reset = (0, import_react6.useCallback)(() => {
     setProvider(null);
     setVisibleSteps([]);
     setStepIndex(0);
   }, []);
-  const goBack = (0, import_react4.useCallback)(() => {
+  const goBack = (0, import_react6.useCallback)(() => {
     if (stepIndex > 0) {
       setStepIndex((i) => i - 1);
       return true;
@@ -1322,10 +1707,10 @@ function useProviderSetupFlow(onSubmit) {
     reset();
     return false;
   }, [stepIndex, reset]);
-  const goNext = (0, import_react4.useCallback)(() => {
+  const goNext = (0, import_react6.useCallback)(() => {
     setStepIndex((i) => Math.min(i + 1, visibleSteps.length - 1));
   }, [visibleSteps]);
-  const selectProtocol = (0, import_react4.useCallback)(
+  const selectProtocol = (0, import_react6.useCallback)(
     (selectedProtocol) => {
       setProtocol(selectedProtocol);
       setBaseUrl("");
@@ -1336,7 +1721,7 @@ function useProviderSetupFlow(onSubmit) {
     },
     [goNext]
   );
-  const selectBaseUrl = (0, import_react4.useCallback)(
+  const selectBaseUrl = (0, import_react6.useCallback)(
     (selectedUrl) => {
       setBaseUrl(selectedUrl);
       setBaseUrlError(null);
@@ -1344,7 +1729,7 @@ function useProviderSetupFlow(onSubmit) {
     },
     [goNext]
   );
-  const submitBaseUrl = (0, import_react4.useCallback)(() => {
+  const submitBaseUrl = (0, import_react6.useCallback)(() => {
     const effective = baseUrl.trim() || baseUrlPlaceholder.trim();
     if (!effective) {
       setBaseUrlError(t("Base URL cannot be empty."));
@@ -1361,15 +1746,15 @@ function useProviderSetupFlow(onSubmit) {
     goNext();
     return true;
   }, [baseUrl, baseUrlPlaceholder, goNext]);
-  const changeBaseUrl = (0, import_react4.useCallback)((value) => {
+  const changeBaseUrl = (0, import_react6.useCallback)((value) => {
     setBaseUrl(value);
     setBaseUrlError(null);
   }, []);
-  const changeApiKey = (0, import_react4.useCallback)((value) => {
+  const changeApiKey = (0, import_react6.useCallback)((value) => {
     setApiKey(value);
     setApiKeyError(null);
   }, []);
-  const buildCurrentInputs = (0, import_react4.useCallback)(
+  const buildCurrentInputs = (0, import_react6.useCallback)(
     (overrides) => ({
       protocol: provider?.protocolOptions ? protocol : void 0,
       baseUrl: baseUrl.trim(),
@@ -1379,7 +1764,7 @@ function useProviderSetupFlow(onSubmit) {
     }),
     [provider, protocol, baseUrl, apiKey, modelIds]
   );
-  const submitOrNext = (0, import_react4.useCallback)(
+  const submitOrNext = (0, import_react6.useCallback)(
     (overrides) => {
       if (stepIndex >= visibleSteps.length - 1) {
         if (provider) void onSubmit(provider, buildCurrentInputs(overrides));
@@ -1389,7 +1774,7 @@ function useProviderSetupFlow(onSubmit) {
     },
     [stepIndex, visibleSteps, provider, onSubmit, buildCurrentInputs, goNext]
   );
-  const submitApiKey = (0, import_react4.useCallback)(
+  const submitApiKey = (0, import_react6.useCallback)(
     (keyOverride) => {
       const trimmed = (keyOverride ?? apiKey).trim();
       if (!trimmed) {
@@ -1410,7 +1795,7 @@ function useProviderSetupFlow(onSubmit) {
     },
     [apiKey, provider, baseUrl, submitOrNext]
   );
-  const highlightBaseUrl = (0, import_react4.useCallback)(
+  const highlightBaseUrl = (0, import_react6.useCallback)(
     (url) => {
       if (provider && Array.isArray(provider.baseUrl)) {
         const idx = provider.baseUrl.findIndex((o) => o.url === url);
@@ -1419,14 +1804,14 @@ function useProviderSetupFlow(onSubmit) {
     },
     [provider]
   );
-  const changeModelIds = (0, import_react4.useCallback)((value) => {
+  const changeModelIds = (0, import_react6.useCallback)((value) => {
     setModelIds(value);
     setModelIdsError(null);
   }, []);
-  const clearModelIdsError = (0, import_react4.useCallback)(() => {
+  const clearModelIdsError = (0, import_react6.useCallback)(() => {
     setModelIdsError(null);
   }, []);
-  const submitModelIds = (0, import_react4.useCallback)(
+  const submitModelIds = (0, import_react6.useCallback)(
     (overrides) => {
       const normalized = overrides?.modelIds ?? normalizeModelIds(modelIds);
       if (normalized.length === 0) {
@@ -1441,13 +1826,13 @@ function useProviderSetupFlow(onSubmit) {
     [modelIds, submitOrNext]
   );
   const advancedOptionCount = modalityEnabled ? 7 : 3;
-  const moveAdvancedFocusUp = (0, import_react4.useCallback)(() => {
+  const moveAdvancedFocusUp = (0, import_react6.useCallback)(() => {
     setFocusedConfigIndex((v) => v <= 0 ? advancedOptionCount - 1 : v - 1);
   }, [advancedOptionCount]);
-  const moveAdvancedFocusDown = (0, import_react4.useCallback)(() => {
+  const moveAdvancedFocusDown = (0, import_react6.useCallback)(() => {
     setFocusedConfigIndex((v) => v >= advancedOptionCount - 1 ? 0 : v + 1);
   }, [advancedOptionCount]);
-  const toggleFocusedAdvancedOption = (0, import_react4.useCallback)(() => {
+  const toggleFocusedAdvancedOption = (0, import_react6.useCallback)(() => {
     switch (focusedConfigIndex) {
       case 0:
         setThinkingEnabled((v) => !v);
@@ -1471,13 +1856,13 @@ function useProviderSetupFlow(onSubmit) {
         break;
     }
   }, [focusedConfigIndex]);
-  const submitAdvancedConfig = (0, import_react4.useCallback)(() => {
+  const submitAdvancedConfig = (0, import_react6.useCallback)(() => {
     goNext();
   }, [goNext]);
-  const changeContextWindowSize = (0, import_react4.useCallback)((value) => {
+  const changeContextWindowSize = (0, import_react6.useCallback)((value) => {
     setContextWindowSize(value.replace(/[^0-9]/g, ""));
   }, []);
-  const submit = (0, import_react4.useCallback)(() => {
+  const submit = (0, import_react6.useCallback)(() => {
     if (!provider) return;
     const multimodal = modalityEnabled ? {
       image: modalityImage || void 0,
@@ -1505,7 +1890,7 @@ function useProviderSetupFlow(onSubmit) {
     onSubmit,
     buildCurrentInputs
   ]);
-  const getPreviewJson = (0, import_react4.useCallback)(() => {
+  const getPreviewJson = (0, import_react6.useCallback)(() => {
     if (!provider) return "";
     const envKey = typeof provider.envKey === "function" ? provider.envKey(protocol, baseUrl.trim()) : provider.envKey;
     const normalizedIds = normalizeModelIds(modelIds);
@@ -1655,342 +2040,14 @@ var EditorSettingsManager = class {
 };
 var editorSettingsManager = new EditorSettingsManager();
 
-// packages/cli/src/ui/statusLinePresets.ts
-init_esbuild_shims();
-import nodePath from "node:path";
-var STATUS_LINE_PRESET_ITEM_IDS = [
-  "project-name",
-  "git-branch",
-  "model-with-reasoning",
-  "model",
-  "context-remaining",
-  "total-input-tokens",
-  "total-output-tokens",
-  "current-dir",
-  "pull-request-number",
-  "branch-changes",
-  "context-used",
-  "run-state",
-  "qwen-version",
-  "context-window-size",
-  "used-tokens",
-  "session-id"
-];
-function aggregateModelTokens(metrics) {
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  for (const modelMetrics of Object.values(metrics.models)) {
-    totalInputTokens += modelMetrics.tokens.prompt;
-    totalOutputTokens += modelMetrics.tokens.candidates;
-  }
-  return { totalInputTokens, totalOutputTokens };
-}
-__name(aggregateModelTokens, "aggregateModelTokens");
-var STATUS_LINE_PRESET_ITEMS = [
-  {
-    id: "project-name",
-    label: "project-name",
-    description: "Project name when available",
-    defaultSelected: true
-  },
-  {
-    id: "git-branch",
-    label: "git-branch",
-    description: "Current Git branch when available",
-    defaultSelected: true
-  },
-  {
-    id: "model-with-reasoning",
-    label: "model-with-reasoning",
-    description: "Current model name with reasoning level when available",
-    defaultSelected: true
-  },
-  {
-    id: "model",
-    label: "model-only",
-    description: "Current model name without reasoning level"
-  },
-  {
-    id: "context-remaining",
-    label: "context-remaining",
-    description: "Percentage of context window remaining"
-  },
-  {
-    id: "total-input-tokens",
-    label: "total-input-tokens",
-    description: "Total input tokens used in session"
-  },
-  {
-    id: "total-output-tokens",
-    label: "total-output-tokens",
-    description: "Total output tokens used in session"
-  },
-  {
-    id: "current-dir",
-    label: "current-dir",
-    description: "Current working directory"
-  },
-  {
-    id: "pull-request-number",
-    label: "pull-request-number",
-    description: "Open pull request number for the current branch"
-  },
-  {
-    id: "branch-changes",
-    label: "branch-changes",
-    description: "Session file changes added and removed"
-  },
-  {
-    id: "context-used",
-    label: "context-used",
-    description: "Percentage of context window used",
-    defaultSelected: true
-  },
-  {
-    id: "run-state",
-    label: "run-state",
-    description: "Compact session run-state text"
-  },
-  {
-    id: "qwen-version",
-    label: "qwen-version",
-    description: "Qwen Code application version"
-  },
-  {
-    id: "context-window-size",
-    label: "context-window-size",
-    description: "Total context window size in tokens"
-  },
-  {
-    id: "used-tokens",
-    label: "used-tokens",
-    description: "Current prompt tokens used"
-  },
-  {
-    id: "session-id",
-    label: "session-id",
-    description: "Current session identifier"
-  }
-];
-var STATUS_LINE_PRESET_ITEM_ID_SET = new Set(
-  STATUS_LINE_PRESET_ITEM_IDS
-);
-function orderStatusLinePresetItems(items) {
-  const selectedItems = new Set(
-    items.filter(
-      (item) => typeof item === "string" && STATUS_LINE_PRESET_ITEM_ID_SET.has(item)
-    )
-  );
-  return STATUS_LINE_PRESET_ITEM_IDS.filter((item) => selectedItems.has(item));
-}
-__name(orderStatusLinePresetItems, "orderStatusLinePresetItems");
-var DEFAULT_STATUS_LINE_PRESET_CONFIG = {
-  type: "preset",
-  useThemeColors: true,
-  items: orderStatusLinePresetItems(
-    STATUS_LINE_PRESET_ITEMS.filter((item) => item.defaultSelected).map(
-      (item) => item.id
-    )
-  )
-};
-function normalizeStatusLinePresetConfig(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    return void 0;
-  }
-  const candidate = raw;
-  if (candidate["type"] !== "preset") {
-    return void 0;
-  }
-  const hasItemsArray = Array.isArray(candidate["items"]);
-  const items = hasItemsArray ? orderStatusLinePresetItems(candidate["items"]) : [];
-  return {
-    type: "preset",
-    useThemeColors: typeof candidate["useThemeColors"] === "boolean" ? candidate["useThemeColors"] : true,
-    items: hasItemsArray ? items : [...DEFAULT_STATUS_LINE_PRESET_CONFIG.items],
-    hideContextIndicator: typeof candidate["hideContextIndicator"] === "boolean" ? candidate["hideContextIndicator"] : void 0
-  };
-}
-__name(normalizeStatusLinePresetConfig, "normalizeStatusLinePresetConfig");
-function formatPercent(value) {
-  if (!Number.isFinite(value)) {
-    return "0%";
-  }
-  const rounded = Math.round(value * 10) / 10;
-  return `${Number.isInteger(rounded) ? rounded.toFixed(0) : rounded}%`;
-}
-__name(formatPercent, "formatPercent");
-function formatTokenCount(value) {
-  if (!Number.isFinite(value) || value <= 0) {
-    return "0";
-  }
-  if (value >= 1e6) {
-    return `${(value / 1e6).toFixed(1)}m`;
-  }
-  if (value >= 1e3) {
-    return `${(value / 1e3).toFixed(1)}k`;
-  }
-  return String(Math.round(value));
-}
-__name(formatTokenCount, "formatTokenCount");
-function getRunStateLabel(state) {
-  switch (state) {
-    case "idle" /* Idle */:
-      return "Ready";
-    case "responding" /* Responding */:
-      return "Working";
-    case "waiting_for_confirmation" /* WaitingForConfirmation */:
-      return "Confirm";
-    default:
-      return "Working";
-  }
-}
-__name(getRunStateLabel, "getRunStateLabel");
-function stripProviderPrefix(name) {
-  return name.replace(/^\[[^\]]*\]\s*/, "");
-}
-__name(stripProviderPrefix, "stripProviderPrefix");
-function formatModelWithReasoning(modelDisplayName, reasoning) {
-  const cleanName = stripProviderPrefix(modelDisplayName);
-  if (reasoning === false) {
-    return `${cleanName} reasoning off`;
-  }
-  if (reasoning?.effort) {
-    return `${cleanName} ${reasoning.effort}`;
-  }
-  return cleanName;
-}
-__name(formatModelWithReasoning, "formatModelWithReasoning");
-function inferPullRequestNumber(branch) {
-  if (!branch) {
-    return void 0;
-  }
-  const match = branch.match(
-    /(?:^|[/_-])(?:pr|pull|pull-request)[/_-]?#?(\d+)(?:$|[/_-])/i
-  );
-  return match?.[1];
-}
-__name(inferPullRequestNumber, "inferPullRequestNumber");
-function buildStatusLinePresetData(params) {
-  const usedPercentage = params.contextWindowSize > 0 ? Math.min(
-    100,
-    Math.max(
-      0,
-      Math.round(
-        params.currentUsage / params.contextWindowSize * 1e3
-      ) / 10
-    )
-  ) : 0;
-  return {
-    sessionId: params.sessionId,
-    version: params.version || "unknown",
-    modelDisplayName: params.modelDisplayName || "unknown",
-    reasoning: params.reasoning,
-    currentDir: params.currentDir,
-    projectName: nodePath.basename(params.currentDir) || void 0,
-    branch: params.branch,
-    pullRequestNumber: params.pullRequestNumber,
-    contextWindowSize: params.contextWindowSize,
-    usedPercentage,
-    remainingPercentage: Math.round((100 - usedPercentage) * 10) / 10,
-    currentUsage: params.currentUsage,
-    totalInputTokens: params.totalInputTokens,
-    totalOutputTokens: params.totalOutputTokens,
-    totalLinesAdded: params.totalLinesAdded,
-    totalLinesRemoved: params.totalLinesRemoved,
-    streamingState: params.streamingState
-  };
-}
-__name(buildStatusLinePresetData, "buildStatusLinePresetData");
-function formatPresetItem(item, data) {
-  switch (item) {
-    case "model-with-reasoning":
-      return formatModelWithReasoning(data.modelDisplayName, data.reasoning);
-    case "model":
-      return stripProviderPrefix(data.modelDisplayName);
-    case "context-remaining":
-      if (data.contextWindowSize > 0) {
-        return `Context ${formatPercent(data.remainingPercentage)} left`;
-      }
-      return void 0;
-    case "current-dir":
-      return data.currentDir;
-    case "context-used":
-      if (data.contextWindowSize > 0 && data.usedPercentage > 0) {
-        return `${formatTokenCount(data.contextWindowSize)} Context ${formatPercent(data.usedPercentage)} used`;
-      }
-      return void 0;
-    case "git-branch":
-      if (data.branch) {
-        return `git:(${data.branch})`;
-      }
-      return void 0;
-    case "project-name":
-      if (data.projectName) {
-        return `\u279C ${data.projectName}`;
-      }
-      return void 0;
-    case "pull-request-number": {
-      const prNumber = data.pullRequestNumber ?? inferPullRequestNumber(data.branch);
-      if (prNumber) {
-        return `#${prNumber}`;
-      }
-      return void 0;
-    }
-    case "branch-changes":
-      if (data.totalLinesAdded > 0 || data.totalLinesRemoved > 0) {
-        return `+${data.totalLinesAdded} -${data.totalLinesRemoved}`;
-      }
-      return void 0;
-    case "run-state":
-      return getRunStateLabel(data.streamingState);
-    case "qwen-version":
-      return `v${data.version}`;
-    case "context-window-size":
-      if (data.contextWindowSize > 0) {
-        return `${formatTokenCount(data.contextWindowSize)} window`;
-      }
-      return void 0;
-    case "used-tokens":
-      if (data.currentUsage > 0) {
-        return `${formatTokenCount(data.currentUsage)} used`;
-      }
-      return void 0;
-    case "total-input-tokens":
-      return `${formatTokenCount(data.totalInputTokens)} total in`;
-    case "total-output-tokens":
-      return `${formatTokenCount(data.totalOutputTokens)} total out`;
-    case "session-id":
-      return data.sessionId || void 0;
-    default: {
-      item;
-      return void 0;
-    }
-  }
-}
-__name(formatPresetItem, "formatPresetItem");
-function buildStatusLinePresetParts(config, data) {
-  const parts = [];
-  for (const item of orderStatusLinePresetItems(config.items)) {
-    const text = formatPresetItem(item, data);
-    if (text) {
-      parts.push(text);
-    }
-  }
-  return parts;
-}
-__name(buildStatusLinePresetParts, "buildStatusLinePresetParts");
-function buildStatusLinePresetLines(config, data) {
-  const line = buildStatusLinePresetParts(config, data).join(" \xB7 ");
-  return line ? [line] : [];
-}
-__name(buildStatusLinePresetLines, "buildStatusLinePresetLines");
-
 export {
   computeWindowTitle,
   writeTerminalTitle,
   formatSessionWindowTitle,
   titleStatusPrefix,
   useLogger,
+  addShellCommandToLlmHistory,
+  useShellCommandProcessor,
   VISIBLE_TOOLS_COUNT,
   VISIBLE_RESOURCES_COUNT,
   groupServersBySource,
@@ -2017,13 +2074,7 @@ export {
   useProviderSetupFlow,
   EDITOR_DISPLAY_NAMES,
   editorSettingsManager,
-  aggregateModelTokens,
-  STATUS_LINE_PRESET_ITEMS,
-  orderStatusLinePresetItems,
-  DEFAULT_STATUS_LINE_PRESET_CONFIG,
-  normalizeStatusLinePresetConfig,
-  buildStatusLinePresetData,
-  buildStatusLinePresetLines,
+  useFollowupSuggestionsCLI,
   DualOutputBridge,
   RemoteInputWatcher
 };
@@ -2044,11 +2095,15 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
+ *
+ * Prompt Suggestion Hook for CLI
+ *
+ * Thin React wrapper around the framework-agnostic controller from core.
  */
 /**
  * @license
- * Copyright 2026 Qwen
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */