lark-remote 0.1.5 → 0.1.7

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

@@ -0,0 +1,124 @@
+/**
+ * KimiAcpTranslator: translates ACP session/update notifications and
+ * session/request_permission server requests into AgentEvents.
+ *
+ * Per-turn stateful: accumulates text/thinking deltas, tracks tool calls,
+ * and produces turn_started events with operationKind.
+ *
+ * Wire envelope (R1, source: kimi-code packages/acp-server/src/events-map.ts,
+ * verified live 2026-08-15/16 against kimi 0.36.0):
+ *   session/update params = {sessionId, update: {sessionUpdate: '<kind>', ...}}
+ *   — the discriminator is `update.sessionUpdate`, NOT a nested `event.type`.
+ *
+ * Event mapping (design doc §4.2):
+ *   agent_message_chunk   → turn_diff text snapshot (content.text accumulation)
+ *   agent_thought_chunk   → turn_diff reasoning snapshot (content.text accumulation)
+ *   tool_call             → assistant/tool_use (rawInput object passthrough,
+ *                           string → JSON.parse fallback)
+ *   tool_call_update      → user/tool_result (status:'failed' → is_error:true)
+ *   plan / available_commands_update / session_info_update /
+ *   current_mode_update / config_option_update → discard
+ *   usage_update          → live context occupancy {used, size} →
+ *                           {total_tokens, context_limit}; NO input/output
+ *                           split exists on the wire — cumulative token stats
+ *                           fall back to wire.jsonl usage.record (dual path)
+ *   prompt stopReason:'end_turn'   → result success
+ *   prompt stopReason:'cancelled'  → result interrupted (独立终态)
+ *   prompt other stopReason/error  → result error
+ *   turn_started (self-produced)   → operationKind 'turn'/'compaction'
+ *   session/request_permission     → approval_requested
+ */
+import type { AgentEvent } from '../../types.js';
+import type { ApprovalRequestedEvent } from '../../types.js';
+/** Self-produced turn_started event (no wire equivalent — produced on prompt start). */
+export interface AcpTurnStartedEvent {
+    type: 'turn_started';
+    threadId: string;
+    turnId: string;
+    operationKind: 'turn' | 'compaction';
+    timestamp?: string;
+}
+/**
+ * Live usage snapshot from usage_update. The wire only carries context
+ * occupancy (`used`) and the model context window (`size`) — there is NO
+ * input/output token split (events-map.ts:505-516). input_tokens/output_tokens
+ * stay undefined so the bridge falls back to wire.jsonl usage.record for
+ * cumulative token stats (R1 dual path).
+ */
+export interface AcpLiveUsage {
+    total_tokens?: number;
+    context_limit?: number;
+    input_tokens?: number;
+    output_tokens?: number;
+}
+/** Usage update event for live token display. */
+export interface AcpUsageEvent {
+    type: 'usage';
+    usage: AcpLiveUsage;
+    timestamp?: string;
+}
+export type AcpTranslatorEvent = AgentEvent | AcpTurnStartedEvent | AcpUsageEvent | ApprovalRequestedEvent;
+export declare class KimiAcpTranslator {
+    /** Accumulated text per tool-call or message (keyed by a logical item id). */
+    private textByItem;
+    /** Accumulated thinking per item. */
+    private thinkingByItem;
+    /** Pending tool calls keyed by toolCallId (for matching tool_call_update). */
+    private pendingToolCalls;
+    /** Current operation kind (turn vs compact). */
+    private operationKind;
+    /** Live usage snapshot from usage_update events (context occupancy only). */
+    private liveUsage;
+    /** Whether any usage_update has been seen this turn (no update → no usage). */
+    private hasLiveUsage;
+    /** Current turn id, set by produceTurnStarted; carried on turn_diff events. */
+    private currentTurnId;
+    /**
+     * Handle a notification from the ACP server and return translated events.
+     */
+    handleNotification(method: string, params: unknown): AcpTranslatorEvent[];
+    /**
+     * Handle a server request (reverse RPC from the ACP server).
+     */
+    handleServerRequest(id: number | string, method: string, params: unknown): AcpTranslatorEvent[];
+    /**
+     * Produce a turn_started event. Called by the runner when session/prompt
+     * is sent (no wire notification for this — self-produced).
+     */
+    produceTurnStarted(sessionId: string, turnId: string): AcpTurnStartedEvent;
+    /**
+     * Translate a prompt response into a result event. Carries the live usage
+     * snapshot only when a usage_update was seen (otherwise undefined, so the
+     * bridge falls back to wire.jsonl usage.record readback).
+     */
+    handlePromptResponse(sessionId: string, result: {
+        stopReason: string;
+    }): AgentEvent;
+    /**
+     * Produce an error result event (for JSON-RPC errors during prompt).
+     */
+    produceErrorResult(sessionId: string, errorMessage: string): AgentEvent;
+    /**
+     * Set the operation kind (turn vs compact).
+     */
+    setOperationKind(kind: 'turn' | 'compact'): void;
+    private handleAgentMessageChunk;
+    private handleAgentThoughtChunk;
+    private handleToolCall;
+    private handleToolCallUpdate;
+    private handleUsageUpdate;
+    private handleRequestPermission;
+    /**
+     * Derive the approval decision list from the server's offered options.
+     * accept/decline/cancel are universal; acceptForSession requires an
+     * always-class option (kimi `approve_always`, opencode `allow_always`).
+     */
+    private deriveAvailableDecisions;
+    /**
+     * ResultEvent.usage requires input_tokens/output_tokens: number, but the
+     * ACP wire has no such split — the live snapshot is context occupancy only.
+     * Cast is deliberate: consumers must tolerate undefined input/output (the
+     * bridge's kimi path already falls back to wire.jsonl readback).
+     */
+    private liveUsageSnapshot;
+}

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

