min-agent 0.4.1 → 0.5.0

package/dist/serve/routes-meta.js

@@ -1,12 +1,13 @@
-import { fetchModels, getActiveProvider, getEffectiveConfig, getBudgetSnapshot, setBudgetMaxCost, setSandboxConfig, setPermissionMode, parsePermissionMode, } from "../config.js";
+import { fetchModels, getActiveProvider, getEffectiveConfig, getBudgetSnapshot, setBudgetMaxCost, setSandboxConfig, setPermissionMode, parsePermissionMode, parseThinkingEffort, } from "../config.js";
+import { setThinkingEffort } from "../thinking.js";
 import { parseNetworkPolicy, parseSandboxMode } from "../sandbox.js";
-import { readMemoryScope } from "../memory.js";
+import { readScope } from "../scope.js";
 import { getWorkingTreeDiff } from "../tui/diff-view.js";
 import { scanProject } from "../code-mode.js";
 import { getContextWindowInfo } from "../context-window.js";
 import { getModelPrice, estimateCost } from "../pricing.js";
 import { checkForUpdate } from "../updater.js";
-import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, } from "./common.js";
+import { sendJson, sendJsonError, readJsonBody, readStringPathList, sandboxPayload, permissionPayload, thinkingPayload, memoryPayload, } from "./common.js";
 export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
     if (req.method === "GET" && pathname === "/health") {
         sendJson(res, 200, { ok: true, service: "min-agent", version: ctx.version });
@@ -19,6 +20,8 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             instructions_chars: ctx.instructions.join("\n").length,
             sandbox: sandboxPayload(),
             permission: permissionPayload(),
+            thinking: thinkingPayload(),
+            memory: memoryPayload(),
         });
         return true;
     }
@@ -64,7 +67,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_max_cost", detail: "maxCostUSD must be a positive number" });
             return true;
         }
-        const scopeParsed = readMemoryScope(parsed.value.scope);
+        const scopeParsed = readScope(parsed.value.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;
@@ -94,7 +97,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_permission", detail: "permission must be ask, accept-edits, or allow-all" });
             return true;
         }
-        const scopeParsed = readMemoryScope(parsed.value.scope);
+        const scopeParsed = readScope(parsed.value.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;
@@ -104,6 +107,31 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
         sendJson(res, 200, { ok: true, scope, ...permissionPayload() });
         return true;
     }
