lark-remote 0.5.19 → 0.5.21

package/dist/runner/opencode/acp/runner.js

@@ -133,8 +133,8 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
         }
         // Apply the configured model (`provider/model`) via set_config_option.
         // Without this the session runs opencode's own default model (e.g.
-        // opencode/big-pickle), which may be unusable — 2026-08-17 live smoke:
-        // default zen model left session/prompt hanging with no response.
+        // opencode/big-pickle), which may be unusable: the default zen model can
+        // leave session/prompt hanging with no response.
         // Non-fatal on failure (unknown model → server InvalidModelError).
         if (this.model && this.currentModelValue !== this.model) {
             try {
@@ -179,7 +179,7 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
      * before failing the turn.
      *
      * 单次 attempt 自身还要等 opencode 侧超时（~10s），所以真实窗口 ≈ Σdelay +
-     * 每次的等待。2026-10-30 现场：daemon 刚重启，`/api/model` 因模型目录拉取
+     * 每次的等待。daemon 刚重启时 `/api/model` 会因模型目录拉取
      * 超时连续 503 约 7 分钟，旧退避 0.5/1.5/3s（合计 ~45s）全落在这段里，4 次
      * 重试无一成功。现在铺到 ~75s + 每次超时 ≈ 2 分钟，覆盖一次冷启动窗口，
      * 又不至于让真故障的用户干等太久。
@@ -194,7 +194,7 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
     /**
      * 用户可见文案。这里刻意**不**建议 `opencode service restart`：卡住的是
      * opencode 的模型目录/位置服务冷启动，重启只会清掉刚热好的状态、重新回到
-     * 同一个窗口（2026-10-30 现场：照提示重启两次仍然失败，等几分钟自己好了）。
+     * 同一个窗口（照提示重启两次仍然失败，等几分钟自己好了）。
      */
     enrichSessionSetupError(err) {
         if (!this.isRetryableSessionSetupError(err)) {

package/dist/runner/pi/rpc/client.js

@@ -10,7 +10,7 @@
  * Response correlation is by command id; every non-response line is forwarded
  * as an event to the active hooks (the runner's translator).
  */
-import { ConnectionLostError } from '../../common/jsonrpc/client.js';
+import { ConnectionLostError, disposeRpcClientInstance, rejectAllPending, } from '../../common/jsonrpc/client.js';
 export class PiRpcClient {
     transport;
     requestTimeoutMs;
@@ -78,13 +78,8 @@ export class PiRpcClient {
             return;
         this.transport.write({ ...command, id: `req_${this.nextId++}` });
     }
-    async dispose() {
-        if (this._disposed)
-            return;
-        this._disposed = true;
-        this._ready = false;
-        this.failPending(new ConnectionLostError('pi rpc client disposed'));
-        await this.transport.close();
+    dispose() {
+        return disposeRpcClientInstance(this, this.pending, () => this.transport.close(), 'pi rpc client disposed');
     }
     // =========================================================================
     // Internal
@@ -104,11 +99,7 @@ export class PiRpcClient {
         this.runHooks?.onEvent?.(message);
     }
     failPending(err) {
-        for (const [_id, pending] of this.pending) {
-            clearTimeout(pending.timer);
-            pending.reject(err);
-        }
-        this.pending.clear();
+        rejectAllPending(this.pending, err);
     }
 }
 //# sourceMappingURL=client.js.map

package/dist/runner/pi/rpc/protocol-types.d.ts

@@ -7,7 +7,7 @@
  *                     and events (session lifecycle / message / compaction) as bare
  *                     JSON objects (no envelope).
  *
- * Turn semantics (verified live against pi 0.84.1, 2026-08-18):
+ * Turn semantics (verified against pi 0.84.1):
  *   - `prompt` returns an ack (`success:true`) immediately; the turn then streams
  *     events and completes with an `agent_settled` event.
  *   - `compact` runs synchronously and returns its response at completion; it also

package/dist/runner/pi/rpc/protocol-types.js

@@ -7,7 +7,7 @@
  *                     and events (session lifecycle / message / compaction) as bare
  *                     JSON objects (no envelope).
  *
- * Turn semantics (verified live against pi 0.84.1, 2026-08-18):
+ * Turn semantics (verified against pi 0.84.1):
  *   - `prompt` returns an ack (`success:true`) immediately; the turn then streams
  *     events and completes with an `agent_settled` event.
  *   - `compact` runs synchronously and returns its response at completion; it also

package/dist/runner/pi/rpc/runner.d.ts

@@ -59,6 +59,7 @@ export declare class PiRpcRunner extends ConnectionBasedRunner<PiRpcClient, PiRp
     protected clearTurnState(): void;
     protected releaseConnection(cwd: string): Promise<void>;
     protected notifyIdle(cwd: string): void;
+    protected notifyConnectionActivity(cwd: string): void;
     protected disposeConnections(): Promise<void>;
     getStatusInfo(): AgentStatusInfo;
     /**
@@ -72,4 +73,6 @@ export declare class PiRpcRunner extends ConnectionBasedRunner<PiRpcClient, PiRp
      */
     runCompact(_message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
     private handleEvent;
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    private installTurnHooks;
 }

package/dist/runner/pi/rpc/runner.js

@@ -20,6 +20,7 @@
 import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
 import { ConnectionManager } from '../../common/jsonrpc/connection-manager.js';
 import { getLogger } from '../../../logger/index.js';
+import { PI_DEFAULTS } from '../../../config/index.js';
 import { PiRpcClient } from './client.js';
 import { PiRpcTranslator } from './translator.js';
 export class PiRpcRunner extends ConnectionBasedRunner {
@@ -36,10 +37,12 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             sessionReader: opts.sessionReader,
             turnIdleTimeoutMs: opts.turnIdleTimeoutMs,
         });
-        this.defaultModel = opts.model ?? 'glm-5.2';
-        this.provider = opts.provider ?? 'Volcano';
-        this.thinking = opts.thinking ?? 'medium';
-        const tools = (opts.tools ?? ['read', 'bash', 'edit', 'write', 'grep', 'find', 'ls']).join(',');
+        this.defaultModel = opts.model ?? PI_DEFAULTS.model;
+        this.provider = opts.provider ?? PI_DEFAULTS.provider;
+        this.thinking = opts.thinking ?? PI_DEFAULTS.thinking;
+        // PI_DEFAULTS.tools 是逗号串（config schema 的 tools 同形态），与原数组兜底
+        // join(',') 结果逐字相等；opts.tools 自身的数组语义（含空数组 → 空串）不变。
+        const tools = opts.tools?.join(',') ?? PI_DEFAULTS.tools;
         this.manager = new ConnectionManager({
             binary: opts.binary ?? 'pi',
             buildArgs: (req) => buildPiArgs(this.provider, this.defaultModel, this.thinking, tools, req.sessionId),
@@ -93,6 +96,9 @@ export class PiRpcRunner extends ConnectionBasedRunner {
     notifyIdle(cwd) {
         this.manager.notifyIdle(cwd);
     }
+    notifyConnectionActivity(cwd) {
+        this.manager.notifyActivity(cwd);
+    }
     async disposeConnections() {
         await this.manager.disposeAll();
     }
@@ -110,28 +116,13 @@ export class PiRpcRunner extends ConnectionBasedRunner {
      * `agent_settled` event produces the result.
      */
     async setupTurn(message, opts) {
-        const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
-        this.manager.notifyActivity(opts.cwd);
-        this.currentClient = client;
-        // 轮次代际锚点（与 BaseAcpRunner 同口径）：pi 的 shouldReuse 要求
-        // sessionId 匹配，/new、/resume 切换后的首条消息会让 acquire **同步
-        // dispose** 旧连接；terminator 等到进程退出后，旧 client 上残留的上一轮
-        // onClose 闭包会把假错误推进新 turn 的共享队列（用户消息未发出即丢失）。
-        // 旧轮迟到的 agent_settled 同理（新 turn 空转立即"成功"）。所有 hook
-        // 落地前必须过 isCurrentTurn。
-        const generation = this.turnGeneration;
-        client.setHooks({
-            onEvent: (evt) => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                this.handleEvent(evt);
-            },
-            onClose: () => {
-                if (!this.isCurrentTurn(generation, client))
-                    return;
-                this.failTurn('Pi RPC connection closed');
-            },
-        });
+        const anchor = await this.acquireForTurn(opts.cwd, () => this.manager.acquire(opts.cwd, { sessionId: opts.sessionId }));
+        // pi 的 shouldReuse 要求 sessionId 匹配：/new、/resume 切换后的首条消息会让
+        // acquire **同步 dispose** 旧连接。旧 client 残留的上一轮 onClose / 迟到的
+        // agent_settled 必须被 anchor 守卫挡掉，否则假错误会推进新 turn 的共享队列
+        // （语义见 acquireForTurn / TurnAnchor）。
+        this.installTurnHooks(anchor);
+        const { client } = anchor;
         let sessionId = opts.sessionId;
         if (!sessionId) {
             const state = await client.request({ type: 'get_state' });
@@ -169,24 +160,11 @@ export class PiRpcRunner extends ConnectionBasedRunner {
             if (!opts.sessionId) {
                 throw new Error('compact requires a sessionId');
             }
-            const client = await this.manager.acquire(opts.cwd, { sessionId: opts.sessionId });
-            this.manager.notifyActivity(opts.cwd);
-            this.currentClient = client;
             // 同 setupTurn：hook 带轮次代际锚点，旧连接的迟到回调不得进入本轮。
-            const generation = this.turnGeneration;
-            client.setHooks({
-                onEvent: (evt) => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.handleEvent(evt);
-                },
-                onClose: () => {
-                    if (!this.isCurrentTurn(generation, client))
-                        return;
-                    this.failTurn('Pi RPC connection closed');
-                },
-            });
+            const anchor = await this.acquireForTurn(opts.cwd, () => this.manager.acquire(opts.cwd, { sessionId: opts.sessionId }));
+            this.installTurnHooks(anchor);
             this.activeSessionId = opts.sessionId;
+            const { client } = anchor;
             const translator = new PiRpcTranslator();
             translator.setSessionId(opts.sessionId);
             translator.setOperationKind('compact');
@@ -210,6 +188,13 @@ export class PiRpcRunner extends ConnectionBasedRunner {
     handleEvent(evt) {
         this.pushEvents(this.currentTranslator?.handleEvent(evt) ?? []);
     }
+    /** Wire the acquired client's hooks into the turn dispatcher (anchor-guarded). */
+    installTurnHooks(anchor) {
+        anchor.client.setHooks({
+            onEvent: this.forCurrentTurn(anchor, 'event', (evt) => this.handleEvent(evt)),
+            onClose: this.forCurrentTurn(anchor, 'connection close', () => this.failTurn('Pi RPC connection closed')),
+        });
+    }
 }
 /** Build pi `--mode rpc` spawn args. `sessionId` is bound at spawn (pi has no
  *  RPC resume-by-id command); omitting it spawns a brand-new session. */

package/dist/runner/pi/rpc/translator.js

@@ -10,7 +10,56 @@
  *     `result` from that response.
  *   - `agent_settled` is ignored for compaction turns (no double result).
  */
-import { makeTurnStartedEvent } from '../../common/turn-started.js';
+import { produceTurnStartedEvent } from '../../common/turn-started.js';
+/** 首见：push 一个空 text/thinking 块并把游标移到它。 */
+function textLikeStart(kind, state, _evt) {
+    state.content.push(kind === 'text' ? { type: 'text', text: '' } : { type: 'thinking', thinking: '' });
+    state.currentContentIndex++;
+}
+/** 增量：把 delta 追加到当前 text/thinking 块（类型不匹配则忽略）。 */
+function textLikeDelta(kind, state, evt) {
+    const idx = state.currentContentIndex;
+    const block = state.content[idx];
+    if (idx >= 0 && block?.type === kind) {
+        block[kind] += evt.delta ?? '';
+    }
+}
+/** 收尾：以全量 content 覆盖当前 text/thinking 块（无 content 则忽略）。 */
+function textLikeEnd(kind, state, evt) {
+    const idx = state.currentContentIndex;
+    const block = state.content[idx];
+    if (idx >= 0 && block?.type === kind && evt.content) {
+        block[kind] = evt.content;
+    }
+}
+function toolCallStart(state, _evt) {
+    // 信息保真 不再 push 空壳 tool_use（空 id/name 会被渲染成
+    // 无意义工具块）。只保留 bookkeeping，toolcall_end 补发完整事件。
+    state.pendingToolCall = true;
+}
+function toolCallEnd(state, evt) {
+    if (state.pendingToolCall && evt.toolCall) {
+        state.content.push({
+            type: 'tool_use',
+            id: evt.toolCall.id,
+            name: evt.toolCall.name,
+            input: evt.toolCall.arguments,
+        });
+        state.currentContentIndex = state.content.length - 1;
+        state.pendingToolCall = false;
+    }
+}
+/** 查表分派 message_update；toolcall_delta 等无专属 handler 的类型为 no-op。 */
+const PI_UPDATE_HANDLERS = new Map([
+    ['text_start', textLikeStart.bind(null, 'text')],
+    ['text_delta', textLikeDelta.bind(null, 'text')],
+    ['text_end', textLikeEnd.bind(null, 'text')],
+    ['thinking_start', textLikeStart.bind(null, 'thinking')],
+    ['thinking_delta', textLikeDelta.bind(null, 'thinking')],
+    ['thinking_end', textLikeEnd.bind(null, 'thinking')],
+    ['toolcall_start', toolCallStart],
+    ['toolcall_end', toolCallEnd],
+]);
 export class PiRpcTranslator {
     content = [];
     currentContentIndex = -1;
@@ -135,8 +184,9 @@ export class PiRpcTranslator {
     }
     /** Self-produced turn_started (no wire equivalent). */
     produceTurnStarted(sessionId, turnId) {
-        this.sessionId = sessionId;
-        return makeTurnStartedEvent(sessionId, turnId, this.operationKind);
+        return produceTurnStartedEvent(sessionId, turnId, this.operationKind, (s) => {
+            this.sessionId = s;
+        });
     }
     /** Result for a completed normal turn (agent_settled). */
     produceResultFromSettled() {
@@ -236,63 +286,14 @@ export class PiRpcTranslator {
             this.lastTotalTokens = u.totalTokens;
     }
     applyUpdate(evt) {
-        switch (evt.type) {
-            case 'text_start':
-                this.content.push({ type: 'text', text: '' });
-                this.currentContentIndex++;
-                break;
-            case 'text_delta':
-                if (this.currentContentIndex >= 0 &&
-                    this.content[this.currentContentIndex]?.type === 'text') {
-                    this.content[this.currentContentIndex].text += evt.delta ?? '';
-                }
-                break;
-            case 'text_end':
-                if (this.currentContentIndex >= 0 &&
-                    this.content[this.currentContentIndex]?.type === 'text' &&
-                    evt.content) {
-                    this.content[this.currentContentIndex].text = evt.content;
-                }
-                break;
-            case 'thinking_start':
-                this.content.push({ type: 'thinking', thinking: '' });
-                this.currentContentIndex++;
-                break;
-            case 'thinking_delta':
-                if (this.currentContentIndex >= 0 &&
-                    this.content[this.currentContentIndex]?.type === 'thinking') {
-                    this.content[this.currentContentIndex].thinking +=
-                        evt.delta ?? '';
-                }
-                break;
-            case 'thinking_end':
-                if (this.currentContentIndex >= 0 &&
-                    this.content[this.currentContentIndex]?.type === 'thinking' &&
-                    evt.content) {
-                    this.content[this.currentContentIndex].thinking = evt.content;
-                }
-                break;
-            case 'toolcall_start':
-                // 信息保真 不再 push 空壳 tool_use（空 id/name 会被渲染成
-                // 无意义工具块）。只保留 bookkeeping，toolcall_end 补发完整事件。
-                this.pendingToolCall = true;
-                break;
-            case 'toolcall_end':
-                if (this.pendingToolCall && evt.toolCall) {
-                    this.content.push({
-                        type: 'tool_use',
-                        id: evt.toolCall.id,
-                        name: evt.toolCall.name,
-                        input: evt.toolCall.arguments,
-                    });
-                    this.currentContentIndex = this.content.length - 1;
-                    this.pendingToolCall = false;
-                }
-                break;
-            default:
-                // toolcall_delta: pi provides complete arguments at toolcall_end, ignore.
-                break;
-        }
+        const state = {
+            content: this.content,
+            currentContentIndex: this.currentContentIndex,
+            pendingToolCall: this.pendingToolCall,
+        };
+        PI_UPDATE_HANDLERS.get(evt.type)?.(state, evt);
+        this.currentContentIndex = state.currentContentIndex;
+        this.pendingToolCall = state.pendingToolCall;
     }
 }
 /**

package/dist/runner/types.d.ts

@@ -302,7 +302,7 @@ export interface ResultEvent {
      * 省略）` 标记——渲染层再怎么「回答优先」也找不回被丢掉的头部。runner 在
      * 收 turn 时拿到的是**完整** assistant 文本（一条消息，不是逐 delta 拼接），
      * 把它挂在 result 上，`promoteFinalAnswer` 用它建立 finalAnswer，回答因此
-     * 不再被进度窗口截断（2026-11-01 卡片输出块被截断缺陷）。
+     * 不再被进度窗口截断。
      */
     finalAnswerText?: string;
     usage?: {
@@ -582,7 +582,7 @@ export { AGENT_DISPLAY_NAMES } from '../agent-kinds.js';
  * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
  * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
  * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
- * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮。
  *
  * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
  * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧

package/dist/runner/types.js

@@ -11,7 +11,7 @@ export { AGENT_DISPLAY_NAMES } from '../agent-kinds.js';
  * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
  * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
  * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
- * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮。
  *
  * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
  * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧

package/dist/session/claude/sessions.d.ts

@@ -25,6 +25,50 @@ export declare function getNewestSession(cwd: string, opts?: {
 export declare function isClaudeSessionActive(sessionId: string, cwd: string, opts?: {
     projectsDir?: string;
 }): boolean;
+/** claude wire 一条 assistant 行携带的原始 usage 字段（可选，缺按 0 计）。 */
+interface ClaudeRawUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+}
+/** per-message-id 合并后的 usage 采样（四个分量 + 采集时的真人 turn 序号）。 */
+export interface ClaudePerMessageUsage {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreation: number;
+    /** 该 message 属于第几个真人 turn（0 = 还没有真人 prompt）。 */
+    turn: number;
+}
+/**
+ * 两条采样逐字段取 max（纯函数；UsageAccumulator 的 per-field max 语义）。
+ *
+ * RED LINE（token 口径单源的一部分）：一条 streaming assistant 消息跨多行
+ * jsonl、共享同一 message id；部分后端（第三方网关，如 DeepSeek）在早期占位
+ * 行（空 thinking 块）写全零 usage，真实用量只在带 stop_reason 的末行。
+ * first-occurrence-wins 会把零记录钉死、丢掉真实用量（regression 2026-08-19：
+ * auto-resume 卡 per-run 统计全 0）。逐字段 max 与行序无关地重建完整用量；
+ * 官方 API 每行重复相同 usage，max 是 no-op。
+ *
+ * 产生：合并后的一条采样。依赖：入参。不改任何外部状态。
+ */
+export declare function maxUsageRecord(prev: ClaudePerMessageUsage | undefined, usage: ClaudeRawUsage, turnSeq: number): ClaudePerMessageUsage;
+/**
+ * usage 装配（纯函数）：每个 message id 一条最优记录、按首次出现顺序喂
+ * UsageAccumulator（Map 保序），acc.last = 末条 message 的完整用量，totals
+ * 让每条 API 响应恰好多计一次。per-run flow 只取末个真人 turn 的记录——
+ * 工具往返的 turn 有多条 assistant 消息（一次模型请求一条），只取 `last`
+ * 会低报。
+ *
+ * 产生：AgentSessionUsage。依赖：入参 records + 标量。不改任何外部状态
+ * （UsageAccumulator 在函数内新建）。
+ */
+export declare function buildClaudeUsage(records: Iterable<ClaudePerMessageUsage>, opts: {
+    turnSeq: number;
+    lastPostTokens: number;
+    compactCount: number;
+}): AgentSessionUsage;
 export declare function readSessionContent(sessionId: string, cwd: string, opts?: {
     projectsDir?: string;
     maxEvents?: number;
@@ -35,3 +79,4 @@ export declare function readSessionContent(sessionId: string, cwd: string, opts?
     recap?: string;
     displayTitle?: string;
 };
+export {};