@@ -0,0 +1,336 @@
+/**
+ * KimiAcpTranslator: translates ACP session/update notifications and
+ * session/request_permission server requests into AgentEvents.
+ *
+ * Per-turn stateful: accumulates text/thinking deltas, tracks tool calls,
+ * and produces turn_started events with operationKind.
+ *
+ * Wire envelope (R1, source: kimi-code packages/acp-server/src/events-map.ts,
+ * verified live 2026-08-15/16 against kimi 0.36.0):
+ *   session/update params = {sessionId, update: {sessionUpdate: '<kind>', ...}}
+ *   — the discriminator is `update.sessionUpdate`, NOT a nested `event.type`.
+ *
+ * Event mapping (design doc §4.2):
+ *   agent_message_chunk   → turn_diff text snapshot (content.text accumulation)
+ *   agent_thought_chunk   → turn_diff reasoning snapshot (content.text accumulation)
+ *   tool_call             → assistant/tool_use (rawInput object passthrough,
+ *                           string → JSON.parse fallback)
+ *   tool_call_update      → user/tool_result (status:'failed' → is_error:true)
+ *   plan / available_commands_update / session_info_update /
+ *   current_mode_update / config_option_update → discard
+ *   usage_update          → live context occupancy {used, size} →
+ *                           {total_tokens, context_limit}; NO input/output
+ *                           split exists on the wire — cumulative token stats
+ *                           fall back to wire.jsonl usage.record (dual path)
+ *   prompt stopReason:'end_turn'   → result success
+ *   prompt stopReason:'cancelled'  → result interrupted (独立终态)
+ *   prompt other stopReason/error  → result error
+ *   turn_started (self-produced)   → operationKind 'turn'/'compaction'
+ *   session/request_permission     → approval_requested
+ */
+import { NotificationMethod, ServerRequestMethod, SessionEventType, } from '../../common/acp/protocol-types.js';
+import { getLogger } from '../../../logger/index.js';
+/**
+ * Fixed snapshot item ids: ACP has exactly one text stream and one thinking
+ * stream per turn (no itemId on the wire), so turn_diff snapshots use these
+ * stable ids for in-place block replacement.
+ */
+const TEXT_ITEM_ID = 'text';
+const THINKING_ITEM_ID = 'thinking';
+// =============================================================================
+// Translator
+// =============================================================================
+export class KimiAcpTranslator {
+    /** Accumulated text per tool-call or message (keyed by a logical item id). */
+    textByItem = new Map();
+    /** Accumulated thinking per item. */
+    thinkingByItem = new Map();
+    /** Pending tool calls keyed by toolCallId (for matching tool_call_update). */
+    pendingToolCalls = new Map();
+    /** Current operation kind (turn vs compact). */
+    operationKind = 'turn';
+    /** Live usage snapshot from usage_update events (context occupancy only). */
+    liveUsage = {};
+    /** Whether any usage_update has been seen this turn (no update → no usage). */
+    hasLiveUsage = false;
+    /** Current turn id, set by produceTurnStarted; carried on turn_diff events. */
+    currentTurnId = '';
+    /**
+     * Handle a notification from the ACP server and return translated events.
+     */
+    handleNotification(method, params) {
+        if (method !== NotificationMethod.SESSION_UPDATE) {
+            return [];
+        }
+        // R1: real envelope is {sessionId, update: {sessionUpdate: ...}}.
+        const notif = params;
+        const update = notif.update;
+        switch (update.sessionUpdate) {
+            case SessionEventType.AGENT_MESSAGE_CHUNK:
+                return this.handleAgentMessageChunk(update, notif.sessionId);
+            case SessionEventType.AGENT_THOUGHT_CHUNK:
+                return this.handleAgentThoughtChunk(update, notif.sessionId);
+            case SessionEventType.TOOL_CALL:
+                return this.handleToolCall(update, notif.sessionId);
+            case SessionEventType.TOOL_CALL_UPDATE:
+                return this.handleToolCallUpdate(update, notif.sessionId);
+            case SessionEventType.PLAN:
+                getLogger().debug(`[kimi-acp-translator] discarding plan event`);
+                return [];
+            case SessionEventType.AVAILABLE_COMMANDS_UPDATE:
+            case SessionEventType.SESSION_INFO_UPDATE:
+            case SessionEventType.CURRENT_MODE_UPDATE:
+            case SessionEventType.CONFIG_OPTION_UPDATE:
+                // Control-plane noise (command list, mode/config echoes) — not content.
+                return [];
+            case SessionEventType.USAGE_UPDATE:
+                return this.handleUsageUpdate(update);
+            default:
+                return [];
+        }
+    }
+    /**
+     * Handle a server request (reverse RPC from the ACP server).
+     */
+    handleServerRequest(id, method, params) {
+        if (method === ServerRequestMethod.REQUEST_PERMISSION) {
+            return this.handleRequestPermission(id, params);
+        }
+        return [];
+    }
+    /**
+     * Produce a turn_started event. Called by the runner when session/prompt
+     * is sent (no wire notification for this — self-produced).
+     */
+    produceTurnStarted(sessionId, turnId) {
+        this.currentTurnId = turnId;
+        return {
+            type: 'turn_started',
+            threadId: sessionId,
+            turnId,
+            operationKind: this.operationKind === 'compact' ? 'compaction' : 'turn',
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Translate a prompt response into a result event. Carries the live usage
+     * snapshot only when a usage_update was seen (otherwise undefined, so the
+     * bridge falls back to wire.jsonl usage.record readback).
+     */
+    handlePromptResponse(sessionId, result) {
+        // §4.2: cancelled is independent terminal state, must NOT merge into error
+        const subtype = result.stopReason === 'end_turn'
+            ? 'success'
+            : result.stopReason === 'cancelled'
+                ? 'interrupted'
+                : 'error';
+        return {
+            type: 'result',
+            subtype,
+            session_id: sessionId,
+            ...(this.hasLiveUsage ? { usage: this.liveUsageSnapshot() } : {}),
+            ...(subtype === 'error'
+                ? { errorMessage: `Prompt ended with stopReason: ${result.stopReason}` }
+                : {}),
+        };
+    }
+    /**
+     * Produce an error result event (for JSON-RPC errors during prompt).
+     */
+    produceErrorResult(sessionId, errorMessage) {
+        return {
+            type: 'result',
+            subtype: 'error',
+            session_id: sessionId,
+            errorMessage,
+            ...(this.hasLiveUsage ? { usage: this.liveUsageSnapshot() } : {}),
+        };
+    }
+    /**
+     * Set the operation kind (turn vs compact).
+     */
+    setOperationKind(kind) {
+        this.operationKind = kind;
+    }
+    // =========================================================================
+    // Private notification handlers
+    // =========================================================================
+    handleAgentMessageChunk(event, sessionId) {
+        // Use a stable key for the current text stream. Kimi ACP doesn't
+        // provide an itemId in agent_message_chunk; we use 'text' as the
+        // single logical text accumulator (one text stream per turn).
+        // R1: wire chunk text lives at content.text and is a DELTA
+        // (kimi-code events-map.ts assistantDeltaToSessionUpdate:
+        // content.text = event.delta), so we accumulate here into a full-text
+        // snapshot and emit it as turn_diff. The card reducer's turn_diff path
+        // REPLACES the block in place (snapshot semantics). Emitting the full
+        // text as assistant/text (delta semantics) made the reducer append the
+        // full text to itself on every chunk — duplicated card output
+        // (2026-08-17 live regression, reproduced with 3 chunks).
+        const key = 'text';
+        const prev = this.textByItem.get(key) ?? '';
+        const next = prev + event.content.text;
+        this.textByItem.set(key, next);
+        return [
+            {
+                type: 'turn_diff',
+                itemId: TEXT_ITEM_ID,
+                text: next,
+                threadId: sessionId,
+                turnId: this.currentTurnId,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleAgentThoughtChunk(event, sessionId) {
+        // Same delta→snapshot contract as handleAgentMessageChunk: accumulate
+        // wire deltas and emit a full reasoning snapshot via turn_diff so the
+        // reducer replaces the thinking block instead of appending.
+        const key = THINKING_ITEM_ID;
+        const prev = this.thinkingByItem.get(key) ?? '';
+        const next = prev + event.content.text;
+        this.thinkingByItem.set(key, next);
+        return [
+            {
+                type: 'turn_diff',
+                itemId: THINKING_ITEM_ID,
+                reasoning: next,
+                threadId: sessionId,
+                turnId: this.currentTurnId,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleToolCall(event, _sessionId) {
+        // rawInput arrives as an object on the wire; older kimi versions sent a
+        // JSON string — parse defensively in that case. The acp-server's
+        // lazy-create tool_call (first args delta, events-map.ts
+        // toolCallLazyCreateToSessionUpdate) carries NO rawInput field at all —
+        // normalize to an empty object so the card renders an empty args summary
+        // instead of crashing on undefined input (2026-08-17 live TypeError).
+        let input = event.rawInput ?? {};
+        if (typeof event.rawInput === 'string') {
+            try {
+                input = JSON.parse(event.rawInput);
+            }
+            catch {
+                // Keep raw string as-is
+            }
+        }
+        this.pendingToolCalls.set(event.toolCallId, {
+            id: event.toolCallId,
+            name: event.title,
+            input,
+        });
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: event.toolCallId,
+                            name: event.title,
+                            input,
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleToolCallUpdate(event, _sessionId) {
+        // §4.2: status:'failed' → is_error:true (fixes CLI mode's is_error always false)
+        const isError = event.status === 'failed';
+        const content = event.rawOutput ?? '';
+        return [
+            {
+                type: 'user',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: event.toolCallId,
+                            content,
+                            is_error: isError,
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleUsageUpdate(event) {
+        // R1: usage_update is {sessionUpdate:'usage_update', used, size}
+        // (events-map.ts:505-516) — context occupancy, not cumulative tokens.
+        this.liveUsage = {
+            total_tokens: event.used,
+            context_limit: event.size,
+        };
+        this.hasLiveUsage = true;
+        return [];
+    }
+    // =========================================================================
+    // Private approval handlers
+    // =========================================================================
+    handleRequestPermission(requestId, params) {
+        // §5.4: Question elicitation auto-respond cancelled
+        if (params.isQuestion || !params.toolCall) {
+            getLogger().info(`[kimi-acp-translator] question elicitation detected, auto-responding cancelled (requestId=${requestId})`);
+            return [];
+        }
+        const view = {
+            requestId,
+            kind: 'command',
+            command: params.toolCall?.title ?? undefined,
+            reason: params.toolCall?.rawInput ? truncate(params.toolCall.rawInput, 200) : undefined,
+            // §P4: 从服务端 options kind 派生——带 approve_always（或 allow_always）
+            // 才提供「本会话总是允许」（acceptForSession）；否则与旧行为一致。
+            availableDecisions: this.deriveAvailableDecisions(params),
+        };
+        return [
+            {
+                type: 'approval_requested',
+                requestId,
+                kind: 'command',
+                threadId: params.sessionId,
+                turnId: '',
+                itemId: '',
+                view,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    /**
+     * Derive the approval decision list from the server's offered options.
+     * accept/decline/cancel are universal; acceptForSession requires an
+     * always-class option (kimi `approve_always`, opencode `allow_always`).
+     */
+    deriveAvailableDecisions(params) {
+        const decisions = ['accept', 'decline', 'cancel'];
+        const hasAlwaysOption = (params.options ?? []).some((opt) => opt.kind === 'approve_always' || opt.kind === 'allow_always');
+        if (hasAlwaysOption) {
+            decisions.push('acceptForSession');
+        }
+        return decisions;
+    }
+    // =========================================================================
+    // Private helpers
+    // =========================================================================
+    /**
+     * ResultEvent.usage requires input_tokens/output_tokens: number, but the
+     * ACP wire has no such split — the live snapshot is context occupancy only.
+     * Cast is deliberate: consumers must tolerate undefined input/output (the
+     * bridge's kimi path already falls back to wire.jsonl readback).
+     */
+    liveUsageSnapshot() {
+        return { ...this.liveUsage };
+    }
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+function truncate(text, maxLen) {
+    return text.length <= maxLen ? text : text.slice(0, maxLen) + '…';
+}
+//# sourceMappingURL=translator.js.map

package/dist/runner/kimi/index.d.ts

@@ -1 +1 @@
-export { KimiRunner } from './runner.js';
+export { KimiAcpRunner } from './acp/runner.js';

package/dist/runner/kimi/index.js

@@ -1,2 +1,2 @@
-export { KimiRunner } from './runner.js';
+export { KimiAcpRunner } from './acp/runner.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+export { OpencodeAcpRunner, type OpencodeAcpRunnerOptions } from './runner.js';

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

@@ -0,0 +1,2 @@
+export { OpencodeAcpRunner } from './runner.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,121 @@
+/**
+ * OpencodeAcpRunner: workspace-lifetime runner using opencode's ACP mode
+ * (`opencode acp`, JSON-RPC over stdio). Registered as the opencode agent's
+ * runner.
+ *
+ * Flow per run: acquire persistent connection → session/new or session/resume
+ * → synthetic init → session/prompt → consume session/update notifications
+ * until prompt settles → result event.
+ *
+ * Structurally aligned with KimiAcpRunner via the shared ConnectionBasedRunner
+ * base (same notification queue + waitResolve pattern, same forceFinish/
+ * stopRequested semantics, same turn idle timeout, same ConnectionLostError
+ * retry). Differences from kimi:
+ * - session/set_mode applies the configured mode (build/plan; default 'build'
+ *   keeps manual approvals flowing); opencode sends no set_mode notification,
+ *   so the client refreshes the local mode view itself
+ * - no wire.jsonl compaction polling (opencode /compact is synchronous:
+ *   service.ts:555-571 summarize completes before the prompt response)
+ * - text/thinking go to the assistant incremental channel (opencode wire
+ *   deltas), not turn_diff snapshots
+ */
+import type { AgentKind, AgentSessionReader, AgentEvent, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import { JsonRpcClient } from '../../common/jsonrpc/client.js';
+import { type OpencodeAcpTranslatorEvent } from './translator.js';
+import { ConnectionBasedRunner } from '../../common/connection-based-runner.js';
+export interface OpencodeAcpRunnerOptions {
+    kind: AgentKind;
+    sessionReader: AgentSessionReader;
+    /** Path to the opencode binary. Defaults to `opencode`. */
+    binary?: string;
+    /** Environment variables. */
+    env?: Record<string, string | undefined>;
+    /** Args to spawn the ACP server with. Defaults to `['acp']`. Note: no
+     *  explicit `--cwd` — opencode acp defaults --cwd to the process cwd, which
+     *  the transport already sets to the workspace (cli/cmd/acp.ts:13-17). */
+    acpArgs?: string[];
+    /** Request timeout in milliseconds. */
+    requestTimeoutMs?: number;
+    /** Idle TTL for connection manager. */
+    idleTtlMs?: number;
+    /** How long to wait for turn output before failing. Defaults to 10 min. */
+    turnIdleTimeoutMs?: number;
+    model?: string;
+    /** Configured session mode: 'build' (default) or 'plan' (opencode agent names). */
+    mode?: 'build' | 'plan';
+}
+export declare class OpencodeAcpRunner extends ConnectionBasedRunner<JsonRpcClient, OpencodeAcpTranslatorEvent> {
+    private connectionManager;
+    private currentTranslator;
+    private activeSessionId;
+    private model?;
+    /** Configured session mode applied via session/set_mode (§P5). */
+    private configuredMode;
+    /** Current session mode id, parsed from session/new|resume configOptions. */
+    private currentModeId?;
+    /** Current model value (`provider/model`), parsed from configOptions. */
+    private currentModelValue?;
+    /** Pending approval requests: requestId → kind + view + options. */
+    private pendingApprovals;
+    /** Tracker for the in-flight prompt request — needed for cancellation. */
+    private promptSettled;
+    /** Whether the prompt request has been fired (distinguishes "stop before
+     *  prompt sent" from "stop while prompt in-flight" — the latter sends
+     *  session/cancel immediately). */
+    private promptSent;
+    constructor(opts: OpencodeAcpRunnerOptions);
+    protected get logTag(): string;
+    protected get turnTimeoutErrorMessage(): string;
+    protected get turnInterruptedErrorMessage(): string;
+    protected currentSessionId(): string | null;
+    protected shouldDeferStop(): boolean;
+    protected cancelCurrentTurn(): Promise<void>;
+    protected clearTurnState(): void;
+    protected releaseConnection(cwd: string): Promise<void>;
+    protected notifyIdle(cwd: string): void;
+    protected disposeConnections(): Promise<void>;
+    /**
+     * Run a compact operation on the current session.
+     *
+     * opencode special-cases the `/compact` text prompt server-side
+     * (service.ts:555-571): it runs session.summarize synchronously and the
+     * prompt response settles only after compaction completes — no background
+     * record polling needed (unlike kimi).
+     */
+    runCompact(_message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
+    /**
+     * Respond to an approval server request. `response` is the bridge
+     * ApprovalAction (`{ action: 'accept' | 'decline' | 'cancel' }`).
+     */
+    respondApproval(requestId: number | string, response: unknown): Promise<void>;
+    getStatusInfo(): AgentStatusInfo;
+    /**
+     * Hot-apply a mode change to the live ACP session (§P5).
+     *
+     * opencode's session/set_mode sends no notification — the client refreshes
+     * the local mode view itself. The local mode is always updated so
+     * `getStatusInfo()` (and therefore `/s`) reflects the new value
+     * immediately; when a session is connected, also re-sends session/set_mode
+     * so the running session picks up the new mode without waiting for the
+     * runner to be evicted/recreated. Failure is non-fatal: the next setupTurn
+     * re-applies the cached mode when it differs from the session's current
+     * mode.
+     */
+    updateApprovalMode(settings: {
+        mode?: 'build' | 'plan';
+    }): Promise<void>;
+    /**
+     * Acquire the connection and set up the turn:
+     * session/new (new session) or session/resume (existing sessionId)
+     * → session/prompt.
+     */
+    protected setupTurn(message: string, opts: SpawnOptions): Promise<void>;
+    /**
+     * Track the current session mode and model from a session/new|resume
+     * result's configOptions (opencode buildModeSelectOption/buildModelSelectOption:
+     * {id, category, currentValue}).
+     */
+    private trackConfigOptions;
+    private handleNotification;
+    private handleServerRequest;
+}