+    if (req.method === "GET" && pathname === "/v1/thinking") {
+        sendJson(res, 200, thinkingPayload());
+        return true;
+    }
+    if (req.method === "POST" && pathname === "/v1/thinking") {
+        const parsed = await readJsonBody(req);
+        if (!parsed.ok) {
+            sendJsonError(res, parsed);
+            return true;
+        }
+        const effort = parseThinkingEffort(parsed.value.thinking);
+        if (!effort) {
+            sendJson(res, 400, { error: "invalid_thinking", detail: "thinking must be off, low, medium, high, or max" });
+            return true;
+        }
+        const scopeParsed = readScope(parsed.value.scope);
+        if (!scopeParsed.ok) {
+            sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
+            return true;
+        }
+        const scope = scopeParsed.scope ?? "global";
+        setThinkingEffort(effort, scope);
+        sendJson(res, 200, { ok: true, scope, ...thinkingPayload() });
+        return true;
+    }
     if (req.method === "POST" && pathname === "/v1/sandbox") {
         const parsed = await readJsonBody(req);
         if (!parsed.ok) {
@@ -134,7 +162,7 @@ export const handleMetaRoutes = async (req, res, ctx, url, pathname) => {
             sendJson(res, 400, { error: "invalid_body", detail: "Provide mode, network, extraWriteRoots, or extraReadRoots" });
             return true;
         }
-        const scopeParsed = readMemoryScope(body.scope);
+        const scopeParsed = readScope(body.scope);
         if (!scopeParsed.ok) {
             sendJson(res, 400, { error: "invalid_scope", allowed: ["global", "project"] });
             return true;

package/dist/think-cli.js

@@ -0,0 +1,36 @@
+import { takeScopeFlags, scopeLabel } from "./scope.js";
+import { parseThinkingEffort, resolveThinkingEffort, setThinkingEffort, setThinkingOverride, thinkingEffortLabel, } from "./thinking.js";
+export const THINK_CLI_USAGE = [
+    "Usage: min-agent think [off|low|medium|high|max] [--project|--global]",
+    "       min-agent --think off|low|medium|high|max [--project|--global]",
+].join("\n");
+function sourceLabel(source) {
+    return source === "cli" ? "this run" : source === "project" ? "project" : source === "global" ? "global" : "default";
+}
+export function runThinkCli(input) {
+    const { scope: posScope, rest } = takeScopeFlags(input.positionals);
+    const scope = posScope ?? input.scope ?? "global";
+    if (rest[0] === "--help" || rest[0] === "-h") {
+        return { ok: true, lines: [THINK_CLI_USAGE] };
+    }
+    if (rest.length === 1) {
+        const parsed = parseThinkingEffort(rest[0]);
+        if (!parsed)
+            return { ok: false, lines: [THINK_CLI_USAGE] };
+        setThinkingEffort(parsed, scope);
+        setThinkingOverride(parsed);
+        return { ok: true, lines: [`✓ Thinking set to ${thinkingEffortLabel(parsed)} (${scopeLabel(scope)})`] };
+    }
+    if (rest.length > 1)
+        return { ok: false, lines: [THINK_CLI_USAGE] };
+    if (input.flagEffort) {
+        setThinkingEffort(input.flagEffort, scope);
+        setThinkingOverride(input.flagEffort);
+        return { ok: true, lines: [`✓ Thinking set to ${thinkingEffortLabel(input.flagEffort)} (${scopeLabel(scope)})`] };
+    }
+    const { thinking, source } = resolveThinkingEffort();
+    return {
+        ok: true,
+        lines: [`Current thinking: ${thinkingEffortLabel(thinking)} (${sourceLabel(source)})`, THINK_CLI_USAGE],
+    };
+}

package/dist/thinking-wire.js

@@ -0,0 +1,228 @@
+import { AsyncLocalStorage } from "async_hooks";
+import { readFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import { getActiveProvider, getConfigDir, getEffectiveConfig } from "./config.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) {
+    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) {
+    const spec = thinkingRequestStore.getStore();
+    if (!spec || !init || typeof init.body !== "string")
+        return inner(input, init);
+    let parsed;
+    try {
+        parsed = JSON.parse(init.body);
+    }
+    catch {
+        return inner(input, init);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return inner(input, init);
+    const body = parsed;
+    const host = hostnameFromInput(input);
+    const modelId = typeof body.model === "string" ? body.model : "";
+    const providerType = opts?.providerType ?? getActiveProvider(getEffectiveConfig())?.type;
+    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,142 @@
+import { getEffectiveConfig, loadConfig, loadProjectConfig, saveConfig, saveProjectConfig, getActiveProvider, parseThinkingEffort, } from "./config.js";
+import { getCachedModelCatalog } from "./model-catalog.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) {
+    if (!modelId)
+        return [...THINKING_EFFORTS];
+    const entry = getCachedModelCatalog(modelId);
+    if (!entry)
+        return [...THINKING_EFFORTS];
+    return thinkingChoicesFromReasoning(entry.reasoning);
+}
+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)];
+    return choices.find((item) => item !== "off") ?? 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,12 @@ 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 { 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, 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 +39,10 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
                 onModelCancel();
                 return;
             }
+            if (initialState.thinkPicker) {
+                onThinkCancel();
+                return;
+            }
             if (initialState.sessionPicker) {
                 onSessionCancel();
                 return;
@@ -55,6 +60,7 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
             if (initialState.confirmMessage ||
                 initialState.question ||
                 initialState.modelPicker ||
+                initialState.thinkPicker ||
                 initialState.sessionPicker)
                 return;
             if (initialState.isRunning)
@@ -69,30 +75,52 @@ export function App({ initialState, onSubmit, onConfirm, onQuestionAnswer, onMod
             !initialState.confirmMessage &&
             !initialState.question &&
             !initialState.modelPicker &&
+            !initialState.thinkPicker &&
             !initialState.sessionPicker) {
             onExit();
         }
     });
-    if (initialState.confirmMessage || initialState.question || initialState.modelPicker || initialState.sessionPicker)
+    if (initialState.confirmMessage ||
+        initialState.question ||
+        initialState.modelPicker ||
+        initialState.thinkPicker ||
+        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 sessionPickerActive = Boolean(initialState.sessionPicker);
+    const overlayActive = confirmActive || questionActive || modelPickerActive || thinkPickerActive || 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()
+                    : sessionPickerActive
+                        ? sessionPickerRows(layoutRows)
+                        : inputBarRows;
+    const spinnerVisible = initialState.isRunning &&
+        !confirmActive &&
+        !questionActive &&
+        !modelPickerActive &&
+        !thinkPickerActive &&
+        !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.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 }))] }));
 }