lark-remote 0.5.20 → 0.5.21

package/dist/runner/dsh/mux-stream.js

@@ -1,5 +1,28 @@
 import { getLogger } from '../../logger/index.js';
 import { DshError } from './errors.js';
+function nonEmptyString(value) {
+    return typeof value === 'string' && value ? value : undefined;
+}
+// 模块级命名提取器：顺序即优先级，先命中先返回。抽到模块顶层后
+// describeSocketError 只剩「校验 + 遍历」，决策点集中在独立的纯函数里。
+function messageDetail(e) {
+    return nonEmptyString(e.message);
+}
+function errorObjectDetail(e) {
+    return e.error instanceof Error ? nonEmptyString(e.error.message) : undefined;
+}
+function errorStringDetail(e) {
+    return nonEmptyString(e.error);
+}
+function typeDetail(e) {
+    return nonEmptyString(e.type);
+}
+const SOCKET_ERROR_DETAIL_EXTRACTORS = [
+    messageDetail,
+    errorObjectDetail,
+    errorStringDetail,
+    typeDetail,
+];
 /**
  * onerror 的事件对象在 ws 实现之间形态不一（{message} / {error} / {type}）。
  * 尽力取出可读描述；取不到就不追加，别拿 '[object Object]' 充数。
@@ -8,14 +31,11 @@ function describeSocketError(event) {
     if (!event || typeof event !== 'object')
         return undefined;
     const e = event;
-    if (typeof e.message === 'string' && e.message)
-        return e.message;
-    if (e.error instanceof Error && e.error.message)
-        return e.error.message;
-    if (typeof e.error === 'string' && e.error)
-        return e.error;
-    if (typeof e.type === 'string' && e.type)
-        return e.type;
+    for (const extract of SOCKET_ERROR_DETAIL_EXTRACTORS) {
+        const detail = extract(e);
+        if (detail)
+            return detail;
+    }
     return undefined;
 }
 export async function* openMuxStream(opts) {

package/dist/runner/dsh/runner.d.ts

@@ -21,6 +21,7 @@ import type { AgentSessionReader } from '../../session-contract.js';
 import type { AgentEvent, AgentStatusInfo, BackgroundJobRoster, SpawnOptions, StopOutcome } from '../types.js';
 import type { AgentRunner } from '../types.js';
 import { DshClient, type WebSocketFactory } from './client.js';
+import { DshApprovalTracker } from './approval.js';
 import type { DshDaemon } from './daemon.js';
 export interface DshRunnerOptions {
     kind: 'dsh';
@@ -110,7 +111,7 @@ export declare class DshRunner implements AgentRunner {
     /** 已对齐权限预设的 session；同一 session 只执行一次 `/permission`。 */
     private readonly permissionAlignedSessions;
     /** `$events` approval waterfall state for the current run. */
-    private readonly approvalTracker;
+    readonly approvalTracker: DshApprovalTracker;
     /**
      * eventId → 待回答的 DSH `ask_user_question` waterfall。
      *
@@ -207,7 +208,7 @@ export declare class DshRunner implements AgentRunner {
      * 现，卡片列出来只会误导"还没跑完"。`job/list` 拿不到时返回空数组——没有
      * 任务列表不等于有任务在跑。
      */
-    private collectBackgroundJobs;
+    collectBackgroundJobs(sessionId: string, signal: AbortSignal): Promise<AgentEvent[]>;
     /**
      * 订阅本 session 的后台任务名单（跨 turn 生命周期）。
      *
@@ -243,7 +244,7 @@ export declare class DshRunner implements AgentRunner {
      * the Other input, multi-select submit and skip from this view alone.
      */
     private buildQuestionRequested;
