dsh-lark-agent 0.1.2 → 0.3.0

package/dist/live-reply.js

@@ -0,0 +1,518 @@
+import { cardMarkdown, markdownBlocks, plainLabel } from './replies.js';
+// CardKit rejects cards over 30 KB, measured on the card JSON.
+const CARD_BYTES = 28_000;
+const LIVE_ANSWER_BYTES = 20_000;
+const MAX_KEPT_CHARS = 40_000;
+// Cards have a component limit; older steps fold into one note beyond this.
+const MAX_ROWS = 60;
+// One card entity accepts at most 10 operations per second.
+const STREAM_INTERVAL_MS = 500;
+const FULL_INTERVAL_MS = 2_000;
+// Feishu turns streaming mode off 10 minutes after it was last turned on.
+const REOPEN_AFTER_MS = 9 * 60_000;
+const TRUNCATED = '回复超过了飞书卡片的长度上限，后面的内容没有显示。完整回复在电脑上的这段 Harness 会话里，也可以让我整理成文档。';
+const grey = (markdown) => `<font color='grey'>${markdown}</font>`;
+const bytes = (value) => Buffer.byteLength(typeof value === 'string' ? value : JSON.stringify(value), 'utf8');
+const code = (value) => '`' + value.replace(/`/g, 'ˋ') + '`';
+/** The App's step labels and a matching Feishu icon, by tool name. */
+function activity(name) {
+    const is = (...names) => names.includes(name);
+    if (is('read'))
+        return { label: '读取', doing: '正在读取文件', icon: 'file-link-text_outlined' };
+    if (is('read_image'))
+        return { label: '读取图片', doing: '正在读取图片', icon: 'image_outlined' };
+    if (is('grep'))
+        return { label: '搜索文件内容', doing: '正在搜索代码', icon: 'doc-search_outlined' };
+    if (is('glob') || name.endsWith('_inspect'))
+        return { label: '查找文件', doing: '正在搜索代码', icon: 'search_outlined' };
+    if (is('write'))
+        return { label: '写入', doing: '正在写入文件', icon: 'add-doc_outlined' };
+    if (is('edit', 'apply_patch'))
+        return { label: '编辑', doing: '正在编辑文件', icon: 'edit_outlined' };
+    if (is('bash', 'pwsh', 'exec_command', 'write_stdin') || name.startsWith('terminal_'))
+        return { label: '运行命令', doing: '正在运行命令', icon: 'code_outlined' };
+    if (is('run_code'))
+        return { label: '运行代码', doing: '正在运行代码', icon: 'codeblock_outlined' };
+    if (is('web_search'))
+        return { label: '网页搜索', doing: '正在搜索网页', icon: 'internet_outlined' };
+    if (is('web_fetch'))
+        return { label: '网页获取', doing: '正在访问网页', icon: 'web-card_outlined' };
+    if (is('subagent') || name.startsWith('subagent_'))
+        return { label: '子智能体', doing: '正在协调子智能体', icon: 'robot_outlined' };
+    if (is('todo_write', 'create_goal', 'update_goal', 'get_goal'))
+        return { label: '更新计划', doing: '正在更新计划', icon: 'list-check_outlined' };
+    if (is('ask_user_question', 'request_user_input'))
+        return { label: '提问', doing: '等待你的操作', icon: 'chat_outlined' };
+    if (name.startsWith('lark_memory_'))
+        return { label: '记忆', doing: '正在查看记忆', icon: 'mindnote_outlined' };
+    if (is('lark_present'))
+        return { label: '整理作品', doing: '正在整理作品', icon: 'web-card_outlined' };
+    return { label: plainLabel(name, 40) || '工具调用', doing: '正在调用工具', icon: 'setting_outlined' };
+}
+/** The longest prefix of text within maxBytes, never splitting a code point. */
+function head(text, maxBytes) {
+    let size = 0, end = 0;
+    for (const point of text) {
+        size += Buffer.byteLength(point, 'utf8');
+        if (size > maxBytes)
+            break;
+        end += point.length;
+    }
+    return text.slice(0, end);
+}
+/**
+ * A suffix of text within maxBytes. The cut moves in coarse steps so that
+ * successive updates mostly share a prefix, which keeps Feishu's typewriter
+ * effect instead of redrawing the whole element.
+ */
+function tail(text, maxBytes) {
+    if (bytes(text) <= maxBytes)
+        return text;
+    let size = 0, start = text.length;
+    while (start > 0) {
+        const pair = start >= 2 && (text.charCodeAt(start - 1) & 0xfc00) === 0xdc00 && (text.charCodeAt(start - 2) & 0xfc00) === 0xd800;
+        const width = Buffer.byteLength(text.slice(start - (pair ? 2 : 1), start), 'utf8');
+        if (size + width > maxBytes)
+            break;
+        size += width;
+        start -= pair ? 2 : 1;
+    }
+    let cut = Math.ceil(start / 1_000) * 1_000;
+    const newline = text.indexOf('\n', cut);
+    if (newline >= 0 && newline - cut < 200)
+        cut = newline + 1;
+    if (cut < text.length && (text.charCodeAt(cut) & 0xfc00) === 0xdc00)
+        cut++;
+    return text.slice(Math.min(cut, text.length));
+}
+/**
+ * One streaming reply card: the answer, with the process in a panel that
+ * stays folded unless the reader opens it. Like the App, the process is a
+ * list of steps, thinking and tool calls, each on its own row. Only the
+ * initial reply is a send; every later operation updates the same card
+ * entity and is safe to supersede or repeat. A reply never continues in
+ * another message.
+ */
+export class LiveReply {
+    transport;
+    target;
+    options;
+    phase = 'thinking';
+    steps = [];
+    nextStep = 0;
+    trimmed = false;
+    answer = '';
+    separator = false;
+    mark = { steps: 0, tail: -1, answer: 0 };
+    tools = 0;
+    note;
+    footer;
+    cardId;
+    sequence = 0;
+    sent = new Map();
+    shown = [];
+    dirty = false;
+    layoutDirty = false;
+    degraded = false;
+    streamFailures = 0;
+    closed = false;
+    loop;
+    wake;
+    streamingSince = 0;
+    startedAt;
+    answeredAt;
+    finishedAt;
+    constructor(transport, target, options = {}) {
+        this.transport = transport;
+        this.target = target;
+        this.options = options;
+        this.startedAt = this.now();
+    }
+    /** Send the card. False means nothing was sent, so the caller keeps its ordinary reply. */
+    async open() {
+        let card;
+        try {
+            card = this.card();
+            this.cardId = await this.transport.createCardEntity(card);
+        }
+        catch {
+            this.audit('live-card-unavailable');
+            return false;
+        }
+        this.streamingSince = this.now();
+        this.markSent(card);
+        try {
+            await this.transport.replyCardEntity(this.target.messageId, this.cardId, { idempotencyKey: this.target.idempotencyKey, inThread: this.target.inThread });
+        }
+        // The reply may still have been delivered. Never send another message for this
+        // turn; updating a card nobody received is harmless.
+        catch {
+            this.audit('live-card-delivery-unknown');
+        }
+        if (this.dirty)
+            this.schedule();
+        return true;
+    }
+    /** Trusted settings line under the answer, such as the model and thinking depth in use. */
+    setFooter(text) {
+        if (this.closed || !text.trim() || text === this.footer)
+            return;
+        this.footer = text;
+        this.layoutDirty = true;
+        this.schedule();
+    }
+    push(event) {
+        if (this.closed)
+            return;
+        switch (event.type) {
+            case 'attempt': {
+                const last = this.steps.at(-1);
+                this.mark = { steps: this.steps.length, tail: last?.kind === 'reasoning' ? last.text.length : -1, answer: this.answer.length };
+                this.separator = this.answer.length > 0;
+                break;
+            }
+            case 'discard': {
+                if (this.steps.length > this.mark.steps)
+                    this.layoutDirty = true;
+                this.steps.length = Math.min(this.steps.length, this.mark.steps);
+                const last = this.steps.at(-1);
+                if (this.mark.tail >= 0 && last?.kind === 'reasoning')
+                    last.text = last.text.slice(0, this.mark.tail);
+                this.answer = this.answer.slice(0, this.mark.answer);
+                this.separator = this.answer.length > 0;
+                // A discarded draft was the only answer so far: the reply is still at work.
+                if (!this.answer && this.phase === 'answering') {
+                    this.phase = 'thinking';
+                    this.answeredAt = undefined;
+                    this.layoutDirty = true;
+                }
+                break;
+            }
+            case 'reasoning': {
+                const last = this.steps.at(-1);
+                if (last?.kind === 'reasoning')
+                    last.text += event.text;
+                else {
+                    this.steps.push({ id: this.nextStep++, kind: 'reasoning', text: event.text });
+                    this.layoutDirty = true;
+                }
+                this.trim();
+                break;
+            }
+            case 'text':
+                if (this.answer.length > 70_000)
+                    return;
+                if (this.separator) {
+                    this.answer += '\n\n';
+                    this.separator = false;
+                }
+                this.answer += event.text;
+                // The folded panel's title switches from the current step to the time it took.
+                if (this.phase === 'thinking') {
+                    this.phase = 'answering';
+                    this.answeredAt = this.now();
+                    this.layoutDirty = true;
+                }
+                break;
+            case 'tool':
+                if (this.steps.some(step => step.kind === 'tool' && step.callId === event.callId))
+                    return;
+                this.steps.push({ id: this.nextStep++, kind: 'tool', callId: event.callId, name: event.name, state: 'running',
+                    ...(event.detail ? { detail: event.detail } : {}), ...(event.code ? { code: true } : {}) });
+                this.tools++;
+                this.layoutDirty = true;
+                this.trim();
+                break;
+            case 'tool-done': {
+                const step = this.steps.find(item => item.kind === 'tool' && item.callId === event.callId);
+                if (step?.kind !== 'tool')
+                    return;
+                step.state = event.ok ? 'done' : 'failed';
+                if (event.exitCode !== undefined)
+                    step.exitCode = event.exitCode;
+                // The title names the running step, so it changes too.
+                this.layoutDirty = true;
+                break;
+            }
+        }
+        this.schedule();
+    }
+    /** Stop streaming and write the final card. True only when Feishu confirmed it. */
+    async finish(final) {
+        if (this.closed)
+            return false;
+        this.closed = true;
+        this.wake?.();
+        await this.loop;
+        this.finishedAt = this.now();
+        this.phase = final.phase;
+        if (final.answer !== undefined)
+            this.answer = final.answer;
+        if (final.reasoning && !this.steps.some(step => step.kind === 'reasoning'))
+            this.steps.unshift({ id: this.nextStep++, kind: 'reasoning', text: final.reasoning });
+        for (const step of this.steps)
+            if (step.kind === 'tool' && step.state === 'running')
+                step.state = final.phase === 'done' ? 'done' : 'failed';
+        this.note = final.note;
+        const card = this.finalCard();
+        if (!this.cardId)
+            return false;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                await this.transport.updateCardEntity(this.cardId, card, ++this.sequence);
+                return true;
+            }
+            catch {
+                if (attempt < 2)
+                    await this.sleep(500 * 3 ** attempt);
+            }
+        }
+        this.audit('live-card-final-failed');
+        return false;
+    }
+    now() { return (this.options.now ?? Date.now)(); }
+    sleep(ms) { return (this.options.sleep ?? (wait => new Promise(done => setTimeout(done, wait))))(ms); }
+    audit(stage) { try {
+        this.options.audit?.(stage);
+    }
+    catch { /* Diagnostics only. */ } }
+    /** Keep only what the card can still show; the turn result stays authoritative. */
+    trim() {
+        let total = this.steps.reduce((sum, step) => sum + (step.kind === 'reasoning' ? step.text.length : 200), 0);
+        while ((total > MAX_KEPT_CHARS || this.steps.length > MAX_ROWS * 2) && this.steps.length > 1) {
+            const removed = this.steps.shift();
+            total -= removed.kind === 'reasoning' ? removed.text.length : 200;
+            this.mark.steps = Math.max(0, this.mark.steps - 1);
+            this.trimmed = true;
+            this.layoutDirty = true;
+        }
+        const only = this.steps[0];
+        if (this.steps.length === 1 && only?.kind === 'reasoning' && only.text.length > MAX_KEPT_CHARS) {
+            const cut = only.text.length - MAX_KEPT_CHARS / 2;
+            only.text = only.text.slice(cut);
+            this.mark.tail = Math.max(-1, this.mark.tail - cut);
+            this.trimmed = true;
+        }
+    }
+    schedule() {
+        this.dirty = true;
+        if (!this.cardId || this.closed || this.loop)
+            return;
+        this.loop = this.run().finally(() => {
+            this.loop = undefined;
+            if (this.dirty && !this.closed)
+                this.schedule();
+        });
+    }
+    async run() {
+        while (this.dirty && !this.closed) {
+            this.dirty = false;
+            const started = this.now();
+            await this.flush();
+            const wait = (this.degraded ? FULL_INTERVAL_MS : STREAM_INTERVAL_MS) - (this.now() - started);
+            if (wait > 0 && !this.closed)
+                await this.pause(wait);
+        }
+    }
+    /** Pacing between updates; finishing the reply ends it early. */
+    async pause(ms) {
+        await Promise.race([this.sleep(ms), new Promise(done => { this.wake = done; })]);
+        this.wake = undefined;
+    }
+    async flush() {
+        const cardId = this.cardId;
+        const card = this.card();
+        const elements = this.textElements(card);
+        // Rows that appeared, left or moved need the whole card, which also sets the title.
+        const layout = elements.filter(([id]) => id !== 'answer').map(([id]) => id).join() !== this.shown.join();
+        if (this.degraded || this.layoutDirty || layout || this.now() - this.streamingSince > REOPEN_AFTER_MS) {
+            this.layoutDirty = false;
+            try {
+                // A complete card also turns streaming mode back on.
+                await this.transport.updateCardEntity(cardId, card, ++this.sequence);
+                this.streamingSince = this.now();
+                this.markSent(card);
+                this.degraded = this.streamFailures >= 3;
+            }
+            catch {
+                this.degraded = true;
+            }
+            return;
+        }
+        for (const [id, content] of elements) {
+            if (this.closed)
+                return;
+            if (this.sent.get(id) === content)
+                continue;
+            try {
+                await this.transport.streamCardText(cardId, id, content, ++this.sequence);
+                this.sent.set(id, content);
+            }
+            catch {
+                this.streamFailures++;
+                this.degraded = true;
+                this.audit('live-card-degraded');
+                return;
+            }
+        }
+    }
+    /** Streamable text elements of a card: its process rows and the answer. */
+    textElements(card) {
+        const result = [];
+        const visit = (items) => {
+            for (const item of items) {
+                if (Array.isArray(item.elements))
+                    visit(item.elements);
+                if (item.tag === 'markdown' && typeof item.element_id === 'string' && /^(?:s[0-9]+|answer)$/.test(item.element_id)) {
+                    result.push([item.element_id, item.content]);
+                }
+            }
+        };
+        visit(card.body.elements);
+        return result;
+    }
+    markSent(card) {
+        const elements = this.textElements(card);
+        this.sent.clear();
+        for (const [id, content] of elements)
+            this.sent.set(id, content);
+        this.shown = elements.filter(([id]) => id !== 'answer').map(([id]) => id);
+    }
+    /** One step as a row, in the App's words: what was done and on what. */
+    row(step, maxBytes = Infinity) {
+        if (step.kind === 'reasoning') {
+            const text = step.text.trim();
+            const shown = bytes(text) > maxBytes ? tail(text, Math.max(200, maxBytes)) : text;
+            return { tag: 'markdown', element_id: `s${step.id}`, text_size: 'notation',
+                icon: { tag: 'standard_icon', token: 'mindnote_outlined', color: 'grey' },
+                content: (shown.length < text.length ? `${grey('…')}\n` : '') + (cardMarkdown(shown) || grey('正在思考…')) };
+        }
+        const { label, icon } = activity(step.name);
+        const detail = step.detail ? ' · ' + (step.code ? code(step.detail) : grey(cardMarkdown(step.detail))) : '';
+        const status = step.state === 'running' ? ` · ${grey('进行中…')}`
+            : step.state === 'failed' ? ` · <font color='red'>失败</font>`
+                : step.exitCode !== undefined ? ` · <font color='red'>退出码 ${step.exitCode}</font>` : '';
+        return { tag: 'markdown', element_id: `s${step.id}`, text_size: 'notation',
+            icon: { tag: 'standard_icon', token: icon, color: step.state === 'failed' || step.exitCode !== undefined ? 'red' : 'grey' },
+            content: `${label}${detail}${status}` };
+    }
+    answerContent() {
+        if (!this.answer)
+            return grey('…');
+        const shown = head(this.answer, LIVE_ANSWER_BYTES);
+        return cardMarkdown(shown) + (shown.length < this.answer.length ? `\n\n${grey('……')}` : '');
+    }
+    panelTitle() {
+        const tools = this.tools ? ` · ${this.tools} 次工具调用` : '';
+        const seconds = (end) => Math.max(1, Math.round(((end ?? this.now()) - this.startedAt) / 1000));
+        switch (this.phase) {
+            case 'thinking': {
+                const running = [...this.steps].reverse().find(step => step.kind === 'tool' && step.state === 'running');
+                if (running?.kind !== 'tool')
+                    return `正在思考…${tools}`;
+                const detail = running.detail ? plainLabel(running.detail, 40) : '';
+                return `${activity(running.name).doing}${detail ? ` · ${detail}` : '…'}`;
+            }
+            case 'answering': return `已思考 ${seconds(this.answeredAt)} 秒${tools}`;
+            case 'done': return `已完成，用时 ${seconds(this.finishedAt)} 秒${tools}`;
+            case 'stopped': return `已停止，用时 ${seconds(this.finishedAt)} 秒${tools}`;
+            case 'failed': return `处理失败，用时 ${seconds(this.finishedAt)} 秒${tools}`;
+        }
+    }
+    /** The folded process panel. Readers open it when they want the thinking and tool steps. */
+    panel(rows) {
+        return {
+            tag: 'collapsible_panel', element_id: 'think_panel', expanded: false,
+            header: { title: { tag: 'plain_text', content: this.panelTitle() }, vertical_align: 'center',
+                icon: { tag: 'standard_icon', token: 'down-small-ccm_outlined', color: 'grey', size: '16px 16px' }, icon_position: 'follow_text', icon_expanded_angle: -180 },
+            border: { color: 'grey', corner_radius: '5px' }, vertical_spacing: '6px', padding: '8px 8px 8px 8px',
+            elements: rows.length ? rows : [{ tag: 'markdown', element_id: 's_wait', content: grey('正在思考…'), text_size: 'notation' }],
+        };
+    }
+    /**
+     * The rows that fit in maxBytes, newest last. Older steps give way first and
+     * leave a note; a single oversized thought keeps its most recent part.
+     */
+    rows(maxBytes) {
+        const rows = this.steps.map(step => this.row(step));
+        const sizes = rows.map(row => bytes(row) + 1);
+        let total = sizes.reduce((sum, size) => sum + size, 0);
+        let start = Math.max(0, rows.length - MAX_ROWS);
+        for (let index = 0; index < start; index++)
+            total -= sizes[index];
+        while (start < rows.length - 1 && total > maxBytes)
+            total -= sizes[start++];
+        const shown = rows.slice(start);
+        if (shown.length === 1 && total > maxBytes)
+            shown[0] = this.row(this.steps[start], maxBytes - 400);
+        if (start > 0 || this.trimmed)
+            shown.unshift({ tag: 'markdown', element_id: 'omitted', text_size: 'notation',
+                content: grey('前面的步骤较多，这里只显示最近的部分；完整过程在电脑上的这段 Harness 会话里。') });
+        return shown;
+    }
+    /** Live layout when final is undefined; a final layout otherwise (null leaves out the panel's rows). */
+    card(final) {
+        const elements = [];
+        if (!final)
+            elements.push(this.panel(this.rows(Math.max(1_000, CARD_BYTES - 3_000 - bytes(this.answerContent())))));
+        else if (final.rows)
+            elements.push(this.panel(final.rows));
+        elements.push({ tag: 'markdown', element_id: 'answer',
+            content: final ? (final.answer.trim() ? cardMarkdown(final.answer) : grey('（没有文字回复）')) : this.answerContent() });
+        const note = [this.note, final?.truncated ? TRUNCATED : undefined].filter(Boolean).join(' ');
+        if (final && note)
+            elements.push({ tag: 'markdown', element_id: 'note', content: grey(cardMarkdown(note)), text_size: 'notation' });
+        if (this.footer)
+            elements.push({ tag: 'markdown', element_id: 'footer', text_size: 'notation',
+                icon: { tag: 'standard_icon', token: 'robot_outlined', color: 'grey' }, content: grey(cardMarkdown(this.footer)) });
+        const summary = final ? plainLabel(final.answer || this.note || '回复', 60) || '回复' : this.answer ? '正在回复…' : '正在思考…';
+        return {
+            schema: '2.0',
+            config: { update_multi: true, enable_forward: false, width_mode: 'default', summary: { content: summary }, streaming_mode: !final,
+                ...(final ? {} : { streaming_config: { print_frequency_ms: { default: 30 }, print_step: { default: 2 }, print_strategy: 'fast' } }) },
+            body: { direction: 'vertical', vertical_spacing: '8px', padding: '12px 16px 12px 16px', elements },
+        };
+    }
+    /** The answer comes first. The folded process gets all the space that is left. */
+    finalCard() {
+        // Reserve room for the folded title, so its time and tool count stay visible even beside a long answer.
+        const minimal = this.steps.length ? [{ tag: 'markdown', element_id: 'omitted', text_size: 'notation', content: grey('过程较长，卡片里没有显示；完整过程在电脑上的这段 Harness 会话里。') }] : null;
+        let answer = this.answer, truncated = false;
+        const fits = (candidate, rows) => bytes(this.card({ answer: candidate, rows, truncated })) <= CARD_BYTES;
+        if (!fits(answer, minimal)) {
+            truncated = true;
+            // Cut between top-level blocks so what is shown stays valid Markdown.
+            const blocks = markdownBlocks(this.answer);
+            let low = 1, high = blocks.length - 1, best = 0;
+            while (low <= high) {
+                const middle = (low + high) >> 1;
+                if (fits(blocks.slice(0, middle).join(''), minimal)) {
+                    best = middle;
+                    low = middle + 1;
+                }
+                else
+                    high = middle - 1;
+            }
+            if (best > 0)
+                answer = blocks.slice(0, best).join('');
+            else {
+                // One oversized block, such as a long code listing: cut it by size.
+                let budget = 20_000;
+                answer = head(this.answer, budget);
+                while (answer && !fits(answer, minimal))
+                    answer = head(this.answer, budget = Math.floor(budget * 0.7));
+            }
+        }
+        if (minimal) {
+            let budget = CARD_BYTES - bytes(this.card({ answer, rows: [], truncated })) - 200;
+            while (budget > 300) {
+                const rows = this.rows(budget);
+                if (fits(answer, rows))
+                    return this.card({ answer, rows, truncated });
+                budget = Math.floor(budget * 0.85);
+            }
+        }
+        return this.card({ answer, rows: minimal, truncated });
+    }
+}
+//# sourceMappingURL=live-reply.js.map

