dsh-lark-agent 0.2.0 → 0.3.0

package/dist/dsh-runtime.js

@@ -27,6 +27,7 @@ export class DshRuntimeError extends Error {
             DISPOSED: '当前会话已关闭，请重新开始。',
             MODEL_UNAVAILABLE: '当前宿主暂时无法提供模型选项，请检查模型配置。',
             INVALID_MODEL_SELECTION: '这个模型或思考深度当前不可用，请刷新选项后重试。',
+            MODEL_NOT_SAVED: '模型设置没能保存到电脑上的 Harness，请稍后重试。',
             PERMISSION_UNAVAILABLE: '权限模式暂时无法在飞书切换，请在电脑上的 Harness 里调整。',
         };
         super(messages[code]);
@@ -61,6 +62,10 @@ function clip(value, limit) {
     const points = Array.from(value.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '').trim());
     return points.length > limit ? points.slice(0, limit).join('') + '…' : points.join('');
 }
+// The App's order: a call's own title or description first, then what it acts on.
+const DETAIL_KEYS = ['title', 'description', 'objective', 'task', 'task_name', 'name', 'question', 'questions', 'prompt', 'message',
+    'command', 'cmd', 'queries', 'query', 'pattern', 'url', 'uri', 'file_path', 'path', 'target', 'action', 'status'];
+const CODE_KEYS = new Set(['command', 'cmd', 'pattern', 'file_path', 'path']);
 /** What a call is about, from well-known argument fields only; never the whole argument object. */
 function callDetail(args, limit) {
     let value;
@@ -72,11 +77,13 @@ function callDetail(args, limit) {
     }
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return;
-    for (const key of ['url', 'query', 'queries', 'command', 'path', 'file_path', 'pattern']) {
+    for (const key of DETAIL_KEYS) {
         const field = value[key];
-        const text = Array.isArray(field) ? field.filter((item) => typeof item === 'string').join('、') : field;
-        if (typeof text === 'string' && text.trim())
-            return clip(text.replace(/\s+/g, ' '), limit);
+        const items = Array.isArray(field) ? field.map(item => typeof item === 'string' ? item
+            : item && typeof item === 'object' && typeof item.question === 'string' ? item.question : undefined) : [field];
+        const text = items.filter((item) => typeof item === 'string' && Boolean(item.trim())).join(', ');
+        if (text.trim())
+            return { text: clip(text.replace(/\s+/g, ' ').trim(), limit), code: CODE_KEYS.has(key) };
     }
 }
 /** An approval is only informed if the owner sees the arguments being decided. */
@@ -258,6 +265,54 @@ function permissionOptions(service) {
     }
     return options;
 }
+/** The App's default for new sessions, when the catalog names one of its own options. */
+function permissionDefault(service, options) {
+    let catalog;
+    try {
+        catalog = service.catalog();
+    }
+    catch {
+        return;
+    }
+    const value = catalog && typeof catalog === 'object' ? catalog.defaultPreset : undefined;
+    return typeof value === 'string' && options.some(option => option.id === value) ? value : undefined;
+}
+function sessionProjections(ctx) {
+    let service;
+    try {
+        service = ctx.get('sessionProjections');
+    }
+    catch {
+        return;
+    }
+    return typeof service?.stateOf === 'function' ? service : undefined;
+}
+/**
+ * The model a session's next request uses under the App's own rule: its latest
+ * pick, else its last request's model (an effort the adapter filled in stays
+ * unset), else the host default. Undefined when the host keeps no such record.
+ */
+function sessionChoice(projections, session, defaults) {
+    try {
+        const state = projections.stateOf(session, 'modelSelection');
+        if (!state || typeof state !== 'object')
+            return;
+        if (state.pending)
+            return nativeSelection(modelSelection(state.pending));
+        const header = session
+            .requestHeader?.();
+        if (header?.config) {
+            const { provider, model, reasoningEffort } = header.config;
+            return nativeSelection(modelSelection({ provider, model,
+                ...(reasoningEffort === undefined || header.adapterDefaults?.reasoningEffort === true ? {} : { reasoningEffort: String(reasoningEffort) }) }));
+        }
+        const fallback = defaults?.currentSelection();
+        return fallback ? nativeSelection(modelSelection(fallback)) : undefined;
+    }
+    catch {
+        return;
+    }
+}
 const MODEL_CATALOG_TTL_MS = 30_000;
 const modelId = (value) => typeof value === 'string' && value.length > 0 && value.length <= 256
     && value.trim() === value && !/[\u0000-\u001f\u007f]/.test(value);
