min-agent 0.4.1 → 0.5.1

package/dist/thinking-wire.js

@@ -0,0 +1,239 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { readFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getActiveProvider, getConfigDir, getEffectiveConfig } from "./config.js";
+import { fetchOllamaNativeChat, readFetchBody } from "./ollama-openai-bridge.js";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
+export const thinkingRequestStore = new AsyncLocalStorage();
+export const THINKING_WIRE_VERSION = 1;
+export const THINKING_WIRE_TTL = 7 * 24 * 60 * 60 * 1000;
+export const DEFAULT_THINKING_WIRE = {
+    version: THINKING_WIRE_VERSION,
+    thinkingType: "enabled-disabled",
+    effort: "reasoning_effort",
+};
+const memoryCache = new Map();
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isThinkingTypeMode(value) {
+    return value === "enabled-disabled" || value === "adaptive-disabled" || value === "omit";
+}
+function isEffortMode(value) {
+    return value === "reasoning_effort" || value === "omit";
+}
+function isProfile(value) {
+    if (!isRecord(value))
+        return false;
+    return (value.version === THINKING_WIRE_VERSION &&
+        isThinkingTypeMode(value.thinkingType) &&
+        isEffortMode(value.effort) &&
+        typeof value.timestamp === "number" &&
+        Number.isFinite(value.timestamp));
+}
+function cacheFile() {
+    return path.join(getConfigDir(), "thinking-wire-cache.json");
+}
+function loadDiskCache() {
+    const file = cacheFile();
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf-8"));
+        if (!isRecord(parsed))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (isProfile(value))
+                out[key] = value;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function saveDiskCache(cache) {
+    const file = cacheFile();
+    mkdirSync(path.dirname(file), { recursive: true });
+    atomicWriteFileSync(file, JSON.stringify(cache));
+}
+function liveProfile(entry, now) {
+    if (entry.version !== THINKING_WIRE_VERSION)
+        return null;
+    if (now - entry.timestamp > THINKING_WIRE_TTL)
+        return null;
+    return entry;
+}
+export function thinkingWireCacheKey(host, modelId) {
+    const h = host.trim().toLowerCase();
+    const m = modelId.trim().toLowerCase();
+    if (!h)
+        return m;
+    if (!m)
+        return h;
+    return `${h}::${m}`;
+}
+export function inferThinkingWire(modelId, host, providerType) {
+    if (providerType === "ollama") {
+        return { thinkingType: "omit", effort: "reasoning_effort" };
+    }
+    const haystack = `${modelId} ${host}`.toLowerCase();
+    if (haystack.includes("minimax")) {
+        return { thinkingType: "adaptive-disabled", effort: "reasoning_effort" };
+    }
+    if (providerType === "openai") {
+        return { thinkingType: "omit", effort: "reasoning_effort" };
+    }
+    return { thinkingType: DEFAULT_THINKING_WIRE.thinkingType, effort: DEFAULT_THINKING_WIRE.effort };
+}
+function readCachedProfile(key, now) {
+    const memory = memoryCache.get(key);
+    if (memory) {
+        const live = liveProfile(memory, now);
+        if (live)
+            return live;
+        memoryCache.delete(key);
+    }
+    const disk = loadDiskCache()[key];
+    if (!disk)
+        return null;
+    const live = liveProfile(disk, now);
+    if (!live)
+        return null;
+    memoryCache.set(key, live);
+    return live;
+}
+export function resolveThinkingWireProfile(host, modelId, providerType, now = Date.now()) {
+    const cached = readCachedProfile(thinkingWireCacheKey(host, modelId), now);
+    if (cached)
+        return cached;
+    return {
+        version: THINKING_WIRE_VERSION,
+        ...inferThinkingWire(modelId, host, providerType),
+        timestamp: now,
+    };
+}
+export function saveLearnedThinkingWire(host, modelId, profile, now = Date.now()) {
+    const entry = {
+        version: THINKING_WIRE_VERSION,
+        thinkingType: profile.thinkingType,
+        effort: profile.effort,
+        timestamp: profile.timestamp ?? now,
+    };
+    const key = thinkingWireCacheKey(host, modelId);
+    memoryCache.set(key, entry);
+    const cache = loadDiskCache();
+    cache[key] = entry;
+    saveDiskCache(cache);
+    return entry;
+}
+export function clearThinkingWireCache() {
+    memoryCache.clear();
+}
+export function applyThinkingToChatBody(body, spec, profile = DEFAULT_THINKING_WIRE) {
+    const next = { ...body };
+    if (profile.effort === "omit")
+        delete next.reasoning_effort;
+    else
+        next.reasoning_effort = spec.reasoningEffort;
+    if (profile.thinkingType === "omit")
+        delete next.thinking;
+    else {
+        const on = profile.thinkingType === "adaptive-disabled" ? "adaptive" : "enabled";
+        next.thinking = { type: spec.thinkingEnabled ? on : "disabled" };
+    }
+    return next;
+}
+function splitAllowed(raw) {
+    return new Set(raw
+        .split(",")
+        .map((part) => part
+        .trim()
+        .replace(/^['"]|['"]$/g, "")
+        .toLowerCase())
+        .filter(Boolean));
+}
+export function parseThinkingWireHint(text) {
+    const allowedMatch = text.match(/thinking\.type[\s\S]*?allowed:\s*([^)]+)/i);
+    if (allowedMatch?.[1]) {
+        const allowed = splitAllowed(allowedMatch[1]);
+        if (allowed.has("adaptive") && allowed.has("disabled"))
+            return { thinkingType: "adaptive-disabled" };
+        if (allowed.has("enabled") && allowed.has("disabled"))
+            return { thinkingType: "enabled-disabled" };
+    }
+    if (/unknown parameter[:\s]+['"`]?thinking['"`]?(?![\w.])/i.test(text))
+        return { thinkingType: "omit" };
+    if (/unknown parameter[:\s]+['"`]?reasoning_effort['"`]?(?![\w.])/i.test(text))
+        return { effort: "omit" };
+    return null;
+}
+function hostnameFromInput(input) {
+    try {
+        const raw = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        return new URL(raw).hostname;
+    }
+    catch {
+        return "";
+    }
+}
+function rebuild400(response, text) {
+    return new Response(text, {
+        status: 400,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+function profileUnchanged(current, next) {
+    return current.thinkingType === next.thinkingType && current.effort === next.effort;
+}
+export async function fetchWithThinkingWire(inner, input, init, opts) {
+    if (!init?.body)
+        return inner(input, init);
+    const rawBody = await readFetchBody(init.body);
+    if (rawBody == null)
+        return inner(input, init);
+    let parsed;
+    try {
+        parsed = JSON.parse(rawBody);
+    }
+    catch {
+        return inner(input, init);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return inner(input, init);
+    const spec = thinkingRequestStore.getStore();
+    const providerType = opts?.providerType ?? getActiveProvider(getEffectiveConfig())?.type;
+    const body = parsed;
+    if (providerType === "ollama")
+        return fetchOllamaNativeChat(inner, input, init, body, spec);
+    if (!spec)
+        return inner(input, init);
+    const host = hostnameFromInput(input);
+    const modelId = typeof body.model === "string" ? body.model : "";
+    const profile = resolveThinkingWireProfile(host, modelId, providerType);
+    const first = await inner(input, {
+        ...init,
+        body: JSON.stringify(applyThinkingToChatBody(body, spec, profile)),
+    });
+    if (first.status !== 400)
+        return first;
+    const text = await first.text();
+    const hint = parseThinkingWireHint(text);
+    if (!hint)
+        return rebuild400(first, text);
+    const next = {
+        version: THINKING_WIRE_VERSION,
+        thinkingType: hint.thinkingType ?? profile.thinkingType,
+        effort: hint.effort ?? profile.effort,
+        timestamp: Date.now(),
+    };
+    if (profileUnchanged(profile, next))
+        return rebuild400(first, text);
+    saveLearnedThinkingWire(host, modelId, next);
+    return inner(input, {
+        ...init,
+        body: JSON.stringify(applyThinkingToChatBody(body, spec, next)),
+    });
+}

package/dist/thinking.js

@@ -0,0 +1,166 @@
+import { getEffectiveConfig, loadConfig, loadProjectConfig, saveConfig, saveProjectConfig, getActiveProvider, parseThinkingEffort, } from "./config.js";
+import { getCachedModelCatalog, getModelCatalog } from "./model-catalog.js";
+import { getCachedOllamaModel, getOllamaModel, thinkingChoicesFromOllama } from "./ollama-model.js";
+import { applyThinkingToChatBody, thinkingRequestStore } from "./thinking-wire.js";
+export { parseThinkingEffort, applyThinkingToChatBody, thinkingRequestStore };
+export const THINKING_EFFORTS = ["off", "low", "medium", "high", "max"];
+export const DEFAULT_THINKING_EFFORT = "medium";
+let thinkingOverride;
+export function setThinkingOverride(effort) {
+    thinkingOverride = effort;
+}
+export function getThinkingOverride() {
+    return thinkingOverride;
+}
+export function thinkingEffortLabel(effort) {
+    return effort;
+}
+export function thinkingChoiceIndex(effort, choices = THINKING_EFFORTS) {
+    const list = choices.length > 0 ? choices : THINKING_EFFORTS;
+    const clamped = clampThinkingEffort(effort, list);
+    const i = list.indexOf(clamped);
+    return i >= 0 ? i : 0;
+}
+export function thinkingChoicesFromReasoning(info) {
+    const set = new Set();
+    if (info.toggle || info.efforts.includes("none"))
+        set.add("off");
+    for (const raw of info.efforts) {
+        const mapped = parseThinkingEffort(raw);
+        if (mapped)
+            set.add(mapped);
+    }
+    const enabled = THINKING_EFFORTS.filter((effort) => effort !== "off" && set.has(effort));
+    // Toggle-only catalog rows must not collapse the picker to off.
+    if (enabled.length === 0)
+        return [...THINKING_EFFORTS];
+    return THINKING_EFFORTS.filter((effort) => set.has(effort));
+}
+export function thinkingChoicesForModel(modelId) {
+    const provider = getActiveProvider(getEffectiveConfig());
+    if (provider?.type === "ollama") {
+        if (!modelId)
+            return [...THINKING_EFFORTS];
+        const cached = getCachedOllamaModel(modelId, provider.baseURL);
+        if (!cached)
+            return [...THINKING_EFFORTS];
+        return thinkingChoicesFromOllama(cached);
+    }
+    if (!modelId)
+        return [...THINKING_EFFORTS];
+    const entry = getCachedModelCatalog(modelId);
+    if (!entry)
+        return [...THINKING_EFFORTS];
+    return thinkingChoicesFromReasoning(entry.reasoning);
+}
+export async function refreshThinkingChoices(modelId, hint) {
+    const provider = getActiveProvider(getEffectiveConfig());
+    const type = hint?.type ?? provider?.type;
+    const baseURL = hint?.baseURL ?? provider?.baseURL;
+    if (modelId) {
+        if (type === "ollama")
+            await getOllamaModel(modelId, baseURL);
+        else
+            await getModelCatalog(modelId, baseURL);
+    }
+    return thinkingChoicesForModel(modelId);
+}
+export function clampThinkingEffort(effort, choices = THINKING_EFFORTS) {
+    if (choices.length === 0 || choices.includes(effort))
+        return effort;
+    if (choices.includes("medium"))
+        return "medium";
+    if (choices.includes("high"))
+        return "high";
+    const enabled = choices.filter((item) => item !== "off");
+    if (enabled.length > 0)
+        return enabled[Math.floor((enabled.length - 1) / 2)];
+    if (choices.includes("off"))
+        return "off";
+    return DEFAULT_THINKING_EFFORT;
+}
+export function thinkingSourceLabel(source) {
+    if (source === "cli")
+        return "本次启动参数";
+    if (source === "project")
+        return "项目";
+    if (source === "global")
+        return "全局";
+    return "默认";
+}
+export function resolveThinkingEffort(runOverride, modelId) {
+    let thinking;
+    let source;
+    if (runOverride) {
+        thinking = runOverride;
+        source = "cli";
+    }
+    else {
+        const override = getThinkingOverride();
+        if (override) {
+            thinking = override;
+            source = "cli";
+        }
+        else {
+            const snap = getThinkingSnapshot();
+            thinking = snap.thinking ?? DEFAULT_THINKING_EFFORT;
+            source = snap.source;
+        }
+    }
+    const id = modelId ?? getActiveProvider(getEffectiveConfig())?.defaultModel;
+    return { thinking: clampThinkingEffort(thinking, thinkingChoicesForModel(id)), source };
+}
+export function getThinkingSnapshot() {
+    const project = parseThinkingEffort(loadProjectConfig().thinking);
+    if (project !== undefined)
+        return { thinking: project, source: "project" };
+    const global = parseThinkingEffort(loadConfig().thinking);
+    if (global !== undefined)
+        return { thinking: global, source: "global" };
+    return { thinking: undefined, source: null };
+}
+function clearProjectThinking() {
+    const project = loadProjectConfig();
+    if (project.thinking === undefined)
+        return;
+    const { thinking: _removed, ...rest } = project;
+    saveProjectConfig(rest);
+}
+export function setThinkingEffort(effort, scope) {
+    if (scope === "project") {
+        saveProjectConfig({ ...loadProjectConfig(), thinking: effort });
+        return;
+    }
+    saveConfig({ ...loadConfig(), thinking: effort });
+    // A leftover project value (including off) would keep shadowing the global file.
+    clearProjectThinking();
+}
+export function thinkingPayload() {
+    const { thinking, source } = resolveThinkingEffort();
+    return {
+        thinking,
+        source,
+        label: thinkingEffortLabel(thinking),
+    };
+}
+export function toWireEffort(effort, providerType, modelId) {
+    if (effort === "off")
+        return "none";
+    if (effort !== "max")
+        return effort;
+    const catalog = modelId ? getCachedModelCatalog(modelId) : undefined;
+    const supported = catalog?.reasoning.efforts ?? [];
+    if (supported.includes("max"))
+        return "max";
+    if (supported.includes("xhigh") || providerType === "openai")
+        return "xhigh";
+    return "max";
+}
+export function resolveThinkingRequest(opts) {
+    const { thinking } = resolveThinkingEffort(opts?.runOverride, opts?.modelId);
+    const providerType = opts?.providerType ?? getActiveProvider(getEffectiveConfig())?.type;
+    return {
+        reasoningEffort: toWireEffort(thinking, providerType, opts?.modelId),
+        thinkingEnabled: thinking !== "off",
+    };
+}

package/dist/token-display.js

@@ -24,13 +24,16 @@ export function tokenInfoFromTracker(tracker, contextWindow, estimatedContext =
     };
 }
 export function formatTokenStatusLabel(info) {
-    const parts = [];
     const pct = contextUsagePercent(info.context, info.contextWindow);
-    if (pct != null) {
-        parts.push(`${formatTokenCount(info.context)}/${formatTokenCount(info.contextWindow)} ${pct}%`);
-    }
-    if (info.input > 0 || info.output > 0) {
-        parts.push(`累计 ${formatTokenCount(info.input)} in · ${formatTokenCount(info.output)} out`);
-    }
+    if (pct == null)
+        return "";
+    return `${formatTokenCount(info.context)}/${formatTokenCount(info.contextWindow)} ${pct}%`;
+}
+export function formatModelStatusMeta(thinkingLabel, contextWindow, memoryOn = false) {
+    const parts = [`思考 ${thinkingLabel}`];
+    if (memoryOn)
+        parts.push("记忆 开");
+    if (contextWindow && contextWindow > 0)
+        parts.push(`窗口 ${formatTokenCount(contextWindow)}`);
     return parts.join(" · ");
 }

package/dist/tools/todo.js

@@ -61,24 +61,37 @@ function messageText(msg) {
         .map((p) => p.text)
         .join("\n");
 }
+const CHITCHAT_RE = /^(你好|您好|嗨|哈喽|哈罗|哈囉|在吗|在嗎|早上好|晚上好|早安|午安|hello|hi|hey|yo|sup|thanks|thankyou|thx|ty|谢谢|谢谢你|多谢|感谢|ok|okay|好的|收到)$/i;
+/** Greetings / acknowledgements are not a durable task. "你好，帮我修 bug" is. */
+export function isChitchatUserText(text) {
+    const stripped = text.trim().replace(/[\s\p{P}\p{S}\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu, "");
+    return stripped.length === 0 || CHITCHAT_RE.test(stripped);
+}
+function durableGoal(text) {
+    const trimmed = text.trim();
+    if (!trimmed || isChitchatUserText(trimmed))
+        return undefined;
+    return trimmed.slice(0, GOAL_MAX_CHARS);
+}
 /** Keep the first real user request so compaction cannot drop the original goal. */
 export function captureGoal(state, messages) {
-    if (state.goal.trim())
+    if (state.goal.trim() && !isChitchatUserText(state.goal))
         return;
     for (const msg of messages) {
         if (msg.role !== "user")
             continue;
         if (isSyntheticMessage(msg))
             continue;
-        const text = messageText(msg).trim();
-        if (!text)
+        const goal = durableGoal(messageText(msg));
+        if (!goal)
             continue;
-        state.goal = text.slice(0, GOAL_MAX_CHARS);
+        state.goal = goal;
         return;
     }
 }
 export function formatTaskStatePrompt(state) {
-    if (!state.goal && state.todos.length === 0)
+    const goal = state.goal.trim() && !isChitchatUserText(state.goal) ? state.goal : "";
+    if (!goal && state.todos.length === 0)
         return "";
     const icons = {
         pending: "pending",
@@ -88,10 +101,11 @@ export function formatTaskStatePrompt(state) {
     };
     const lines = [
         "## Current Task",
-        "This block is the durable task state. It survives context compaction. Keep it accurate with the todo tool.",
+        "This block tracks progress for the current user request. It is not a reason to start extra work.",
+        "If the task list is missing or empty, there is no pending work to resume. Follow the current user message only. Keep the list accurate with the todo tool.",
     ];
-    if (state.goal) {
-        lines.push("", "### Original goal", state.goal);
+    if (goal) {
+        lines.push("", "### Original goal", goal);
     }
     if (state.todos.length > 0) {
         lines.push("", "### Task list");

package/dist/tui/App.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useState } from "react";
+import { useCallback, useEffect, useState } from "react";
 import { Box, useInput, useStdout } from "ink";
 import { Spinner } from "./Spinner.js";
 import { InputBar } from "./InputBar.js";
@@ -8,11 +8,13 @@ import { ConfirmBar, confirmBarRows } from "./ConfirmBar.js";
 import { QuestionBar, questionBarRows } from "./QuestionBar.js";
 import { StatusBar } from "./StatusBar.js";
 import { ModelPicker, modelPickerRows } from "./ModelPicker.js";
+import { ThinkPicker, thinkPickerRows } from "./ThinkPicker.js";
+import { CtxPicker, ctxPickerRows } from "./CtxPicker.js";
 import { SessionPicker, sessionPickerRows } from "./SessionPicker.js";
 import { setCaretPosition } from "./caret.js";
 import { computeMessageMaxHeight, frameRows, INPUT_BAR_ROWS } from "./layout.js";
 import { isCtrlC } from "./input-history.js";
-export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onModelPick, onModelCancel, onSessionPick, onSessionCancel, onToggleSelectionMode, onExitSelectionMode, onExit, onCopyNotice, }) {
+export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onModelPick, onModelCancel, onThinkPick, onThinkCancel, onCtxPick, onCtxCancel, onSessionPick, onSessionCancel, onToggleSelectionMode, onExitSelectionMode, onExit, onCopyNotice, onNotice, }) {
     // Ink recalculates its own layout on resize without re-rendering React, so
     // track terminal size ourselves to keep heights/widths in sync.
     const { stdout } = useStdout();
@@ -38,6 +40,14 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
                 onModelCancel();
                 return;
             }
+            if (initialState.thinkPicker) {
+                onThinkCancel();
+                return;
+            }
+            if (initialState.ctxPicker) {
+                onCtxCancel();
+                return;
+            }
             if (initialState.sessionPicker) {
                 onSessionCancel();
                 return;
@@ -55,6 +65,8 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
             if (initialState.confirmMessage ||
                 initialState.question ||
                 initialState.modelPicker ||
+                initialState.thinkPicker ||
+                initialState.ctxPicker ||
                 initialState.sessionPicker)
                 return;
             if (initialState.isRunning)
@@ -69,30 +81,58 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
             !initialState.confirmMessage &&
             !initialState.question &&
             !initialState.modelPicker &&
+            !initialState.thinkPicker &&
+            !initialState.ctxPicker &&
             !initialState.sessionPicker) {
             onExit();
         }
     });
-    if (initialState.confirmMessage || initialState.question || initialState.modelPicker || initialState.sessionPicker)
+    if (initialState.confirmMessage ||
+        initialState.question ||
+        initialState.modelPicker ||
+        initialState.thinkPicker ||
+        initialState.ctxPicker ||
+        initialState.sessionPicker)
         setCaretPosition(null);
     const columns = terminal.columns;
     const terminalRows = terminal.rows;
     const layoutRows = frameRows(terminalRows);
+    const [inputBarRows, setInputBarRows] = useState(INPUT_BAR_ROWS);
+    const onInputBarRowsChange = useCallback((rows) => {
+        setInputBarRows((prev) => (prev === rows ? prev : rows));
+    }, []);
     const confirmActive = Boolean(initialState.confirmMessage);
     const questionActive = Boolean(initialState.question);
     const modelPickerActive = Boolean(initialState.modelPicker);
+    const thinkPickerActive = Boolean(initialState.thinkPicker);
+    const ctxPickerActive = Boolean(initialState.ctxPicker);
     const sessionPickerActive = Boolean(initialState.sessionPicker);
+    const overlayActive = confirmActive || questionActive || modelPickerActive || thinkPickerActive || ctxPickerActive || sessionPickerActive;
+    useEffect(() => {
+        if (overlayActive)
+            setInputBarRows(INPUT_BAR_ROWS);
+    }, [overlayActive]);
     const footerRows = confirmActive
         ? confirmBarRows(initialState.confirmMessage ?? "", columns, layoutRows)
         : questionActive
             ? questionBarRows(initialState.question.prompt, initialState.question.options, columns, layoutRows)
             : modelPickerActive
                 ? modelPickerRows(layoutRows)
-                : sessionPickerActive
-                    ? sessionPickerRows(layoutRows)
-                    : INPUT_BAR_ROWS;
-    const spinnerVisible = initialState.isRunning && !confirmActive && !questionActive && !modelPickerActive && !sessionPickerActive;
+                : thinkPickerActive
+                    ? thinkPickerRows()
+                    : ctxPickerActive
+                        ? ctxPickerRows()
+                        : sessionPickerActive
+                            ? sessionPickerRows(layoutRows)
+                            : inputBarRows;
+    const spinnerVisible = initialState.isRunning &&
+        !confirmActive &&
+        !questionActive &&
+        !modelPickerActive &&
+        !thinkPickerActive &&
+        !ctxPickerActive &&
+        !sessionPickerActive;
     const spinnerRows = spinnerVisible ? 1 : 0;
     const messageMaxHeight = computeMessageMaxHeight(layoutRows, footerRows, spinnerRows);
-    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: layoutRows || undefined, overflow: "hidden", children: [!modelPickerActive && (_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflow: "hidden", width: "100%", children: _jsx(MessageList, { messages: initialState.messages, maxHeight: messageMaxHeight, columns: columns, onCopyNotice: onCopyNotice, selectionMode: Boolean(initialState.selectionMode), onExitSelectionMode: onExitSelectionMode, interactive: !confirmActive && !questionActive }) })), spinnerVisible && (_jsx(Box, { paddingLeft: 1, flexShrink: 0, width: "100%", children: _jsx(Spinner, { label: initialState.spinnerText || "思考中..." }) })), _jsx(StatusBar, { state: initialState, columns: columns }), initialState.confirmMessage ? (_jsx(ConfirmBar, { message: initialState.confirmMessage, onConfirm: onConfirm, columns: columns, maxRows: footerRows })) : initialState.question ? (_jsx(QuestionBar, { prompt: initialState.question.prompt, options: initialState.question.options, onAnswer: onQuestionAnswer, columns: columns, maxRows: footerRows })) : initialState.modelPicker ? (_jsx(ModelPicker, { currentModel: initialState.model, onSelect: onModelPick, onCancel: onModelCancel })) : initialState.sessionPicker ? (_jsx(SessionPicker, { currentId: initialState.sessionId, onSelect: onSessionPick, onCancel: onSessionCancel })) : (_jsx(InputBar, { onSubmit: onSubmit, disabled: initialState.isRunning || Boolean(initialState.selectionMode), placeholder: initialState.isRunning ? "按 Esc 取消运行..." : "输入消息... (Ctrl+J 换行)", columns: columns, terminalRows: layoutRows, onSelectionMode: onToggleSelectionMode, onExit: onExit }))] }));
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: layoutRows || undefined, overflow: "hidden", children: [!modelPickerActive && (_jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, minHeight: 0, overflow: "hidden", width: "100%", children: _jsx(MessageList, { messages: initialState.messages, maxHeight: messageMaxHeight, columns: columns, onCopyNotice: onCopyNotice, selectionMode: Boolean(initialState.selectionMode), onExitSelectionMode: onExitSelectionMode, interactive: !confirmActive && !questionActive }) })), spinnerVisible && (_jsx(Box, { paddingLeft: 1, flexShrink: 0, width: "100%", children: _jsx(Spinner, { label: initialState.spinnerText || "思考中..." }) })), _jsx(StatusBar, { state: initialState, columns: columns }), initialState.confirmMessage ? (_jsx(ConfirmBar, { message: initialState.confirmMessage, onConfirm: onConfirm, columns: columns, maxRows: footerRows })) : initialState.question ? (_jsx(QuestionBar, { prompt: initialState.question.prompt, options: initialState.question.options, onAnswer: onQuestionAnswer, columns: columns, maxRows: footerRows })) : initialState.modelPicker ? (_jsx(ModelPicker, { currentModel: initialState.model, onSelect: onModelPick, onCancel: onModelCancel })) : initialState.thinkPicker ? (_jsx(ThinkPicker, { scope: initialState.thinkPicker.scope, modelId: initialState.model, onSelect: (effort) => onThinkPick(effort, initialState.thinkPicker.scope), onCancel: onThinkCancel })) : initialState.ctxPicker ? (_jsx(CtxPicker, { onSelect: onCtxPick, onCancel: onCtxCancel })) : initialState.sessionPicker ? (_jsx(SessionPicker, { currentId: initialState.sessionId, onSelect: onSessionPick, onCancel: onSessionCancel })) : (_jsx(InputBar, { onSubmit: onSubmit, disabled: initialState.isRunning || Boolean(initialState.selectionMode), placeholder: initialState.isRunning ? "按 Esc 取消运行..." : "输入消息... (Ctrl+J 换行)", columns: columns, terminalRows: layoutRows, onSelectionMode: onToggleSelectionMode, onExit: onExit, onRowsChange: onInputBarRowsChange, onNotice: onNotice }))] }));
 }