-    private approvalResolved;
+    approvalResolved(requestId: string): AgentEvent;
     private approvalFallbackText;
     /**
      * Compact the session through DSH's `/compact` command.

package/dist/runner/dsh/runner.js

@@ -192,6 +192,88 @@ function interruptedResult(sessionId) {
         errorMessage: 'run stopped',
     };
 }
+/** goal/change：权威变更，不等投影直接按事件更新（create/edit/pause/...）。 */
+function goalChangeEvents(_runner, event, ctx) {
+    const parsed = goalFromChange(event.data);
+    if (parsed !== undefined && !sameGoal(parsed, ctx.goal.last)) {
+        ctx.goal.last = parsed;
+        return [goalStateEvent(parsed, true)];
+    }
+    return [];
+}
+/** approval/decided：审批回流，清审批卡。 */
+function approvalDecidedEvents(runner, event) {
+    const data = event.data;
+    if (!data.id)
+        return [];
+    runner.approvalTracker.onDecided(data.id);
+    return [runner.approvalResolved(data.id)];
+}
+/** 终态分支查表：命中即返回（不再落到 translator）。 */
+const SESSION_EVENT_TERMINAL_HANDLERS = new Map([
+    ['goal/change', goalChangeEvents],
+    ['approval/decided', approvalDecidedEvents],
+]);
+/** tool/call：先记账（审批卡命令展示用），随后仍落到 translator 出工具行。 */
+function recordToolCall(toolCalls, event) {
+    const data = event.data;
+    if (data.callId && data.name) {
+        toolCalls.set(data.callId, {
+            name: data.name,
+            arguments: data.arguments ?? '',
+            ...(data.turn === undefined ? {} : { turn: data.turn }),
+        });
+        if (toolCalls.size > 100) {
+            const oldest = toolCalls.keys().next().value;
+            if (oldest !== undefined)
+                toolCalls.delete(oldest);
+        }
+    }
+}
+/** result 收尾：后台任务名单 + goal 收尾复核；返回要插到 result 前的事件。 */
+async function resultFinalizeEvents(runner, ctx) {
+    const events = [];
+    for (const jobsEvent of await runner.collectBackgroundJobs(ctx.sessionId, ctx.abort.signal)) {
+        events.push(jobsEvent);
+    }
+    // 收尾复核：这一轮结束时 goal 是否仍 active，决定卡片能不能收尾。
+    // 必须现读宿主，不能沿用过程中的最后一次观测——goal 可能在本轮
+    // 最后一个 step 才被 complete，也可能刚被 driver 置为 blocked。
+    const finalGoal = await runner.client.goalState(ctx.sessionId, {
+        signal: ctx.signal,
+        timeoutMs: GOAL_PROBE_TIMEOUT_MS,
+    });
+    if (!finalGoal.known) {
+        // 收尾读不到：seed 已报过 unknown 就不重复发，否则把状态降级
+        // 交给卡片（卡片据此不再宣布完成）。
+        if (ctx.goal.known) {
+            ctx.goal.known = false;
+            events.push(goalStateEvent(null, false));
+        }
+    }
+    else if (!ctx.goal.known || !sameGoal(finalGoal.goal, ctx.goal.last)) {
+        ctx.goal.known = true;
+        ctx.goal.last = finalGoal.goal;
+        events.push(goalStateEvent(finalGoal.goal, true));
+    }
+    return events;
+}
+/** translator 循环：result 事件插入收尾事件并提前返回。 */
+async function collectAgentEvents(runner, event, ctx) {
+    const events = [];
+    for (const ev of ctx.translator.eventToAgentEvents(event, ctx.sessionId)) {
+        if (ev.type === 'result') {
+            if (!ctx.abort.signal.aborted) {
+                for (const finalized of await resultFinalizeEvents(runner, ctx))
+                    events.push(finalized);
+            }
+            events.push(attachContextLimit(ev, ctx.live.contextLimit));
+            return events;
+        }
+        events.push(ev);
+    }
+    return events;
+}
 export class DshRunner {
     kind = 'dsh';
     /**
@@ -772,75 +854,17 @@ export class DshRunner {
      *   复核）再随 result 一起返回。
      */
     async handleSessionEvent(event, sessionId, translator, goal, live, abort, signal) {
-        if (event.type === 'goal/change') {
-            // 权威变更（create/edit/pause/resume/complete/block/clear）：不等投影
-            // 推送，直接按事件更新——agent 刚 create 的那一刻卡片就该显示目标。
-            const parsed = goalFromChange(event.data);
-            if (parsed !== undefined && !sameGoal(parsed, goal.last)) {
-                goal.last = parsed;
-                return [goalStateEvent(parsed, true)];
-            }
-            return [];
-        }
+        const ctx = { sessionId, translator, goal, live, abort, signal };
+        const terminal = SESSION_EVENT_TERMINAL_HANDLERS.get(event.type);
+        if (terminal)
+            return terminal(this, event, ctx);
         if (event.type === 'tool/call') {
-            const data = event.data;
-            if (data.callId && data.name) {
-                this.toolCalls.set(data.callId, {
-                    name: data.name,
-                    arguments: data.arguments ?? '',
-                    ...(data.turn === undefined ? {} : { turn: data.turn }),
-                });
-                if (this.toolCalls.size > 100) {
-                    const oldest = this.toolCalls.keys().next().value;
-                    if (oldest !== undefined)
-                        this.toolCalls.delete(oldest);
-                }
-            }
             // 记账后继续往下走：tool/call 同时是卡片工具行的来源（translator 翻
             // 译成 assistant.tool_use）。早期版本在这里 `continue`，把调用轨迹整个
             // 吞掉——卡片因此只有正文、没有任何工具行。
+            recordToolCall(this.toolCalls, event);
         }
-        else if (event.type === 'approval/decided') {
-            const data = event.data;
-            if (!data.id)
-                return [];
-            this.approvalTracker.onDecided(data.id);
-            return [this.approvalResolved(data.id)];
-        }
-        const events = [];
-        for (const ev of translator.eventToAgentEvents(event, sessionId)) {
-            if (ev.type === 'result') {
-                if (!abort.signal.aborted) {
-                    for (const jobsEvent of await this.collectBackgroundJobs(sessionId, abort.signal)) {
-                        events.push(jobsEvent);
-                    }
-                    // 收尾复核：这一轮结束时 goal 是否仍 active，决定卡片能不能收尾。
-                    // 必须现读宿主，不能沿用过程中的最后一次观测——goal 可能在本轮
-                    // 最后一个 step 才被 complete，也可能刚被 driver 置为 blocked。
-                    const finalGoal = await this.client.goalState(sessionId, {
-                        signal,
-                        timeoutMs: GOAL_PROBE_TIMEOUT_MS,
-                    });
-                    if (!finalGoal.known) {
-                        // 收尾读不到：seed 已报过 unknown 就不重复发，否则把状态降级
-                        // 交给卡片（卡片据此不再宣布完成）。
-                        if (goal.known) {
-                            goal.known = false;
-                            events.push(goalStateEvent(null, false));
-                        }
-                    }
-                    else if (!goal.known || !sameGoal(finalGoal.goal, goal.last)) {
-                        goal.known = true;
-                        goal.last = finalGoal.goal;
-                        events.push(goalStateEvent(finalGoal.goal, true));
-                    }
-                }
-                events.push(attachContextLimit(ev, live.contextLimit));
-                return events;
-            }
-            events.push(ev);
-        }
-        return events;
+        return collectAgentEvents(this, event, ctx);
     }
     /**
      * 收尾时仍在跑的后台任务。

package/dist/runner/dsh/translator.d.ts

@@ -26,39 +26,9 @@
 import type { AgentEvent, ResultEvent } from '../types.js';
 import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from '../../dsh/types.js';
 export declare class DshTranslator {
-    /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
-    private turnUsage;
-    /** 末次采样的 usage：上下文水位，或只有 live chunk 时的兜底值。 */
-    private lastUsage?;
-    /** 是否收到过 durable assistant/message.usage（唯一累加来源）。 */
-    private hasMessageUsage;
-    /** 是否只收到过 live usage chunk（无 durable message usage 时的兜底）。 */
-    private hasStreamUsage;
-    /** 当前 attempt 的 id（start 帧携带，chunk 帧也带；断开重连重放时不变）。 */
-    private attemptId;
-    /**
-     * 本 turn 末条 durable assistant 消息的正文（**完整**、未截断）。
-     *
-     * live chunk 是逐 delta 拼接、会被状态层的 MAX_TEXT_CHARS 窗口截断；
-     * durable `assistant/message` 一次就到齐全文。收 turn 时把它挂在 result 上，
-     * 卡片才能渲染完整回答。
-     */
-    private lastMessageText?;
+    private readonly state;
     /** Translate one live assistant-stream chunk into AgentEvents. */
     streamFrameToAgentEvents(frame: DshAssistantStreamFrame, _sessionId: string): AgentEvent[];
-    /**
-     * Record durable per-step usage — the accumulation source. assistant/message
-     * carries exactly one usage per model call and is seq-deduped by the client,
-     * so summing it gives the turn total without double counting.
-     */
-    private recordMessageUsage;
-    /**
-     * Record a live usage chunk. Never summed: the same step also arrives as a
-     * durable assistant/message.usage, so summing both would double count. It only
-     * refreshes the watermark and covers a turn whose messages never persisted.
-     */
-    private recordStreamUsage;
-    private chunkToAgentEvents;
     /** Translate one session event into AgentEvents (may be empty). */
     eventToAgentEvents(ev: DshSessionEvent, sessionId: string): AgentEvent[];
 }