@@ -537,6 +592,22 @@ export class DshRuntime {
         const service = permissionPresets(this.ctx);
         return service ? permissionOptions(service) : [];
     }
+    /** Whether harness sessions here share their model choice with the App (see RuntimeSession.sharesModelSelection). */
+    sharesModelSelection() {
+        return Boolean(sessionProjections(this.ctx)) && typeof this.ctx.get('agentDefaultModel')?.saveSelection === 'function';
+    }
+    /** Make a choice the App's default for new sessions, as the App's own model selector does. */
+    async saveDefaultModel(selection) {
+        const service = this.ctx.get('agentDefaultModel');
+        if (typeof service?.saveSelection !== 'function')
+            return;
+        try {
+            await service.saveSelection(nativeSelection(modelSelection(selection)));
+        }
+        catch {
+            throw new DshRuntimeError('MODEL_NOT_SAVED');
+        }
+    }
     /** The preset a stored session runs on: its current projection, else its header. */
     recordedPreset(session) {
         const projections = this.ctx.get('sessionProjections');
@@ -570,7 +641,17 @@ export class DshRuntime {
         let memoryText = '';
         let artifactsText = '';
         let active;
-        const selected = { current: undefined, assembled: undefined };
+        // A restricted session, or one on an administrator's fixed route, keeps that route.
+        // A harness session on the App host follows its own record once it exists (see sharesModelSelection).
+        const projections = harness && !(policy.provider && policy.model) ? sessionProjections(this.ctx) : undefined;
+        const defaultModel = projections ? this.ctx.get('agentDefaultModel') : undefined;
+        let fixed;
+        let shared;
+        const selected = {
+            get current() { return (shared && projections && sessionChoice(projections, shared, defaultModel)) || fixed; },
+            set current(next) { fixed = next; },
+            assembled: undefined,
+        };
         let handle;
         // Legacy hosts log raw chunks as session events, modern hosts publish live
         // frames. Use whichever arrives first so a host offering both shows text once.
@@ -600,8 +681,8 @@ export class DshRuntime {
             // Kept only so an approval prompt can show the exact call being decided.
             if (turn.calls.size < 256)
                 turn.calls.set(block.id, args);
-            const detail = callDetail(args, 120);
-            emit(turn, { type: 'tool', callId: block.id, name: clip(block.name, 64), ...(detail ? { detail } : {}) });
+            const detail = callDetail(args, 160);
+            emit(turn, { type: 'tool', callId: block.id, name: clip(block.name, 64), ...(detail ? { detail: detail.text, ...(detail.code ? { code: true } : {}) } : {}) });
         };
         try {
             if (!isAbsolute(policy.cwd))
@@ -779,8 +860,12 @@ export class DshRuntime {
                         }
                     });
                     agentCtx.on('tools/result', (execution, result) => {
-                        if (active && typeof execution.callId === 'string')
-                            emit(active, { type: 'tool-done', callId: execution.callId, ok: !result.isError });
+                        if (!active || typeof execution.callId !== 'string')
+                            return;
+                        // A command that ran but exited non-zero still succeeded as a tool call; show its code like the App.
+                        const exitCode = result.value?.exitCode;
+                        emit(active, { type: 'tool-done', callId: execution.callId, ok: !result.isError,
+                            ...(typeof exitCode === 'number' && Number.isInteger(exitCode) && exitCode !== 0 ? { exitCode } : {}) });
                     });
                 }
                 else {
@@ -854,6 +939,8 @@ export class DshRuntime {
             throw new DshRuntimeError(resumeId ? 'RESTORE_FAILED' : 'SETUP_FAILED');
         }
         const agent = handle.agent;
+        if (projections && sessionChoice(projections, agent.session, defaultModel))
+            shared = agent.session;
         // Keep this capability while the owner is active. Cordis unloads sibling
         // effects concurrently, so native agent teardown may detach this session
         // before the bridge's teardown reaches it.
@@ -992,8 +1079,22 @@ export class DshRuntime {
                     throw new DshRuntimeError('DISPOSED');
                 if (active || agent.status === 'running')
                     throw new DshRuntimeError('BUSY');
-                selected.current = nativeSelection(modelSelection(next));
+                const choice = nativeSelection(modelSelection(next));
+                if (!shared) {
+                    selected.current = choice;
+                    return;
+                }
+                // Recorded like the App selector's own pick, so the App shows it as this session's model.
+                // Older SDK typings predate this event; only a host with the record gets here.
+                try {
+                    agent.session.append('model/selection', { provider: choice.provider, model: choice.model,
+                        ...(choice.reasoningEffort === undefined ? {} : { reasoningEffort: String(choice.reasoningEffort) }) });
+                }
+                catch {
+                    throw new DshRuntimeError('INVALID_MODEL_SELECTION');
+                }
             },
+            sharesModelSelection: Boolean(shared),
             permissionState: () => {
                 const service = harness && !disposed ? permissionPresets(this.ctx) : undefined;
                 const options = service ? permissionOptions(service) : [];
@@ -1006,7 +1107,8 @@ export class DshRuntime {
                 catch {
                     return;
                 }
-                return { current: typeof current === 'string' ? current : 'custom', options };
+                const defaultPreset = permissionDefault(service, options);
+                return { current: typeof current === 'string' ? current : 'custom', options, ...(defaultPreset ? { defaultPreset } : {}) };
             },
             setPermission: (id) => {
                 if (disposed)

package/dist/interaction-cards.d.ts

@@ -1,23 +1,28 @@
 import type { ApprovalPrompt, QuestionAnswer, UserQuestion } from './dsh-runtime.js';
-import { type ReplyPayload } from './replies.js';
+import { type PanelTone, type ReplyPayload } from './replies.js';
 /** A verified card click on a pending approval or question. */
 export interface InteractionAnswer {
     verb: 'approve' | 'deny' | 'choose' | 'reply';
     index?: number;
     formValues?: unknown;
 }
+/** How a card closed: allowed or answered (success), refused (error), or expired and stopped (muted). */
+export interface InteractionOutcome {
+    text: string;
+    tone: PanelTone;
+}
 /** Buttons answer one short single-choice question in one tap; anything else uses a form. */
 export declare function simpleQuestion(questions: readonly UserQuestion[]): boolean;
 /** The decision card. Without tokens it shows the settled outcome and no buttons. */
 export declare function approvalCard(prompt: ApprovalPrompt, tokens?: {
     allow: string;
     deny: string;
-}, outcome?: string): ReplyPayload;
+}, outcome?: InteractionOutcome): ReplyPayload;
 /** A question card: buttons for one short choice, otherwise a form. Without tokens it shows the outcome. */
 export declare function questionCard(questions: readonly UserQuestion[], tokens?: {
     choose?: string[];
     reply?: string;
-}, outcome?: string): ReplyPayload;
+}, outcome?: InteractionOutcome): ReplyPayload;
 /** Map a click or form back to the host's answer shape, echoing the original option labels. */
 export declare function questionAnswers(questions: readonly UserQuestion[], answer: InteractionAnswer): QuestionAnswer[] | undefined;
 export declare function answeredText(questions: readonly UserQuestion[], answers: readonly QuestionAnswer[]): string;

