dsh-lark-agent 0.2.0 → 0.3.1

package/dist/live-reply.js

@@ -1,10 +1,10 @@
 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_STEP_BYTES = 6_000;
 const LIVE_ANSWER_BYTES = 20_000;
-const FINAL_STEP_BYTES = 8_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;
@@ -14,6 +14,41 @@ const TRUNCATED = '回复超过了飞书卡片的长度上限，后面的内容
 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;
@@ -51,10 +86,12 @@ function tail(text, maxBytes) {
     return text.slice(Math.min(cut, text.length));
 }
 /**
- * One streaming reply card: the answer, with reasoning and tool steps in a
- * panel that stays folded unless the reader opens it. 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.
+ * 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;
@@ -62,15 +99,18 @@ export class LiveReply {
     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;
@@ -90,15 +130,17 @@ export class LiveReply {
     }
     /** Send the card. False means nothing was sent, so the caller keeps its ordinary reply. */
     async open() {
+        let card;
         try {
-            this.cardId = await this.transport.createCardEntity(this.card());
+            card = this.card();
+            this.cardId = await this.transport.createCardEntity(card);
         }
         catch {
             this.audit('live-card-unavailable');
             return false;
         }
         this.streamingSince = this.now();
-        this.markSent();
+        this.markSent(card);
         try {
             await this.transport.replyCardEntity(this.target.messageId, this.cardId, { idempotencyKey: this.target.idempotencyKey, inThread: this.target.inThread });
         }
@@ -111,6 +153,14 @@ export class LiveReply {
             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;
@@ -122,20 +172,30 @@ export class LiveReply {
                 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({ kind: 'reasoning', text: event.text });
+                else {
+                    this.steps.push({ id: this.nextStep++, kind: 'reasoning', text: event.text });
+                    this.layoutDirty = true;
+                }
                 this.trim();
                 break;
             }
@@ -147,7 +207,7 @@ export class LiveReply {
                     this.separator = false;
                 }
                 this.answer += event.text;
-                // The folded panel's title switches from "thinking" to the time it took.
+                // 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();
@@ -157,7 +217,8 @@ export class LiveReply {
             case 'tool':
                 if (this.steps.some(step => step.kind === 'tool' && step.callId === event.callId))
                     return;
-                this.steps.push({ kind: 'tool', callId: event.callId, name: event.name, ...(event.detail ? { detail: event.detail } : {}), state: 'running' });
+                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();
@@ -167,6 +228,10 @@ export class LiveReply {
                 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;
             }
         }
@@ -184,7 +249,7 @@ export class LiveReply {
         if (final.answer !== undefined)
             this.answer = final.answer;
         if (final.reasoning && !this.steps.some(step => step.kind === 'reasoning'))
-            this.steps.unshift({ kind: 'reasoning', text: final.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';
@@ -214,11 +279,12 @@ export class LiveReply {
     /** 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 > 1) {
+        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) {
@@ -255,13 +321,17 @@ export class LiveReply {
     }
     async flush() {
         const cardId = this.cardId;
-        if (this.degraded || this.layoutDirty || this.now() - this.streamingSince > REOPEN_AFTER_MS) {
+        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, this.card(), ++this.sequence);
+                await this.transport.updateCardEntity(cardId, card, ++this.sequence);
                 this.streamingSince = this.now();
-                this.markSent();
+                this.markSent(card);
                 this.degraded = this.streamFailures >= 3;
             }
             catch {
@@ -269,7 +339,7 @@ export class LiveReply {
             }
             return;
         }
-        for (const [id, content] of [['think', this.thinkContent()], ['answer', this.answerContent()]]) {
+        for (const [id, content] of elements) {
             if (this.closed)
                 return;
             if (this.sent.get(id) === content)
@@ -286,20 +356,45 @@ export class LiveReply {
             }
         }
     }
-    markSent() {
-        this.sent.set('think', this.thinkContent());
-        this.sent.set('answer', this.answerContent());
+    /** 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;
     }
-    stepsMarkdown(maxBytes) {
-        const parts = this.steps.map(step => step.kind === 'reasoning' ? cardMarkdown(step.text.trim())
-            : `${step.state === 'running' ? '⏳' : step.state === 'done' ? '✅' : '⚠️'} ${code(step.name)}${step.detail ? ' ' + code(step.detail) : ''}`)
-            .filter(Boolean);
-        const text = parts.join('\n\n');
-        const shown = tail(text, maxBytes);
-        return (this.trimmed || shown.length < text.length) && shown ? `${grey('…')}\n${shown}` : shown;
+    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);
     }
-    thinkContent() {
-        return this.stepsMarkdown(LIVE_STEP_BYTES) || grey('正在思考…');
+    /** 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)
@@ -308,34 +403,68 @@ export class LiveReply {
         return cardMarkdown(shown) + (shown.length < this.answer.length ? `\n\n${grey('……')}` : '');
     }
     panelTitle() {
-        const tools = this.tools ? ` · 使用工具 ${this.tools} 次` : '';
-        if (this.phase === 'thinking')
-            return `💭 思考中…${tools}`;
-        const seconds = Math.max(1, Math.round(((this.answeredAt ?? this.finishedAt ?? this.now()) - this.startedAt) / 1000));
-        return `💭 思考了 ${seconds} 秒${tools}`;
+        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 reasoning and tool steps. */
-    panel(content) {
+    /** 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: 'markdown', content: this.panelTitle() }, vertical_align: 'center',
-                icon: { tag: 'standard_icon', token: 'down-small-ccm_outlined', size: '16px 16px' }, icon_position: 'follow_text', icon_expanded_angle: -180 },
-            border: { color: 'grey', corner_radius: '5px' }, vertical_spacing: '8px', padding: '8px 8px 8px 8px',
-            elements: [{ tag: 'markdown', element_id: 'think', content, text_size: 'notation' }],
+            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' }],
         };
     }
-    /** Live layout when steps is undefined; a final layout otherwise ('' leaves out the panel). */
+    /**
+     * 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.thinkContent()));
-        else if (final.steps)
-            elements.push(this.panel(final.steps));
+            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',
@@ -344,12 +473,12 @@ export class LiveReply {
             body: { direction: 'vertical', vertical_spacing: '8px', padding: '12px 16px 12px 16px', elements },
         };
     }
-    /** The answer comes first. The folded process only gets the space that is left. */
+    /** 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 ? grey('思考过程较长，卡片里没有显示。') : '';
+        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, steps) => bytes(this.card({ answer: candidate, steps, truncated })) <= CARD_BYTES;
+        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.
@@ -375,15 +504,15 @@ export class LiveReply {
             }
         }
         if (minimal) {
-            let budget = Math.min(FINAL_STEP_BYTES, CARD_BYTES - bytes(this.card({ answer, steps: '', truncated })) - 800);
+            let budget = CARD_BYTES - bytes(this.card({ answer, rows: [], truncated })) - 200;
             while (budget > 300) {
-                const steps = this.stepsMarkdown(budget);
-                if (steps && fits(answer, steps))
-                    return this.card({ answer, steps, truncated });
-                budget = Math.floor(budget * 0.7);
+                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, steps: minimal, truncated });
+        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

package/dist/onboarding/host.d.ts

@@ -27,9 +27,13 @@ export declare function lockedConnectionControl(): ConnectionControl;
 export declare function registerConnectionRpc(rpc: RpcHost, controller: ConnectionControl): () => Promise<void>;
 export declare function registerConnectionRpc(rpc: RpcHost, controller: ConnectionControl, ownerRoutes?: OwnerFetchRoutes): (() => Promise<void>) | Promise<() => Promise<void>>;
 export declare function findLarkExecutable(explicit?: string): Promise<string>;
-/** Attach the control plane without requiring any user-written team configuration. */
+/**
+ * Attach the control plane without requiring any user-written team configuration.
+ * `latestVersion` replaces the npm lookup behind the upgrade notice (tests use it to stay offline).
+ */
 export declare function applyOnboarding(ctx: Context, options?: {
     dataDir?: string;
     executable?: string;
+    latestVersion?: (signal: AbortSignal) => Promise<string | undefined>;
 }): Promise<void>;
 export {};

package/dist/onboarding/host.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { access } from 'node:fs/promises';
-import { constants } from 'node:fs';
+import { constants, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { delimiter, join, resolve } from 'node:path';
 import { createBotService, BotServiceStartError } from '../bot-service.js';
@@ -9,6 +9,7 @@ import { acquireLock, LockHeldError } from '../lock.js';
 import { ConnectionController, SetupError } from './controller.js';
 import { ConnectionStore } from './store.js';
 import { LarkPlatform } from './lark-platform.js';
+import { npmLatest, UpdateCheck } from './updates.js';
 const endpoints = new Set(['status', 'profiles', 'create', 'use-profile', 'recheck', 'cancel',
     'renew-pairing', 'confirm-owner', 'pause', 'resume', 'disconnect', 'enable-documents', 'cancel-documents']);
 const failure = (message) => ({ ok: false, error: { code: 'internal', message, details: {} } });
@@ -151,6 +152,21 @@ export async function findLarkExecutable(explicit) {
     }
     return 'lark-cli';
 }
+/** This plugin's own package name and version, from the package it was installed from. */
+function installedPackage() {
+    try {
+        const value = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+        return typeof value.name === 'string' && typeof value.version === 'string' ? { name: value.name, version: value.version } : undefined;
+    }
+    catch {
+        return;
+    }
+}
+/** Every snapshot the page receives carries the upgrade notice once a newer release is known. */
+function withUpdate(snapshot, updates) {
+    const update = updates.status();
+    return update ? { ...snapshot, update } : snapshot;
+}
 function requireRuntime(ctx) {
     if (!checkRuntimeCompatibility(ctx).supported)
         throw new SetupError('当前 dsh 缺少所需的会话能力，请检查插件和持久化服务。', false);
@@ -185,7 +201,10 @@ async function waitReady(service, signal) {
             abort();
     });
 }
-/** Attach the control plane without requiring any user-written team configuration. */
+/**
+ * Attach the control plane without requiring any user-written team configuration.
+ * `latestVersion` replaces the npm lookup behind the upgrade notice (tests use it to stay offline).
+ */
 export async function applyOnboarding(ctx, options = {}) {
     const connection = ctx.get('connection');
     if (!connection?.rpc)
@@ -240,9 +259,17 @@ export async function applyOnboarding(ctx, options = {}) {
                 throw error;
             }
         }, });
+    const installed = installedPackage();
+    const updates = new UpdateCheck(installed?.version, options.latestVersion
+        ?? (signal => installed ? npmLatest(installed.name, signal) : Promise.resolve(undefined)));
+    const control = {
+        snapshot: () => withUpdate(controller.snapshot(), updates),
+        profiles: signal => controller.profiles(signal),
+        command: async (endpoint, payload) => withUpdate(await controller.command(endpoint, payload), updates),
+    };
     let remove;
     try {
-        remove = await registerConnectionRpc(connection.rpc, controller, connection.fetch);
+        remove = await registerConnectionRpc(connection.rpc, control, connection.fetch);
         ctx.effect(() => {
             return async () => {
                 await remove();

package/dist/onboarding/protocol.d.ts

@@ -40,6 +40,11 @@ export interface ConnectionSnapshot {
             expiresAt: number;
         };
     };
+    /** A newer published release of this plugin, with the installed version. */
+    update?: {
+        current: string;
+        latest: string;
+    };
 }
 export interface ConnectionProfile {
     name: string;