package/dist/model-controls.d.ts

@@ -7,6 +7,14 @@ export declare function modelStateText(selection: ModelSelection, catalog: Model
 export declare function isModelQuestion(text: string): boolean;
 export declare function modelChoice(catalog: ModelCatalog, key: string): ModelSelection | undefined;
 export declare function thinkingChoice(catalog: ModelCatalog, selection: ModelSelection, key: string): ModelSelection | undefined;
+/** The card's state: a page, a switch in flight (its choice key), a confirmed switch, a refusal, or a refresh notice. */
+export interface ModelPanelState {
+    page?: number;
+    changed?: boolean;
+    pending?: string;
+    error?: string;
+    notice?: string;
+}
 type Issue = (label: string, command: string, mutation: boolean, primary?: boolean) => ReplyAction | undefined;
-export declare function modelControlPanel(kind: 'model' | 'thinking', catalog: ModelCatalog, selection: ModelSelection, issue: Issue, page?: number, changed?: boolean): ReplyPanel;
+export declare function modelControlPanel(kind: 'model' | 'thinking', catalog: ModelCatalog, selection: ModelSelection, issue: Issue, state?: ModelPanelState): ReplyPanel;
 export {};

package/dist/model-controls.js

@@ -21,23 +21,39 @@ export function thinkingChoice(catalog, selection, key) {
     const found = model?.reasoning?.efforts.filter(item => thinkingChoiceKey(item.id) === key);
     return found?.length === 1 ? { ...selection, reasoningEffort: found[0].id } : undefined;
 }
-export function modelControlPanel(kind, catalog, selection, issue, page = 0, changed = false) {
+export function modelControlPanel(kind, catalog, selection, issue, state = {}) {
     const model = catalog.models.find(item => item.provider === selection.provider && item.model === selection.model);
     const actions = [];
-    const add = (...args) => { const value = issue(...args); if (value)
-        actions.push(value); return Boolean(value); };
-    const summary = modelStateText(selection, catalog);
-    const sections = [{ text: summary }];
+    const sections = [];
+    // While a switch runs nothing is clickable; otherwise the current choice is shown, not offered.
+    const add = (text, command, mutation, current = false, key) => {
+        if (state.pending || current) {
+            actions.push({ label: `${key !== undefined && key === state.pending ? '⏳ ' : current ? '✓ ' : ''}${text}`, value: {}, disabled: true });
+            return true;
+        }
+        const value = issue(text, command, mutation);
+        if (value)
+            actions.push(value);
+        return Boolean(value);
+    };
+    let pendingName;
+    const size = kind === 'model' ? 5 : 6;
     if (kind === 'model') {
-        const pages = Math.max(1, Math.ceil(catalog.models.length / 5));
-        const currentPage = Math.min(Math.max(0, page), pages - 1);
-        for (const item of catalog.models.slice(currentPage * 5, currentPage * 5 + 5)) {
+        // Open on the page that holds the current (or pending) model unless a page was asked for.
+        const index = catalog.models.findIndex(item => state.pending ? modelChoiceKey(item) === state.pending
+            : item.provider === selection.provider && item.model === selection.model);
+        const pages = Math.max(1, Math.ceil(catalog.models.length / size));
+        const currentPage = Math.min(Math.max(0, state.page ?? Math.max(0, Math.floor(index / size))), pages - 1);
+        for (const item of catalog.models.slice(currentPage * size, currentPage * size + size)) {
             const current = item.provider === selection.provider && item.model === selection.model;
+            const key = modelChoiceKey(item);
+            if (key === state.pending)
+                pendingName = label(item.name || item.model);
             // Feishu keeps button text on one line on mobile. Put the provider first
             // so the distinguishing route remains visible when a long name truncates.
-            const text = `${current ? '✓ ' : ''}${label(item.providerName || item.provider, 20)} · ${label(item.name || item.model, 32)}`;
-            if (!add(text, `/model use ${modelChoiceKey(item)}`, true, current)) {
-                sections.push({ title: label(item.name || item.model), text: `/model use ${modelChoiceKey(item)}` });
+            const text = `${label(item.providerName || item.provider, 20)} · ${label(item.name || item.model, 32)}`;
+            if (!add(text, `/model use ${key}`, true, current, key)) {
+                sections.push({ title: label(item.name || item.model), text: `/model use ${key}` });
             }
         }
         if (!catalog.models.length)
@@ -50,23 +66,32 @@ export function modelControlPanel(kind, catalog, selection, issue, page = 0, cha
     }
     else {
         const efforts = model?.reasoning?.efforts ?? [];
-        const currentPage = Math.min(Math.max(0, page), Math.max(0, Math.ceil(efforts.length / 6) - 1));
-        for (const effort of efforts.slice(currentPage * 6, currentPage * 6 + 6)) {
-            const current = effort.id === selection.reasoningEffort;
-            if (!add(`${current ? '✓ ' : ''}${label(effort.name || effort.id, 32)}`, `/thinking use ${thinkingChoiceKey(effort.id)}`, true, current)) {
-                sections.push({ title: label(effort.name || effort.id), text: `/thinking use ${thinkingChoiceKey(effort.id)}` });
+        const index = efforts.findIndex(effort => state.pending ? thinkingChoiceKey(effort.id) === state.pending : effort.id === selection.reasoningEffort);
+        const currentPage = Math.min(Math.max(0, state.page ?? Math.max(0, Math.floor(index / size))), Math.max(0, Math.ceil(efforts.length / size) - 1));
+        for (const effort of efforts.slice(currentPage * size, currentPage * size + size)) {
+            const key = thinkingChoiceKey(effort.id);
+            if (key === state.pending)
+                pendingName = label(effort.name || effort.id);
+            if (!add(label(effort.name || effort.id, 32), `/thinking use ${key}`, true, effort.id === selection.reasoningEffort, key)) {
+                sections.push({ title: label(effort.name || effort.id), text: `/thinking use ${key}` });
             }
         }
         if (!model?.reasoning?.efforts.length)
             sections.push({ text: '这个模型没有提供可切换的思考档位，可以保留当前配置或选择其他模型。' });
         if (currentPage > 0)
             add('上一页', `/thinking page ${currentPage - 1}`, false);
-        if ((currentPage + 1) * 6 < efforts.length)
+        if ((currentPage + 1) * size < efforts.length)
             add('下一页', `/thinking page ${currentPage + 1}`, false);
         add('选择模型', '/model', false);
     }
-    return { title: changed ? '设置已更新' : kind === 'model' ? '选择模型' : '思考深度', summary,
-        subtitle: '仅用于你在当前聊天中的对话', sections, actions, actionColumns: kind === 'model' ? 1 : 3,
-        note: '下一条回复使用所选配置，已有对话保留。更换模型会使用新模型自身的默认思考档位。' };
+    const current = modelStateText(selection, catalog);
+    const status = state.error ? { text: state.error, tone: 'error' }
+        : state.pending ? { text: `正在切换到「${pendingName ?? '所选配置'}」…`, tone: 'pending' }
+            : state.changed ? { text: `已切换。${current}`, tone: 'success' }
+                : { text: state.notice ? `${state.notice}\n${current}` : current };
+    return { title: state.changed && !state.error ? '设置已更新' : kind === 'model' ? '选择模型' : '思考深度',
+        subtitle: '仅用于你在当前聊天中的对话', tone: status.tone ?? 'normal', status, summary: status.text,
+        sections, actions, actionColumns: kind === 'model' ? 1 : 3,
+        note: state.pending ? '完成后会在这张卡片上更新，无需重复点击。' : '下一条回复使用所选配置，已有对话保留。更换模型会使用新模型自身的默认思考档位。' };
 }
 //# sourceMappingURL=model-controls.js.map