package/dist/interaction-cards.js

@@ -14,12 +14,12 @@ export function simpleQuestion(questions) {
 export function approvalCard(prompt, tokens, outcome) {
     return renderPanel({
         title: tokens ? '需要你确认' : '确认结果',
-        summary: `是否允许使用工具 ${prompt.toolName}`,
+        summary: outcome?.text ?? `是否允许使用工具 ${prompt.toolName}`,
+        ...(outcome ? { tone: outcome.tone, status: outcome } : {}),
         sections: [
             { title: '工具', text: code(prompt.toolName) },
             ...(prompt.reason ? [{ title: '原因', text: prompt.reason }] : []),
             ...(prompt.detail ? [{ title: '参数', text: fenced(prompt.detail) }] : []),
-            ...(outcome ? [{ text: `**${outcome}**` }] : []),
         ],
         ...(tokens ? { actions: [{ label: '允许一次', value: { token: tokens.allow }, primary: true }, { label: '拒绝', value: { token: tokens.deny } }],
             actionColumns: 2, note: '只允许这一次，不改变电脑上的权限设置。5 分钟内没有确认会按拒绝处理。' } : {}),
@@ -36,11 +36,11 @@ export function questionCard(questions, tokens, outcome) {
     const title = questions.length === 1 && first.header ? first.header : '需要你选择';
     const form = Boolean(tokens?.reply);
     const base = renderPanel({
-        title, summary: `${title}：${first.question}`,
+        title, summary: outcome?.text ?? `${title}：${first.question}`,
+        ...(outcome ? { tone: outcome.tone, status: outcome } : {}),
         sections: [
             ...(form ? [{ text: questions.length > 1 ? `请回答下面 ${questions.length} 个问题，然后提交。` : '请选择或填写后提交。' }]
                 : questions.map(question => ({ text: questionText(question) }))),
-            ...(outcome ? [{ text: `**${outcome}**` }] : []),
         ],
         ...(tokens?.choose ? { actions: [...first.options.map((option, index) => ({ label: option.label, value: { token: tokens.choose[index] }, primary: index === 0 })),
                 { label: '跳过', value: { token: tokens.choose[first.options.length] } }], actionColumns: 1 } : {}),

package/dist/live-reply.d.ts

@@ -22,10 +22,12 @@ export interface LiveReplyFinal {
     note?: string;
 }
 /**
- * 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 declare class LiveReply {
     private readonly transport;
@@ -33,15 +35,18 @@ export declare class LiveReply {
     private readonly options;
     private phase;
     private readonly steps;
+    private nextStep;
     private trimmed;
     private answer;
     private separator;
     private mark;
     private tools;
     private note?;
+    private footer?;
     private cardId?;
     private sequence;
     private readonly sent;
+    private shown;
     private dirty;
     private layoutDirty;
     private degraded;
@@ -60,6 +65,8 @@ export declare class LiveReply {
     }, options?: LiveReplyOptions);
     /** Send the card. False means nothing was sent, so the caller keeps its ordinary reply. */
     open(): Promise<boolean>;
+    /** Trusted settings line under the answer, such as the model and thinking depth in use. */
+    setFooter(text: string): void;
     push(event: TurnStreamEvent): void;
     /** Stop streaming and write the final card. True only when Feishu confirmed it. */
     finish(final: LiveReplyFinal): Promise<boolean>;
@@ -73,15 +80,22 @@ export declare class LiveReply {
     /** Pacing between updates; finishing the reply ends it early. */
     private pause;
     private flush;
+    /** Streamable text elements of a card: its process rows and the answer. */
+    private textElements;
     private markSent;
-    private stepsMarkdown;
-    private thinkContent;
+    /** One step as a row, in the App's words: what was done and on what. */
+    private row;
     private answerContent;
     private panelTitle;
-    /** The folded process panel. Readers open it when they want the reasoning and tool steps. */
+    /** The folded process panel. Readers open it when they want the thinking and tool steps. */
     private panel;
-    /** 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.
+     */
+    private rows;
+    /** Live layout when final is undefined; a final layout otherwise (null leaves out the panel's rows). */
     private card;
-    /** 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. */
     private finalCard;
 }