lark-remote 0.5.3 → 0.5.5

package/dist/runner/opencode/acp/error-monitor.js

@@ -2,7 +2,7 @@
  * OpencodeLogErrorMonitor: watches opencode's own log file for LLM stream
  * errors of the active ACP session and reports them immediately.
  *
- * Why this exists: opencode ACP (v1.18.x) does NOT forward retry/error state
+ * Why this exists: opencode ACP (v1.18.x and v2.0.x) does NOT forward retry/error state
  * to the client over the ACP protocol. Its session/update notifications are
  * limited to content deltas (agent_message_chunk / agent_thought_chunk /
  * tool_call / tool_call_update), usage and available-commands updates — there
@@ -36,7 +36,7 @@ const ERROR_MESSAGE_RE = /error\.error="((?:[^"\\]|\\.)*)"/;
  * Resolve opencode's log file path from the XDG data dir
  * (`$XDG_DATA_HOME/opencode/log/opencode.log`, default
  * `~/.local/share/opencode/log/opencode.log`). Matches opencode's own
- * data-dir layout (open source v1.18.x: `opencode/src/cli/global.ts`).
+ * data-dir layout (verified against v1.18.x and v2.0.32 `debug paths`).
  */
 export function resolveOpencodeLogPath() {
     const dataHome = process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share');

package/dist/runner/opencode/acp/runner.d.ts

@@ -84,6 +84,15 @@ export declare class OpencodeAcpRunner extends BaseAcpRunner<OpencodeAcpTranslat
      */
     protected onCompactPromptFired(promptPromise: Promise<SessionPromptResult>, translator: OpencodeAcpTranslator, sessionId: string, _opts: unknown, _baselineTotalCount: number): void;
     protected buildApprovalOutcome(action: string, pending: AcpPendingApproval, _response: unknown): unknown;
+    /**
+     * opencode 2 is ACP client → shared background daemon. The daemon can be
+     * starting or still activating location plugins when the first session is
+     * created; both surface as a JSON-RPC internal error. Retry a few times
+     * before failing the turn.
+     */
+    protected sessionSetupRetryDelaysMs(): number[];
+    protected isRetryableSessionSetupError(err: unknown): boolean;
+    protected enrichSessionSetupError(err: unknown): Error;
     getStatusInfo(): AgentStatusInfo;
     /**
      * Hot-apply a mode change to the live ACP session.

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

@@ -56,6 +56,13 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
                     terminal: false,
                 },
             },
+            onConnected: (result) => {
+                const version = result?.agentInfo
+                    ?.version;
+                if (version) {
+                    getLogger().info(`[opencode-acp-runner] connected to OpenCode ${version}`);
+                }
+            },
         };
         super({
             kind: opts.kind,
@@ -144,11 +151,43 @@ export class OpencodeAcpRunner extends BaseAcpRunner {
      * translation (no wire.jsonl polling, unlike kimi).
      */
     onCompactPromptFired(promptPromise, translator, sessionId, _opts, _baselineTotalCount) {
-        promptPromise.then((result) => this.handlePromptResolved(result, translator, sessionId), (err) => this.handlePromptRejected(err, translator, sessionId, 'compact'));
+        // 与 setupTurn 相同，捕获发起压缩那一轮的代际 + client；
+        // 旧轮迟到的 prompt 结算不得写入新轮的共享队列。
+        const generation = this.turnGeneration;
+        const client = this.currentClient;
+        promptPromise.then((result) => {
+            if (!this.isCurrentTurn(generation, client))
+                return;
+            this.handlePromptResolved(result, translator, sessionId);
+        }, (err) => {
+            if (!this.isCurrentTurn(generation, client))
+                return;
+            this.handlePromptRejected(err, translator, sessionId, 'compact');
+        });
     }
     buildApprovalOutcome(action, pending, _response) {
         return buildAcpPermissionOutcome(action, pending.options, OPENCODE_APPROVAL_KINDS);
     }
+    /**
+     * opencode 2 is ACP client → shared background daemon. The daemon can be
+     * starting or still activating location plugins when the first session is
+     * created; both surface as a JSON-RPC internal error. Retry a few times
+     * before failing the turn.
+     */
+    sessionSetupRetryDelaysMs() {
+        return [500, 1500, 3000];
+    }
+    isRetryableSessionSetupError(err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return /ServiceUnavailableError|Location plugins did not finish activating|Internal service failure|ECONNREFUSED|fetch failed/i.test(message);
+    }
+    enrichSessionSetupError(err) {
+        if (!this.isRetryableSessionSetupError(err)) {
+            return super.enrichSessionSetupError(err);
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return new Error(`opencode 2.0 后台服务不可用（${message}）。请在终端执行 \`opencode service restart\` 后重试。`, { cause: err });
+    }
     getStatusInfo() {
         return {
             kind: this.kind,

package/dist/runner/opencode/acp/translator.d.ts

@@ -9,8 +9,10 @@
  * `props.delta` verbatim), so text/thinking chunks go straight onto the
  * `assistant` incremental channel — NO accumulation, NO turn_diff snapshot.
  * (Contrast kimi: same field is also a delta but kimi's contract accumulates
- * into turn_diff snapshots; both end with exactly one concatenation in
- * run-state, enforced by each side's seam test.)
+ * into turn_diff snapshots. Both end as verbatim text in run-state: the
+ * assistant channel appends deltas sharing one `itemId`, the snapshot channel
+ * replaces by itemId. opencode's `agent_thought_chunk.messageId`
+ * (`<msg>:reasoning:<ordinal>`) IS that block identity — pass it through.)
  *
  * Event mapping (source: opencode acp/service.ts + event.ts + tool.ts,
  * dev@1c965451b5):

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

@@ -9,8 +9,10 @@
  * `props.delta` verbatim), so text/thinking chunks go straight onto the
  * `assistant` incremental channel — NO accumulation, NO turn_diff snapshot.
  * (Contrast kimi: same field is also a delta but kimi's contract accumulates
- * into turn_diff snapshots; both end with exactly one concatenation in
- * run-state, enforced by each side's seam test.)
+ * into turn_diff snapshots. Both end as verbatim text in run-state: the
+ * assistant channel appends deltas sharing one `itemId`, the snapshot channel
+ * replaces by itemId. opencode's `agent_thought_chunk.messageId`
+ * (`<msg>:reasoning:<ordinal>`) IS that block identity — pass it through.)
  *
  * Event mapping (source: opencode acp/service.ts + event.ts + tool.ts,
  * dev@1c965451b5):
@@ -54,7 +56,14 @@ export class OpencodeAcpTranslator extends BaseAcpTranslator {
             {
                 type: 'assistant',
                 message: {
-                    content: [{ type: 'thinking', thinking: event.content.text }],
+                    content: [
+                        {
+                            type: 'thinking',
+                            thinking: event.content.text,
+                            // 同一 reasoning part 的续写 delta 共享 messageId；换 part 才开新块。
+                            ...(event.messageId !== undefined ? { itemId: event.messageId } : {}),
+                        },
+                    ],
                 },
                 timestamp: new Date().toISOString(),
             },

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

@@ -34,6 +34,8 @@ export declare class PiRpcTranslator {
     private hasUsage;
     /** toolcall_start bookkeeping：占位不发事件，end 时补发完整 tool_use。 */
     private pendingToolCall;
+    /** 思考块序号：每条消息的每个 thinking 块一个稳定 itemId。 */
+    private thinkingSeq;
     /** Provider failure (stopReason="error") on the final assistant message. */
     private lastAssistantStopReason;
     private lastAssistantErrorMessage;

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

@@ -25,6 +25,8 @@ export class PiRpcTranslator {
     hasUsage = false;
     /** toolcall_start bookkeeping：占位不发事件，end 时补发完整 tool_use。 */
     pendingToolCall = false;
+    /** 思考块序号：每条消息的每个 thinking 块一个稳定 itemId。 */
+    thinkingSeq = 0;
     /** Provider failure (stopReason="error") on the final assistant message. */
     lastAssistantStopReason;
     lastAssistantErrorMessage;
@@ -192,9 +194,16 @@ export class PiRpcTranslator {
             this.lastAssistantErrorMessage = m.stopReason === 'error' ? m.errorMessage : undefined;
             if (m.usage)
                 this.addUsage(m.usage);
+            // 块生产者职责：连续 thinking 块在这里合并并写入 '\n' 段落分隔，
+            // 再给每个块一个 itemId。run-state 只按 itemId 逐字追加，不猜分隔符。
+            const content = mergeConsecutiveThinking(this.content);
+            for (const block of content) {
+                if (block.type === 'thinking')
+                    block.itemId = `pi:${++this.thinkingSeq}`;
+            }
             const event = {
                 type: 'assistant',
-                message: { content: this.content },
+                message: { content },
                 timestamp: new Date().toISOString(),
             };
             this.content = [];
@@ -291,4 +300,21 @@ export class PiRpcTranslator {
         }
     }
 }
+/**
+ * 合并同一消息内连续的 thinking 块（块间用 '\n'），保留其余内容顺序。
+ * 与 c0e1fb7 的“避免碎片化思考面板”决定一致。
+ */
+function mergeConsecutiveThinking(content) {
+    const out = [];
+    for (const block of content) {
+        const last = out[out.length - 1];
+        if (block.type === 'thinking' && last?.type === 'thinking') {
+            out[out.length - 1] = { ...last, thinking: `${last.thinking}\n${block.thinking}` };
+        }
+        else {
+            out.push(block.type === 'thinking' ? { ...block } : block);
+        }
+    }
+    return out;
+}
 //# sourceMappingURL=translator.js.map

package/dist/runner/types.d.ts

@@ -148,6 +148,11 @@ export interface ApprovalView {
     requestId: number | string;
     kind: 'command' | 'file' | 'permissions' | 'question' | 'tool';
     reason?: string;
+    /**
+     * Agent-agnostic scope note rendered at the top of the approval area (e.g. DSH's
+     * "this grant applies to one call only"). Keep the audit reason untouched.
+     */
+    note?: string;
     /**
      * 提问卡顶部概要行（数据驱动，无 agent 分支）：Kimi elicitation form 的
      * 题面只在 form 级 message 里合并出现，逐字段 title 可能只是短 header，
@@ -201,10 +206,24 @@ export interface ApprovalView {
     availableDecisions: string[];
     /** Raw payloads for structured decisions (e.g. acceptWithExecpolicyAmendment). */
     decisionPayloads?: Record<string, unknown>;
+    /**
+     * 最近一次响应发送失败的原因。协调器失败后回滚 pending 并写回
+     * 该字段，卡片据此渲染「提交失败，可重试」，不再让用户误以为已提交。
+     */
+    deliveryError?: string;
 }
 interface ThinkingContent {
     type: 'thinking';
     thinking: string;
+    /**
+     * 思考块身份。同一 itemId 的连续 `thinking` 内容是**同一块的增量**，run-state
+     * 逐字拼接（不插入任何分隔符）；itemId 变化才开启新块。缺省表示"续写当前块"
+     * （块生产者必须显式给 id，避免与上一块粘连）。
+     *
+     * 来源：opencode `agent_thought_chunk.messageId`（`<msg>:reasoning:<ordinal>`）、
+     * DSH `reasoning-delta` 的 attemptId+index、pi 每条消息的块序号。
+     */
+    itemId?: string;
 }
 interface TextContent {
     type: 'text';
@@ -412,6 +431,21 @@ export interface Runner {
  */
 export declare const AGENT_KINDS: readonly ["claude", "codex", "opencode", "pi", "kimi", "dsh"];
 export type AgentKind = (typeof AGENT_KINDS)[number];
+/**
+ * Compact 能力声明（运行时门控的能力清单，编译期强制完整）。
+ *
+ * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
+ * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
+ * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ *
+ * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
+ * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧
+ * 仍按「声明 && 实现」双重门控（fail closed），不一致时打 error 日志。
+ */
+export declare const COMPACT_CAPABILITY: Readonly<Record<AgentKind, boolean>>;
+/** 该 agent 是否声明支持 compact（渲染门控与执行门控共用的唯一判据）。 */
+export declare function supportsCompact(kind: AgentKind): boolean;
 /** Unified session descriptor returned by every AgentSessionReader. */
 export interface AgentSession {
     sessionId: string;

package/dist/runner/types.js

@@ -16,4 +16,28 @@
  * 新增 agent 只改这里。
  */
 export const AGENT_KINDS = ['claude', 'codex', 'opencode', 'pi', 'kimi', 'dsh'];
+/**
+ * Compact 能力声明（运行时门控的能力清单，编译期强制完整）。
+ *
+ * 键集就是 `AgentKind`：新增 agent 时缺一项 = TypeScript 报错，必须显式回答
+ * 「这个 agent 能不能压缩」。历史教训：能力只由 runner 上有没有 `runCompact`
+ * 这个鸭子方法隐式决定，dsh 接入时漏了实现，run 卡片直接不渲染按钮——没有
+ * 报错、没有置灰、没有日志，用户只能看到一个缺失的按钮（2026-10-17）。
+ *
+ * 声明与实现的唯一性由 `src/runner/runner-structure.test.ts` 的矩阵用例保证：
+ * 每个 kind 的声明值必须等于对应 runner 类是否实现 `runCompact`。bridge 侧
+ * 仍按「声明 && 实现」双重门控（fail closed），不一致时打 error 日志。
+ */
+export const COMPACT_CAPABILITY = {
+    claude: true,
+    codex: true,
+    opencode: true,
+    pi: true,
+    kimi: true,
+    dsh: true,
+};
+/** 该 agent 是否声明支持 compact（渲染门控与执行门控共用的唯一判据）。 */
+export function supportsCompact(kind) {
+    return COMPACT_CAPABILITY[kind];
+}
 //# sourceMappingURL=types.js.map

package/dist/session/codex/rollout-reader.js

@@ -42,6 +42,9 @@ function subtractRawUsage(a, b) {
         total_tokens: a.total_tokens - b.total_tokens,
     };
 }
+function emptyTurnUsage() {
+    return { input: 0, cached: 0, output: 0, total: 0 };
+}
 /**
  * `compacted` 事件自带的摘要调用 usage（`latest_token_usage_record.usage`）。
  * 用于把「压缩前窗口」与「摘要调用自身的消耗」区分开——两者都写在 compacted 前。
@@ -141,12 +144,19 @@ function scanCodexRollout(filePath, includeEvents) {
     // exactly the 0.153 compatibility incident shape.
     let userResponseItemCount = 0;
     // token_count tracking: codex emits cumulative `total_token_usage` and an
-    // incremental `last_token_usage`. We want the LAST turn's usage (matches
-    // pi/opencode /resume "last turn" display semantics). When
+    // incremental `last_token_usage` **per sampling call** — one turn with tool
+    // round-trips logs several `token_count` lines. We want the LAST turn's usage
+    // = the sum of that turn's samplings (matches pi/opencode /resume "last turn"
+    // display semantics). Turn boundaries come from `task_started`. When
     // last_token_usage is absent we derive it as total - previous_total.
     let lastRawUsage;
     /** 上一条被接受的 raw usage；compacted 分支回退一条时用（见下方注释）。 */
     let previousRawUsage;
+    /**
+     * 末个 turn 的累计用量；`null` = 文件里没有 `task_started`（旧数据），
+     * 此时 flow 字段退回「末条 token_count」语义（见 buildUsageFromScan）。
+     */
+    let turnUsage = null;
     // Context window limit from the same token_count event as lastRawUsage
     // (codex reports info.model_context_window per turn; absent on old data).
     let lastContextLimit;
@@ -194,6 +204,12 @@ function scanCodexRollout(filePath, includeEvents) {
                     }
                     lastUserMessageSource = human.source;
                 }
+                else if (payload.type === 'task_started') {
+                    // turn 边界：一个 turn 一条 task_started（与 task_complete 成对，
+                    // turn_id 见 session_meta 之后的 `turn_context`）。从这里开始重新
+                    // 累计本 turn 的用量。
+                    turnUsage = emptyTurnUsage();
+                }
                 else if (payload.type === 'token_count') {
                     const info = payload.info;
                     const last = info?.last_token_usage;
@@ -217,6 +233,13 @@ function scanCodexRollout(filePath, includeEvents) {
                         lastRawUsage = raw;
                         const ctxWindow = info?.model_context_window;
                         lastContextLimit = typeof ctxWindow === 'number' ? ctxWindow : undefined;
+                        if (turnUsage) {
+                            const cached = Math.min(raw.cached_input_tokens, raw.input_tokens);
+                            turnUsage.input += raw.input_tokens - cached;
+                            turnUsage.cached += cached;
+                            turnUsage.output += raw.output_tokens;
+                            turnUsage.total += raw.total_tokens;
+                        }
                     }
                     // 压缩后的水位：压缩收尾 token_count 全 0（raw 不满足上面 zero-filter），
                     // 但 total_tokens 表达真实窗口；之后若出现普通 turn（input>0），
@@ -288,6 +311,7 @@ function scanCodexRollout(filePath, includeEvents) {
         lastContextLimit,
         lastTotalUsage,
         previousTotals,
+        turnUsage,
         compactCount,
         compactPreContextLength,
         compactPostContextLength,
@@ -298,25 +322,38 @@ function scanCodexRollout(filePath, includeEvents) {
  * input = raw - cached (codex reports cached input separately), cache
  * creation is never reported by codex, reasoning is a subset of output
  * (display-only, never added to total).
+ *
+ * Flow fields (input/output/cache/total) are the **sum over the last turn's
+ * samplings** when the file marks turn boundaries (`task_started`) — one codex
+ * turn logs one `token_count` per sampling, so the last line alone understates
+ * a tool-looping run (measured: 212 / 679 displayed vs 3,022 / 3,648 consumed).
+ * Legacy files without `task_started` keep the last-`token_count` semantics.
  * contextLength = input_tokens (= (input_tokens-cached) + cached + 0),
  * i.e. input + cacheRead + cacheCreation — the unified context-window
  * occupancy contract across all five readers (excludes
  * output/reasoning).
  */
 function buildUsageFromScan(scan) {
-    const { lastRawUsage, lastContextLimit, lastTotalUsage, compactCount, compactPreContextLength, compactPostContextLength, } = scan;
+    const { lastRawUsage, lastContextLimit, lastTotalUsage, turnUsage, compactCount, compactPreContextLength, compactPostContextLength, } = scan;
     if (!lastRawUsage)
         return undefined;
     const r = lastRawUsage;
     const cached = Math.min(r.cached_input_tokens, r.input_tokens);
+    // 本 run = 末个 turn 全部采样之和；旧数据（无 task_started）退回末条。
+    const flow = turnUsage ?? {
+        input: r.input_tokens - cached,
+        cached,
+        output: r.output_tokens,
+        total: r.total_tokens,
+    };
     const usage = {
-        inputTokens: r.input_tokens - cached,
-        outputTokens: r.output_tokens,
+        inputTokens: flow.input,
+        outputTokens: flow.output,
         contextLength: r.input_tokens,
         contextLimit: lastContextLimit,
-        cacheReadTokens: cached,
+        cacheReadTokens: flow.cached,
         cacheCreationTokens: 0,
-        totalTokens: r.total_tokens,
+        totalTokens: flow.total,
     };
     // Cumulative from the final total_token_usage (non-cached input +
     // output), summed across all turns in the session.

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

@@ -3,31 +3,62 @@
  *
  * The AgentSessionReader contract is fully synchronous (file-style readers),
  * but DSH exposes only async HTTP. The reader therefore bridges with
- * `spawnSync('curl', ...)` for its unary calls (session.list / session.history)
+ * `spawnSync('curl', ...)` for its unary calls (session/list / session/page)
  * — a synchronous HTTP round-trip to the local DSH host. This keeps the
  * router/bridge interface contract intact without touching any upstream logic.
  *
- * listSessions: session.list → filter by cwd → sort by updatedAt desc → local
+ * listSessions: session/list → filter by cwd → sort by updatedAt desc → local
  *   pagination (DSH v1 has no cursor pagination).
- * readSessionContent: session.history → map SessionEvents to display events +
- *   session-wide usage accumulation (assistant/message.usage).
+ * readSessionContent: session/projections → session/page → map SessionEvents +
+ *   session-wide usage accumulation (assistant/message.usage)；本 run 的 flow
+ *   字段 = 末个 turn（turn/start–turn/end）内所有采样之和，与 codex 同口径。
  */
 import type { AgentSession, AgentSessionReader, SessionContent } from '../../runner/index.js';
 interface DshSessionReaderOptions {
     host?: string;
+    /** Configured DSH home; selects `.credentials.yaml` when credentialsFile is unset. */
+    dshHomeProvider?: () => string | undefined;
+    /** `dsh web` launch token (or its startup URL). */
+    token?: string;
+    /** DSH credentials file with the durable browser-session signing secret. */
+    credentialsFile?: string;
+    /** Resolve the credentials file on every call (hot /config change). */
+    credentialsFileProvider?: () => string | undefined;
+    /** Injectable synchronous credentials reader (tests). */
+    readCredentials?: (file: string) => Buffer;
+    /** Injectable clock (tests). */
+    now?: () => number;
+    /** Lifetime of minted browser cookies. */
+    cookieLifetimeMs?: number;
+    /** Resolve the current token on every call (hot /config change). */
+    tokenProvider?: () => string | undefined;
     /** 每次调用时解析当前 host（/config 修改 host 后 runner 重建、reader 也跟随新 host）。
      *  优先于固定的 `host`。 */
     hostProvider?: () => string | undefined;
     /** Injectable synchronous unary transport. Defaults to spawnSync curl. */
-    syncRequest?: (baseUrl: string, method: string, payload: unknown) => unknown;
+    syncRequest?: (baseUrl: string, method: string, payload: unknown, cookie?: string) => unknown;
+    /** Injectable synchronous launch-token bootstrap (tests). */
+    syncConnect?: (baseUrl: string, token: string) => string;
 }
 export declare class DshSessionReader implements AgentSessionReader {
     private readonly hostProvider;
+    private readonly dshHomeProvider;
+    private readonly tokenProvider;
+    private readonly credentialsFileProvider;
+    private readonly readCredentials;
+    private readonly now;
+    private readonly cookieLifetimeMs;
     private readonly syncRequest;
+    private readonly syncConnect;
+    private readonly cookieCache;
     constructor(opts?: DshSessionReaderOptions);
     /** 解析当前 host（hostProvider 优先，允许 /config 热改 host）。 */
     private resolveBaseUrl;
+    private resolveCredentialsFile;
     private unary;
+    /** Mint from the durable secret, or bootstrap and cache a token cookie. */
+    private resolveCookie;
+    private cookieFromCredentials;
     listSessions(cwd: string, opts?: {
         limit?: number;
         offset?: number;
@@ -36,9 +67,17 @@ export declare class DshSessionReader implements AgentSessionReader {
         total: number;
     };
     getNewestSession(cwd: string): AgentSession | null;
-    readSessionContent(sessionId: string, _cwd: string, opts?: {
+    readSessionContent(sessionId: string, cwd: string, opts?: {
         maxEvents?: number;
     }): SessionContent;
     isSessionActive(sessionId: string, cwd: string): boolean;
+    /**
+     * Find the session row in `session/list` that matches BOTH id and cwd.
+     * Returns undefined when the id belongs to another workspace (or is unknown) —
+     * every caller treats that as "not usable here".
+     */
+    private resolveSession;
+    /** `session/page` needs an inclusive cursor; projections carry the watermark. */
+    private resolveThroughSeq;
 }
 export {};