package/dist/tui/CtxPicker.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { getActiveProvider, loadConfig } from "../config.js";
+import { CTX_CHOICES, ctxChoiceLabel, matchCtxLevel } from "../ctx.js";
+import { formatTokenCount } from "../token-display.js";
+import { shouldAcceptOverlayConfirm } from "./overlay-input.js";
+import { theme } from "./theme.js";
+export function ctxPickerRows() {
+    return 2 + 1 + 1 + CTX_CHOICES.length + 1;
+}
+function configuredTokens() {
+    const n = getActiveProvider(loadConfig())?.contextWindow;
+    if (typeof n === "number" && Number.isFinite(n) && n > 0)
+        return Math.floor(n);
+    return undefined;
+}
+function currentLabel() {
+    const tokens = configuredTokens();
+    if (tokens == null)
+        return ctxChoiceLabel("auto");
+    return matchCtxLevel(tokens) ?? formatTokenCount(tokens);
+}
+function markedChoice() {
+    const tokens = configuredTokens();
+    if (tokens == null)
+        return "auto";
+    return matchCtxLevel(tokens);
+}
+export function CtxPicker({ onSelect, onCancel }) {
+    const marked = markedChoice();
+    const [index, setIndex] = useState(() => {
+        const i = marked ? CTX_CHOICES.indexOf(marked) : -1;
+        return i >= 0 ? i : CTX_CHOICES.length - 1;
+    });
+    const armed = useRef(false);
+    const indexRef = useRef(index);
+    indexRef.current = index;
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            armed.current = true;
+        }, 0);
+        return () => clearTimeout(timer);
+    }, []);
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.downArrow) {
+            setIndex((i) => (i + 1) % CTX_CHOICES.length);
+            return;
+        }
+        if (key.upArrow) {
+            setIndex((i) => (i - 1 + CTX_CHOICES.length) % CTX_CHOICES.length);
+            return;
+        }
+        if (shouldAcceptOverlayConfirm(armed.current, key, input)) {
+            const picked = CTX_CHOICES[indexRef.current];
+            if (picked)
+                onSelect(picked);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", flexShrink: 0, width: "100%", borderStyle: "round", borderColor: theme.pickerBorder, paddingX: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: theme.pickerBorder, children: "\u9009\u62E9\u4E0A\u4E0B\u6587\u7A97\u53E3" }) }), _jsx(Box, { children: _jsxs(Text, { color: theme.muted, children: ["\u5F53\u524D: ", currentLabel()] }) }), CTX_CHOICES.map((choice, i) => {
+                const active = i === index;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: active ? theme.accent : theme.muted, children: active ? "❯ " : "  " }), _jsx(Text, { bold: active, color: active ? theme.accent : undefined, children: ctxChoiceLabel(choice) }), choice === marked && _jsx(Text, { color: theme.success, children: " \u2190 \u5F53\u524D" })] }, choice));
+            }), _jsx(Box, { children: _jsx(Text, { color: theme.muted, dimColor: true, wrap: "truncate-end", children: "\u2191\u2193 \u9009\u62E9 \u00B7 Enter \u786E\u8BA4 \u00B7 Esc \u53D6\u6D88" }) })] }));
+}