lark-remote 0.1.4 → 0.1.6

package/dist/runner/codex/app-server/runner.js

@@ -0,0 +1,554 @@
+/**
+ * CodexAppServerRunner: workspace-lifetime runner using the Codex App Server
+ * protocol (`codex app-server`, JSON-RPC over stdio).
+ *
+ * Flow per run: acquire persistent connection → thread/start or thread/resume
+ * → turn/start → consume notifications (agent message deltas, approval server
+ * requests, …) until turn/completed → synthesize ResultEvent.
+ */
+import { ConnectionManager } from './connection-manager.js';
+import { ConnectionLostError } from './client.js';
+import { CodexAppServerTranslator } from './translator.js';
+import { getLogger } from '../../../logger/index.js';
+import { syntheticInitEvent } from '../../common/runner-utils.js';
+/** How long to wait for turn output notifications before failing. */
+const TURN_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Build the protocol response body for a command/file approval decision.
+ * Structured decisions (acceptWithExecpolicyAmendment) carry the payload the
+ * server originally offered; if it is missing, fall back to plain accept.
+ */
+function buildApprovalResponse(action, view) {
+    if (action === 'accept_for_session') {
+        return { decision: 'acceptForSession' };
+    }
+    if (action === 'accept_with_execpolicy_amendment') {
+        const payload = view.decisionPayloads?.['acceptWithExecpolicyAmendment'];
+        if (payload) {
+            return { decision: { acceptWithExecpolicyAmendment: payload } };
+        }
+        getLogger().warn('[codex-app-server-runner] acceptWithExecpolicyAmendment payload missing, falling back to accept');
+        return { decision: 'accept' };
+    }
+    return { decision: action };
+}
+export class CodexAppServerRunner {
+    kind;
+    sessionReader;
+    lifetime = 'workspace';
+    connectionManager;
+    currentClient = null;
+    currentTranslator = null;
+    currentThreadId = null;
+    currentTurnId = null;
+    lastEventAt = 0;
+    _isRunning = false;
+    model;
+    modelProvider;
+    reasoningEffort;
+    sandboxConfig;
+    approvalPolicyConfig;
+    turnTimeoutMs;
+    /** Pending approval requests: requestId (JSON-RPC id) → kind + view. */
+    pendingApprovals = new Map();
+    /** Notification queue consumed by the active run generator. */
+    notificationQueue = [];
+    waitResolve = null;
+    forceFinish = false;
+    /** stop() 在 turn/start 响应前到达时置位，turn/start 完成后补发 interrupt。 */
+    stopRequested = false;
+    constructor(opts) {
+        this.kind = opts.kind;
+        this.sessionReader = opts.sessionReader;
+        this.model = opts.model;
+        this.modelProvider = opts.modelProvider;
+        this.reasoningEffort = opts.reasoningEffort;
+        this.sandboxConfig = opts.sandbox;
+        this.approvalPolicyConfig = opts.approvalPolicy;
+        this.turnTimeoutMs = opts.turnTimeoutMs ?? TURN_IDLE_TIMEOUT_MS;
+        const managerOpts = {
+            binary: opts.binary ?? 'codex',
+            args: opts.appServerArgs,
+            env: opts.env,
+            requestTimeoutMs: opts.requestTimeoutMs,
+            idleTtlMs: opts.idleTtlMs,
+        };
+        this.connectionManager = new ConnectionManager(managerOpts);
+    }
+    get isRunning() {
+        return this._isRunning;
+    }
+    /**
+     * Run a message in the current thread.
+     *
+     * 进程容错：若 app-server 子进程被外部误杀或自身异常退出（连接丢失），
+     * 自动重拉进程并重试一次 setup（thread/start 或按 sessionId thread/resume
+     * 继续处理），保证消费用户消息时进程挂了也能恢复。
+     */
+    async *run(message, opts) {
+        if (this._isRunning) {
+            throw new Error('CodexAppServerRunner is already running');
+        }
+        this._isRunning = true;
+        this.resetRunState();
+        try {
+            try {
+                await this.setupTurn(message, opts);
+            }
+            catch (err) {
+                // 连接在 setup 期间丢失（进程被误杀/异常退出）：重拉进程并重试一次。
+                // thread/resume 会按持久化记录（rollout）恢复线程，继续原会话处理。
+                if (err instanceof ConnectionLostError && !this.stopRequested) {
+                    getLogger().warn(`[codex-app-server-runner] connection lost during turn setup (${err.message}), respawning app-server and retrying once`);
+                    // 旧连接可能仍挂在 slot 里（close 事件尚未处理完）：先强制释放，
+                    // 保证重试会拉起全新进程；并摘掉旧 client 的 hooks，避免其残留的
+                    // onClose 把错误结果塞进重试后的通知队列。
+                    await this.connectionManager.release(opts.cwd);
+                    const staleClient = this.currentClient;
+                    if (staleClient) {
+                        staleClient.setHooks({
+                            onNotification: () => { },
+                            onServerRequest: () => { },
+                            onClose: () => { },
+                        });
+                    }
+                    this.resetRunState();
+                    await this.setupTurn(message, opts);
+                }
+                else {
+                    throw err;
+                }
+            }
+            if (this.stopRequested) {
+                // 启动期 /stop：turn/start 已完成，补发 interrupt，避免 server 端 turn
+                // 无人接管继续执行。
+                getLogger().warn('[codex-app-server-runner] stop requested before turn/start resolved');
+                try {
+                    await this.currentClient?.request('turn/interrupt', {
+                        threadId: this.currentThreadId,
+                        turnId: this.currentTurnId,
+                    });
+                }
+                catch (err) {
+                    getLogger().warn(`[codex-app-server-runner] deferred interrupt failed: ${err.message}`);
+                }
+            }
+            // §9.22 守卫前提：桥的 pre-init result guard 和 run-state reducer 都以
+            // system.init 作为「本轮真实开始」的标记，而 app-server 协议没有 init 事件。
+            // 缺了它，成功的 result 会被当作 pre-init 丢弃，卡片终态停在 running，
+            // 最后兜底成「输出流已结束，但未收到 result 事件」（2026-08-13 事故）。
+            // 与 exec runner 的 syntheticInitEvent 模式一致：turn setup 成功即发 init，
+            // 保证 turn_started / turn_diff / result 全部落在 init 之后。
+            yield syntheticInitEvent(this.currentThreadId ?? opts.sessionId ?? '');
+            yield* this.consumeTurn();
+        }
+        catch (err) {
+            getLogger().error(`[codex-app-server-runner] run error: ${err.message}`);
+            // 与 spawn 失败路径（spawning-runner §9.22）同理：error result 前必须补
+            // init，否则守卫把错误结果丢弃，卡片只显示通用「输出流已结束」而非具体
+            // 错误信息。
+            yield syntheticInitEvent(this.currentThreadId ?? opts.sessionId ?? '');
+            yield {
+                type: 'result',
+                subtype: 'error',
+                // 优先上报本次 setup 创建/恢复的线程 id：thread/start 成功后 turn/start
+                // 失败时 opts.sessionId 仍是旧值，漏报会导致下条消息再开一个孤儿线程
+                // （review P3-10）。
+                session_id: this.currentThreadId ?? opts.sessionId ?? '',
+                errorMessage: err.message,
+            };
+        }
+        finally {
+            this._isRunning = false;
+            this.currentTranslator = null;
+            this.currentTurnId = null;
+            this.stopRequested = false;
+            this.currentThreadId = null;
+            // 无论成功失败都要重新武装 idle TTL（无 slot 时是 no-op）。
+            this.connectionManager.notifyIdle(opts.cwd);
+        }
+    }
+    /**
+     * Acquire the connection and set up the turn: thread/start（新会话）或
+     * thread/resume（按 sessionId 恢复既有线程）→ turn/start。
+     */
+    async setupTurn(message, opts) {
+        const client = await this.connectionManager.acquire(opts.cwd);
+        this.connectionManager.notifyActivity(opts.cwd);
+        this.currentClient = client;
+        client.setHooks({
+            onNotification: (method, params) => this.handleNotification(method, params),
+            onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
+            onClose: () => {
+                getLogger().warn('[codex-app-server-runner] client connection closed');
+                this.failTurn('Codex app-server connection closed');
+            },
+        });
+        const threadParams = this.buildThreadParams(opts.cwd);
+        let threadId;
+        if (opts.sessionId) {
+            const resumeParams = {
+                threadId: opts.sessionId,
+                ...threadParams,
+            };
+            await client.request('thread/resume', resumeParams);
+            threadId = opts.sessionId;
+        }
+        else {
+            const threadResult = await client.request('thread/start', threadParams);
+            // 会话键假设（review P2-4）：主线程 thread.id === session_meta.session_id，
+            // 故 thread.id 可同时用作协议 threadId 与 store/session reader 的 session
+            // 键（bridge 用 turn_started 通知的 threadId 写回，/resume、Compact 按此
+            // 键定位 JSONL）。forked/subagent 线程二者会分叉（openai/codex#29327），
+            // 桥只把主线程作为顶层会话，不在此链路内。
+            threadId = threadResult.thread.id;
+        }
+        this.currentThreadId = threadId;
+        const translator = new CodexAppServerTranslator();
+        this.currentTranslator = translator;
+        const turnParams = this.buildTurnParams(message, opts);
+        const turnResult = await client.request('turn/start', turnParams);
+        this.currentTurnId = turnResult.turn.id;
+    }
+    /**
+     * Run a compact operation on the current thread.
+     */
+    async *runCompact(_message, opts) {
+        if (this._isRunning) {
+            throw new Error('CodexAppServerRunner is already running');
+        }
+        this._isRunning = true;
+        this.resetRunState();
+        try {
+            const client = await this.connectionManager.acquire(opts.cwd);
+            this.connectionManager.notifyActivity(opts.cwd);
+            this.currentClient = client;
+            client.setHooks({
+                onNotification: (method, params) => this.handleNotification(method, params),
+                onServerRequest: (id, method, params) => this.handleServerRequest(id, method, params),
+                onClose: () => this.failTurn('Codex app-server connection closed'),
+            });
+            if (!opts.sessionId) {
+                throw new Error('compact requires a sessionId');
+            }
+            this.currentThreadId = opts.sessionId;
+            const translator = new CodexAppServerTranslator();
+            translator.setOperationKind('compact');
+            this.currentTranslator = translator;
+            // 冷连接兜底：thread/compact/start 要求线程已加载。真实协议里对未加载
+            // 的线程直接 compact 返回 -32600 "thread not found"（codex-cli 0.147.0
+            // 实测），只有先 thread/resume（或 thread/start）把线程载入内存才能
+            // 压缩。连接池复用期间线程本就在内存，resume 幂等无害；连接被
+            // /stop、idle TTL 或进程重建后，这一步是 Compact 能工作的前提。
+            const resumeParams = {
+                threadId: opts.sessionId,
+                ...this.buildThreadParams(opts.cwd),
+            };
+            await client.request('thread/resume', resumeParams);
+            await client.request('thread/compact/start', { threadId: opts.sessionId });
+            // 与 run() 同理：compact 也先发 init 再消费通知，避免 result 被守卫丢弃。
+            yield syntheticInitEvent(this.currentThreadId ?? opts.sessionId ?? '');
+            yield* this.consumeTurn();
+        }
+        catch (err) {
+            getLogger().error(`[codex-app-server-runner] runCompact error: ${err.message}`);
+            yield syntheticInitEvent(this.currentThreadId ?? opts.sessionId ?? '');
+            yield {
+                type: 'result',
+                subtype: 'error',
+                session_id: this.currentThreadId ?? opts.sessionId ?? '',
+                errorMessage: err.message,
+            };
+        }
+        finally {
+            this._isRunning = false;
+            this.currentTranslator = null;
+            this.currentTurnId = null;
+            this.stopRequested = false;
+            this.currentThreadId = null;
+            this.connectionManager.notifyIdle(opts.cwd);
+        }
+    }
+    /**
+     * Stop the current turn by interrupting it.
+     */
+    async stop(_opts) {
+        if (!this._isRunning || !this.currentClient || !this.currentThreadId)
+            return;
+        if (!this.currentTurnId) {
+            // turn/start 尚未响应：先标记，等 run() 在 turn/start 完成后补发 interrupt。
+            this.stopRequested = true;
+            this.forceFinish = true;
+            this.wakeWaiters();
+            return;
+        }
+        try {
+            await this.currentClient.request('turn/interrupt', {
+                threadId: this.currentThreadId,
+                turnId: this.currentTurnId ?? '',
+            });
+        }
+        catch (err) {
+            getLogger().warn(`[codex-app-server-runner] stop error: ${err.message}`);
+        }
+        // Unblock the turn loop regardless of whether the server sends a
+        // turn/completed notification afterwards.
+        this.forceFinish = true;
+        this.wakeWaiters();
+    }
+    /**
+     * Respond to an approval server request. `response` is the bridge
+     * ApprovalAction (`{ action: 'accept' | 'accept_for_session' | 'decline' | 'cancel' }`).
+     */
+    async respondApproval(requestId, response) {
+        const client = this.currentClient;
+        const pending = this.pendingApprovals.get(requestId);
+        if (!client || !pending)
+            return;
+        const action = response?.action ?? 'decline';
+        if (pending.kind === 'permissions') {
+            // 权限审批的响应没有 decision 字段（真实协议只回 granted profile +
+            // scope）：decline/cancel 必须返回空授权（拒绝全部），否则会把用户已
+            // 勾选的条目当作授予返回（2026-08-12 review 发现：勾选后点「拒绝」实
+            // 际授予了所选权限）。accept/acceptForSession 才带用户勾选的条目。
+            const denied = action === 'decline' || action === 'cancel';
+            client.respond(requestId, {
+                permissions: denied
+                    ? this.denyAllPermissions()
+                    : this.buildGrantedPermissions(pending.view),
+                scope: action === 'accept_for_session' ? 'session' : 'turn',
+            });
+        }
+        else {
+            client.respond(requestId, buildApprovalResponse(action, pending.view));
+        }
+        this.pendingApprovals.delete(requestId);
+        getLogger().info(`[codex-app-server-runner] approval responded requestId=${requestId} kind=${pending.kind} action=${action}`);
+    }
+    /**
+     * Dispose the runner: release the connection.
+     */
+    async dispose() {
+        try {
+            await this.connectionManager.disposeAll();
+        }
+        catch (err) {
+            getLogger().warn(`[codex-app-server-runner] dispose error: ${err.message}`);
+        }
+    }
+    getUsageAuthority() {
+        return 'live';
+    }
+    killOrphan() {
+        // No-op: the app-server connection is managed by ConnectionManager.
+    }
+    registerExitHandlers() {
+        // No-op: connection manager handles cleanup on exit.
+    }
+    unregisterExitHandlers() {
+        // No-op.
+    }
+    getStatusInfo() {
+        return {
+            kind: this.kind,
+            model: this.model ?? '(app-server)',
+            provider: this.modelProvider,
+            reasoning: this.reasoningEffort,
+            extras: {
+                mode: 'app-server',
+                ...(this.sandboxConfig ? { sandbox: this.sandboxConfig } : {}),
+                ...(this.approvalPolicyConfig ? { approvalPolicy: String(this.approvalPolicyConfig) } : {}),
+            },
+        };
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    buildThreadParams(cwd) {
+        const params = {
+            cwd,
+            ...(this.model ? { model: this.model } : {}),
+            ...(this.modelProvider ? { modelProvider: this.modelProvider } : {}),
+            ...(this.approvalPolicyConfig ? { approvalPolicy: this.approvalPolicyConfig } : {}),
+            ...(this.sandboxConfig ? { sandbox: this.sandboxConfig } : {}),
+        };
+        return params;
+    }
+    buildTurnParams(message, opts) {
+        const params = {
+            threadId: this.currentThreadId ?? '',
+            input: [{ type: 'text', text: message }],
+            ...((opts.model ?? this.model) ? { model: opts.model ?? this.model } : {}),
+            ...((opts.reasoningEffort ?? this.reasoningEffort)
+                ? { effort: opts.reasoningEffort ?? this.reasoningEffort }
+                : {}),
+        };
+        return params;
+    }
+    /**
+     * Consume the notification queue until a result event arrives or the turn
+     * times out / is interrupted.
+     */
+    async *consumeTurn() {
+        while (true) {
+            const timedOut = await this.waitForEvents(this.nextTurnIdleDeadline());
+            if (timedOut) {
+                await this.interruptCurrentTurn();
+                getLogger().warn('[codex-app-server-runner] turn wait timed out');
+                yield {
+                    type: 'result',
+                    subtype: 'error',
+                    session_id: this.currentThreadId ?? '',
+                    errorMessage: 'Codex app-server turn timed out',
+                };
+                return;
+            }
+            if (this.forceFinish) {
+                yield {
+                    type: 'result',
+                    subtype: 'interrupted',
+                    session_id: this.currentThreadId ?? '',
+                    errorMessage: 'Codex app-server turn interrupted',
+                };
+                return;
+            }
+            while (this.notificationQueue.length > 0) {
+                const ev = this.notificationQueue.shift();
+                yield ev;
+                if (ev.type === 'result') {
+                    return;
+                }
+            }
+        }
+    }
+    /**
+     * Compute the current idle deadline. 0 disables the idle timeout; otherwise
+     * the deadline is based on the last received event, not the turn start time.
+     */
+    nextTurnIdleDeadline() {
+        if (this.turnTimeoutMs <= 0)
+            return Number.POSITIVE_INFINITY;
+        return this.lastEventAt + this.turnTimeoutMs;
+    }
+    async interruptCurrentTurn() {
+        if (!this.currentClient || !this.currentThreadId || !this.currentTurnId)
+            return;
+        try {
+            await this.currentClient.request('turn/interrupt', {
+                threadId: this.currentThreadId,
+                turnId: this.currentTurnId,
+            });
+        }
+        catch (err) {
+            getLogger().warn(`[codex-app-server-runner] idle-timeout interrupt failed: ${err.message}`);
+        }
+    }
+    async waitForEvents(deadline) {
+        while (this.notificationQueue.length === 0 && !this.forceFinish) {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0)
+                return true;
+            await new Promise((resolve) => {
+                this.waitResolve = resolve;
+                setTimeout(() => {
+                    if (this.waitResolve === resolve) {
+                        this.waitResolve = null;
+                        resolve();
+                    }
+                }, Math.min(remaining, 30_000));
+            });
+        }
+        return false;
+    }
+    handleNotification(method, params) {
+        const events = this.currentTranslator?.handleNotification(method, params) ?? [];
+        this.pushEvents(events);
+    }
+    handleServerRequest(id, method, params) {
+        const events = this.currentTranslator?.handleServerRequest(id, method, params) ?? [];
+        if (events.length === 0) {
+            // 未处理/不支持的服务端请求必须显式响应（error 即"拒绝"，turn 继续），
+            // 否则服务端会一直等待响应（applyPatchApproval、item/tool/requestUserInput、
+            // mcpServer/elicitation/request 等）。
+            this.currentClient?.respondError(id, -32601, `Unsupported server request: ${method}`);
+            return;
+        }
+        for (const ev of events) {
+            if (ev.type === 'approval_requested') {
+                this.pendingApprovals.set(ev.requestId, { kind: ev.kind, view: ev.view });
+                getLogger().info(`[codex-app-server-runner] approval requested requestId=${ev.requestId} kind=${ev.kind}`);
+            }
+        }
+        this.pushEvents(events);
+    }
+    pushEvents(events) {
+        if (events.length === 0)
+            return;
+        this.lastEventAt = Date.now();
+        this.notificationQueue.push(...events);
+        this.wakeWaiters();
+    }
+    wakeWaiters() {
+        if (this.waitResolve) {
+            const resolve = this.waitResolve;
+            this.waitResolve = null;
+            resolve();
+        }
+    }
+    failTurn(message) {
+        this.pushEvents([
+            {
+                type: 'result',
+                subtype: 'error',
+                session_id: this.currentThreadId ?? '',
+                errorMessage: message,
+            },
+        ]);
+    }
+    resetRunState() {
+        this.notificationQueue = [];
+        this.waitResolve = null;
+        this.lastEventAt = Date.now();
+        this.forceFinish = false;
+        this.pendingApprovals.clear();
+    }
+    buildGrantedPermissions(view) {
+        const items = view.permissions?.items ?? [];
+        const read = [];
+        const write = [];
+        let networkEnabled = false;
+        for (const item of items) {
+            if (!item.selected)
+                continue;
+            if (item.target.kind === 'fsRead') {
+                read.push(item.target.path);
+            }
+            else if (item.target.kind === 'fsWrite') {
+                write.push(item.target.path);
+            }
+            else if (item.target.kind === 'network') {
+                networkEnabled = true;
+            }
+        }
+        // 真实 GrantedPermissionProfile 形状（v1 schema）：fileSystem 用
+        // entries[{path, access}]（read/write 为 legacy 字符串数组，即将移除），
+        // network 是 { enabled } 布尔开关，不是 host 列表。
+        return {
+            fileSystem: {
+                entries: [
+                    ...read.map((path) => ({ path, access: 'read' })),
+                    ...write.map((path) => ({ path, access: 'write' })),
+                ],
+            },
+            network: { enabled: networkEnabled },
+        };
+    }
+    /** 拒绝权限审批：空 fileSystem + 关闭网络（真实 GrantedPermissionProfile）。 */
+    denyAllPermissions() {
+        return {
+            fileSystem: { entries: [] },
+            network: { enabled: false },
+        };
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner/codex/app-server/translator.d.ts

@@ -0,0 +1,109 @@
+/**
+ * CodexAppServerTranslator: translates protocol notifications and server
+ * requests into AgentEvents.
+ *
+ * The translator is stateful per turn — it tracks the current turn's state,
+ * accumulates deltas, and synthesizes the final ResultEvent when the turn
+ * completes. Method names and parameter shapes follow the real Codex
+ * app-server v2 protocol (see protocol-types.ts).
+ */
+import type { AgentEvent } from '../../types.js';
+import type { ApprovalRequestedEvent, ApprovalResolvedEvent } from '../../types.js';
+import { type TurnCompletedNotification } from './protocol-types.js';
+export interface TurnStartedEvent {
+    type: 'turn_started';
+    threadId: string;
+    turnId: string;
+    operationKind: 'turn' | 'compaction';
+}
+export interface TurnDiffEvent {
+    type: 'turn_diff';
+    text?: string;
+    reasoning?: string;
+    toolOutput?: string;
+    plan?: string;
+    fileChanges?: Array<{
+        path: string;
+        kind: 'add' | 'update' | 'delete';
+        diff?: string;
+    }>;
+    threadId: string;
+    turnId: string;
+}
+export type TranslatorEvent = AgentEvent | TurnStartedEvent | TurnDiffEvent | ApprovalRequestedEvent | ApprovalResolvedEvent;
+export declare class CodexAppServerTranslator {
+    private turnId;
+    private threadId;
+    private turnStatus;
+    /** Full agentMessage text per item id (item-scoped snapshot). */
+    private textByItem;
+    /**
+     * Reasoning content per item id: paragraphs keyed by `contentIndex`
+     * (textDelta) plus the summary stream (summaryTextDelta). Each reasoning
+     * item is isolated so interleaved items keep their own chronology.
+     */
+    private reasoningByItem;
+    /** Full command output per item id (item-scoped snapshot). */
+    private toolOutputByItem;
+    /** Full plan text per item id (item-scoped snapshot). */
+    private planByItem;
+    /** commandExecution items that emitted item/started (tool block position anchor). */
+    private startedToolItems;
+    /** fileChange items seen this turn, keyed by item id (item/started). */
+    private fileChangeItems;
+    /** File approvals whose item/started has not arrived yet (out-of-order flow). */
+    private pendingFileApprovalByItemId;
+    private usage;
+    private operationKind;
+    /**
+     * Handle a notification from the server and return events.
+     */
+    handleNotification(method: string, params: unknown): TranslatorEvent[];
+    /**
+     * Handle a server request (incoming JSON-RPC request from server, e.g. approval).
+     */
+    handleServerRequest(id: number | string, method: string, params: unknown): TranslatorEvent[];
+    /**
+     * Synthesize a ResultEvent from the current turn state.
+     * Called when the turn completes.
+     */
+    handleTurnCompleted(params?: TurnCompletedNotification['params']): TranslatorEvent[];
+    /**
+     * Get the current usage stats.
+     */
+    getUsage(): {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    /**
+     * Get the current turn status.
+     */
+    getTurnStatus(): string;
+    /**
+     * Set the operation kind (exec vs compact).
+     */
+    setOperationKind(kind: 'exec' | 'compact'): void;
+    private handleTurnStarted;
+    private handleAgentMessageDelta;
+    private handleReasoningDelta;
+    private handleReasoningPartAdded;
+    private handleItemCompleted;
+    private handleReasoningTextDelta;
+    private handleCommandOutputDelta;
+    private handlePlanUpdated;
+    private handleTokenUsageUpdated;
+    private handleError;
+    private handleThreadCompacted;
+    private handleServerRequestResolved;
+    private handleCommandApproval;
+    private handleFileApproval;
+    private handleItemStarted;
+    private handlePermissionsApproval;
+    private buildPermissionItems;
+    /** Get (or lazily create) the reasoning accumulator for one item. */
+    private reasoningEntry;
+    /** Compose the display snapshot for one reasoning item (content + summary). */
+    private reasoningSnapshotFor;
+    /** Receive-time stamp, aligned with the exec JSONL parse path. */
+    private now;
+}