lark-remote 0.1.6 → 0.1.7

package/dist/runner/codex/argv.js

@@ -1,40 +0,0 @@
-/**
- * Builds `codex exec` command-line arguments.
- *
- * Key design decisions:
- * - `approval_policy="never"` eliminates the approval handshake (root cause ①).
- * - Prompt goes via stdin (`-` flag) to avoid argv escaping issues.
- * - `--skip-git-repo-check`: lark-remote's cwd may not be a git repo.
- * - User's `~/.codex/config.toml` and project rules are preserved
- *   (no `--ignore-user-config` / `--ignore-rules`).
- */
-/**
- * Construct the argv array for `codex exec --json`.
- *
- * New session:
- *   `codex exec --json --sandbox danger-full-access -c approval_policy="never" ... -`
- * Resume session:
- *   `codex exec --sandbox danger-full-access ... resume --json <threadId> -`
- */
-export function buildCodexExecArgs(input) {
-    const sandbox = 'danger-full-access';
-    const globalFlags = [
-        '--sandbox',
-        sandbox,
-        '-c',
-        'approval_policy="never"',
-        '-c',
-        'shell_environment_policy.inherit="all"',
-        '--skip-git-repo-check',
-        '-C',
-        input.cwd,
-        ...(input.model ? ['-m', input.model] : []),
-        ...(input.modelProvider ? ['-c', `model_provider="${input.modelProvider}"`] : []),
-        ...(input.reasoningEffort ? ['-c', `model_reasoning_effort="${input.reasoningEffort}"`] : []),
-    ];
-    if (input.threadId) {
-        return ['exec', ...globalFlags, 'resume', '--json', input.threadId, '-'];
-    }
-    return ['exec', '--json', ...globalFlags, '-'];
-}
-//# sourceMappingURL=argv.js.map

package/dist/runner/codex/factory.d.ts

@@ -1,29 +0,0 @@
-/**
- * Codex runner factory: selects the concrete runner based on `serviceMode`.
- *
- * `exec` (default) → CodexExecRunner (spawn-per-message `codex exec`).
- * `app-server` → CodexAppServerRunner (persistent `codex app-server` JSON-RPC
- * connection with approval support and sandbox enforcement).
- */
-import type { AgentSessionReader } from '../types.js';
-import { CodexExecRunner } from './runner.js';
-import { CodexAppServerRunner } from './app-server/runner.js';
-import type { AskForApproval, SandboxMode } from './app-server/protocol-types.js';
-export interface CreateCodexRunnerOptions {
-    model?: string;
-    modelProvider?: string;
-    reasoningEffort?: string;
-    stopGraceMs?: number;
-    pidDir: string;
-    workspace: string;
-    sessionReader: AgentSessionReader;
-    serviceMode?: 'exec' | 'app-server';
-    sandbox?: SandboxMode;
-    approvalPolicy?: AskForApproval;
-    appServerBinary?: string;
-    appServerArgs?: string[];
-    appServerRequestTimeoutMs?: number;
-    appServerIdleTtlMs?: number;
-    appServerTurnIdleTimeoutMinutes?: number;
-}
-export declare function createCodexRunner(opts: CreateCodexRunnerOptions): CodexExecRunner | CodexAppServerRunner;

package/dist/runner/codex/factory.js

@@ -1,39 +0,0 @@
-/**
- * Codex runner factory: selects the concrete runner based on `serviceMode`.
- *
- * `exec` (default) → CodexExecRunner (spawn-per-message `codex exec`).
- * `app-server` → CodexAppServerRunner (persistent `codex app-server` JSON-RPC
- * connection with approval support and sandbox enforcement).
- */
-import { CodexExecRunner } from './runner.js';
-import { CodexAppServerRunner } from './app-server/runner.js';
-export function createCodexRunner(opts) {
-    if (opts.serviceMode === 'app-server') {
-        return new CodexAppServerRunner({
-            kind: 'codex',
-            sessionReader: opts.sessionReader,
-            binary: opts.appServerBinary ?? 'codex',
-            appServerArgs: opts.appServerArgs,
-            requestTimeoutMs: opts.appServerRequestTimeoutMs,
-            idleTtlMs: opts.appServerIdleTtlMs,
-            turnTimeoutMs: opts.appServerTurnIdleTimeoutMinutes != null
-                ? opts.appServerTurnIdleTimeoutMinutes * 60_000
-                : undefined,
-            model: opts.model,
-            modelProvider: opts.modelProvider,
-            reasoningEffort: opts.reasoningEffort,
-            sandbox: opts.sandbox,
-            approvalPolicy: opts.approvalPolicy,
-        });
-    }
-    return new CodexExecRunner({
-        model: opts.model,
-        modelProvider: opts.modelProvider,
-        reasoningEffort: opts.reasoningEffort,
-        stopGraceMs: opts.stopGraceMs,
-        pidDir: opts.pidDir,
-        workspace: opts.workspace,
-        sessionReader: opts.sessionReader,
-    });
-}
-//# sourceMappingURL=factory.js.map

package/dist/runner/codex/jsonl.d.ts

@@ -1,37 +0,0 @@
-/**
- * Translates codex `exec --json` ndjson output into lark-remote `AgentEvent`s.
- *
- * Key design decisions:
- * - Fail-fast: unknown types and missing fields return [] (no event emitted),
- *   never throw, never write back to codex (root cause ② tolerance).
- * - Stream ending before a terminal event records a terminal error via `finish()`
- *   (root cause ③ fail-fast); the runner's `buildResultEvent` emits the result.
- * - Each `run()` must create a new translator instance (stateful: sessionId/terminal/startedTools).
- *
- * Terminal state (sessionId, lastUsage, terminalErrorMessage) is stored on
- * the instance and exposed via getters; `CodexExecRunner.run()` folds this
- * state into `SpawningRunner.buildResultEvent(...)` so result-event
- * semantics are uniform across all 5 agents.
- *
- * Two jsonl formats exist; this translator handles
- * the `codex exec --json` stdout format ONLY. The rollout file format is handled
- * separately by `codex-rollout-reader.ts`.
- */
-import type { AgentEvent, ResultEvent } from '../types.js';
-import { ExecTranslator } from '../common/exec-translator.js';
-type ResultUsage = NonNullable<ResultEvent['usage']>;
-export declare class CodexExecTranslator extends ExecTranslator {
-    protected readonly logTag = "[codex-exec-translator]";
-    protected streamEndedMessage(): string;
-    /** Token usage captured from `turn.completed` (for the success result event). */
-    getLastUsage: () => ResultUsage | undefined;
-    protected translateEvent(raw: Record<string, unknown>): AgentEvent[] | null;
-    private onThreadStarted;
-    private onItemStarted;
-    private onItemCompleted;
-    private onAgentMessage;
-    private onTurnCompleted;
-    private onTerminalError;
-    private onNonTerminalError;
-}
-export {};

package/dist/runner/codex/jsonl.js

@@ -1,221 +0,0 @@
-/**
- * Translates codex `exec --json` ndjson output into lark-remote `AgentEvent`s.
- *
- * Key design decisions:
- * - Fail-fast: unknown types and missing fields return [] (no event emitted),
- *   never throw, never write back to codex (root cause ② tolerance).
- * - Stream ending before a terminal event records a terminal error via `finish()`
- *   (root cause ③ fail-fast); the runner's `buildResultEvent` emits the result.
- * - Each `run()` must create a new translator instance (stateful: sessionId/terminal/startedTools).
- *
- * Terminal state (sessionId, lastUsage, terminalErrorMessage) is stored on
- * the instance and exposed via getters; `CodexExecRunner.run()` folds this
- * state into `SpawningRunner.buildResultEvent(...)` so result-event
- * semantics are uniform across all 5 agents.
- *
- * Two jsonl formats exist; this translator handles
- * the `codex exec --json` stdout format ONLY. The rollout file format is handled
- * separately by `codex-rollout-reader.ts`.
- */
-import { getLogger } from '../../logger/index.js';
-import { recordValue, stringValue, numberValue, extractErrorMessage } from '../../common/guards.js';
-import { ExecTranslator } from '../common/exec-translator.js';
-export class CodexExecTranslator extends ExecTranslator {
-    logTag = '[codex-exec-translator]';
-    streamEndedMessage() {
-        return 'codex stream ended before a terminal event';
-    }
-    // --- translateEvent: codex-specific dispatch ---
-    translateEvent(raw) {
-        switch (raw.type) {
-            case 'thread.started':
-                return this.onThreadStarted(raw);
-            case 'turn.started':
-                return []; // internal marker, no lark-remote event
-            case 'item.started':
-                return this.onItemStarted(raw);
-            case 'item.completed':
-                return this.onItemCompleted(raw);
-            case 'agent_message':
-                return this.onAgentMessage(raw);
-            case 'turn.completed':
-                return this.onTurnCompleted(raw);
-            case 'turn.failed':
-                return this.onTerminalError(raw, 'codex turn failed');
-            case 'error':
-                return this.onNonTerminalError(raw);
-            default:
-                return this.recordUnknownEvent(raw.type);
-        }
-    }
-    // --- Private handlers ---
-    onThreadStarted(raw) {
-        const threadId = stringValue(raw.thread_id);
-        if (!threadId) {
-            return [];
-        }
-        this.sessionId = threadId;
-        return [
-            {
-                type: 'system',
-                subtype: 'init',
-                session_id: threadId,
-                cwd: stringValue(raw.cwd) ?? '',
-                model: stringValue(raw.model) ?? '',
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-    onItemStarted(raw) {
-        const item = recordValue(raw.item);
-        if (!item || item.type !== 'command_execution')
-            return [];
-        const id = stringValue(item.id);
-        if (!id) {
-            return [];
-        }
-        this.startedTools.add(id);
-        return [
-            {
-                type: 'assistant',
-                message: {
-                    content: [
-                        {
-                            type: 'tool_use',
-                            id,
-                            name: 'command_execution',
-                            input: { command: stringValue(item.command) ?? '' },
-                        },
-                    ],
-                },
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-    onItemCompleted(raw) {
-        const item = recordValue(raw.item);
-        if (!item)
-            return [];
-        // agent_message → assistant text
-        if (item.type === 'agent_message') {
-            const text = stringValue(item.text ?? item.message);
-            if (!text)
-                return [];
-            return [
-                {
-                    type: 'assistant',
-                    message: {
-                        content: [{ type: 'text', text }],
-                    },
-                    timestamp: new Date().toISOString(),
-                },
-            ];
-        }
-        // reasoning → thinking content, so output.showThinking
-        // applies to codex the same way it does for claude/pi/opencode.
-        // Shape: {"type":"item.completed","item":{"id":"item_1","type":"reasoning","text":"..."}}
-        if (item.type === 'reasoning') {
-            const text = stringValue(item.text);
-            if (!text)
-                return [];
-            return [
-                {
-                    type: 'assistant',
-                    message: {
-                        content: [{ type: 'thinking', thinking: text }],
-                    },
-                    timestamp: new Date().toISOString(),
-                },
-            ];
-        }
-        // command_execution → tool result
-        if (item.type === 'command_execution') {
-            const id = stringValue(item.id);
-            if (!id) {
-                return [];
-            }
-            this.startedTools.delete(id);
-            const exitCode = numberValue(item.exit_code);
-            const output = stringValue(item.output ?? item.aggregated_output ?? item.stdout) ?? '';
-            return [
-                {
-                    type: 'user',
-                    message: {
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: id,
-                                content: output,
-                                is_error: exitCode !== undefined && exitCode !== 0,
-                            },
-                        ],
-                    },
-                    timestamp: new Date().toISOString(),
-                },
-            ];
-        }
-        return [];
-    }
-    onAgentMessage(raw) {
-        const message = stringValue(raw.message ?? raw.text);
-        if (!message)
-            return [];
-        return [
-            {
-                type: 'assistant',
-                message: {
-                    content: [{ type: 'text', text: message }],
-                },
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-    onTurnCompleted(raw) {
-        // mark terminal and stash usage; the runner emits the result event
-        // via buildResultEvent({...usage}) so success/error is uniform across agents.
-        this.terminal = true;
-        const usage = recordValue(raw.usage);
-        if (usage) {
-            // ccusage-aligned: for codex, cached_input_tokens is a subset of
-            // input_tokens, so the non-cached (displayed) input = raw - cached.
-            // Codex has no separate cache-write, so cache_creation is always 0.
-            const rawInput = numberValue(usage.input_tokens ?? usage.inputTokens) ?? 0;
-            const cached = numberValue(usage.cached_input_tokens ?? usage.cachedInputTokens) ?? 0;
-            const total = numberValue(usage.total_tokens ?? usage.totalTokens);
-            this.lastUsage = {
-                input_tokens: rawInput - Math.min(cached, rawInput),
-                output_tokens: numberValue(usage.output_tokens ?? usage.outputTokens) ?? 0,
-                cache_read_tokens: cached,
-                cache_creation_tokens: 0,
-                ...(total !== undefined ? { total_tokens: total } : {}),
-            };
-        }
-        return [];
-    }
-    onTerminalError(raw, fallback) {
-        // mark terminal and stash the error message; the runner folds it
-        // into buildResultEvent({translatorError}) so the result subtype is 'error'
-        // with the agent-specific reason (e.g. codex turn.failed).
-        this.terminal = true;
-        this.terminalErrorMessage = extractErrorMessage(raw, fallback);
-        this.terminalErrorFromAgent = true;
-        return [];
-    }
-    onNonTerminalError(raw) {
-        const message = extractErrorMessage(raw, 'codex error');
-        this.lastError = message;
-        getLogger().warn(`[codex-exec-translator] non-terminal error: ${message.slice(0, 500)}`);
-        // 将非终止错误作为 assistant 文本输出，让用户在 Run 卡片上看到进度
-        // （如 404/401 重连、provider 不匹配等错误），而非静默等待。
-        return [
-            {
-                type: 'assistant',
-                message: {
-                    content: [{ type: 'text', text: `⚠️ ${message}` }],
-                },
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-}
-//# sourceMappingURL=jsonl.js.map

package/dist/runner/codex/runner.d.ts

@@ -1,66 +0,0 @@
-/**
- * CodexExecRunner: spawn-per-message runner using `codex exec --json`.
- *
- * Architecture:
- * - Each `run()` spawns a fresh `codex exec` process, writes prompt to stdin,
- *   reads ndjson from stdout, translates to AgentEvent via CodexExecTranslator.
- * - No singleton, no long-lived process, no JSON-RPC, no approval handshake.
- * - Structurally identical to ClaudeRunner (spawn-per-message + ProcessStopper + SpawnHeartbeat).
- *
- * The entire spawn + completion + cleanup orchestration is inherited
- * from SpawningRunner. This subclass overrides only the 5 hooks:
- *   - getStdio()              → ['pipe','pipe','pipe'] (writes prompt to stdin)
- *   - setupStdin(proc, msg)   → proc.stdin.end(msg, 'utf-8')
- *   - handleBadStreamLine()   → empty override (silently skip non-JSON lines)
- *   - createTranslator(opts)  → new CodexExecTranslator()
- *   - validateBeforeRun(opts) → API key check (yields error result if missing)
- *
- * Key invariants:
- * 1. argv includes `approval_policy="never"` (root cause ①).
- * 2. stdin is written once via `stdin.end(prompt)` and never written again (root cause ②).
- * 3. Translator parse failures → return [] (no event), never throw, never write back (root cause ②).
- * 4. Stream ending early → finish() yields terminal event, never leaves consumer waiting (root cause ③).
- */
-import type { ChildProcess } from 'node:child_process';
-import type { AgentKind, AgentSessionReader, AgentEvent, AgentRunner, AgentStatusInfo } from '../types.js';
-import type { SpawnOptions } from '../types.js';
-import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
-interface CodexExecRunnerOptions {
-    /** Model override. Omitted → codex reads from its config.toml. */
-    model?: string;
-    /** Model provider override. Omitted → codex reads from its config.toml. */
-    modelProvider?: string;
-    /** Reasoning effort level: low/medium/high/xhigh/max/ultra */
-    reasoningEffort?: string;
-    /** Grace period (ms) for SIGTERM→SIGKILL. Default: 5000. */
-    stopGraceMs?: number;
-    /** Directory for pid files. Default: `~/.lark-remote`. */
-    pidDir?: string;
-    /** Workspace identifier, scoped into the pid file name so concurrent
-     *  workspaces do not share one `<prefix>.pid` (P1-9). */
-    workspace: string;
-    /** Spawn heartbeat interval (ms). Default: 30_000. */
-    spawnHeartbeatMs?: number;
-    /** Injected session reader (file-based CodexSessionReader). */
-    sessionReader: AgentSessionReader;
-}
-export declare class CodexExecRunner extends SpawningRunner implements AgentRunner {
-    readonly kind: AgentKind;
-    readonly sessionReader: AgentSessionReader;
-    private readonly defaultModel?;
-    private readonly modelProvider?;
-    private readonly reasoningEffort?;
-    constructor(opts: CodexExecRunnerOptions);
-    getStatusInfo(): AgentStatusInfo;
-    /** exec 模式的 turn.completed.usage 是会话累计值，flow 字段必须 jsonl 优先
-     *  （review P3-7：桥侧统一走本接口，替代 agentKind 硬编码）。 */
-    getUsageAuthority(): 'jsonl';
-    protected buildArgv(opts: SpawnOptions): string[];
-    protected getStdio(): ('ignore' | 'pipe')[];
-    protected setupStdin(proc: ChildProcess, message: string): void;
-    /** Silently skip non-JSON lines from codex stdout (e.g. warnings). */
-    protected handleBadStreamLine(_line: string): void;
-    protected createTranslator(_opts: SpawnOptions): RunnerTranslator;
-    protected validateBeforeRun(opts: SpawnOptions): AgentEvent | null;
-}
-export {};

package/dist/runner/codex/runner.js

@@ -1,129 +0,0 @@
-/**
- * CodexExecRunner: spawn-per-message runner using `codex exec --json`.
- *
- * Architecture:
- * - Each `run()` spawns a fresh `codex exec` process, writes prompt to stdin,
- *   reads ndjson from stdout, translates to AgentEvent via CodexExecTranslator.
- * - No singleton, no long-lived process, no JSON-RPC, no approval handshake.
- * - Structurally identical to ClaudeRunner (spawn-per-message + ProcessStopper + SpawnHeartbeat).
- *
- * The entire spawn + completion + cleanup orchestration is inherited
- * from SpawningRunner. This subclass overrides only the 5 hooks:
- *   - getStdio()              → ['pipe','pipe','pipe'] (writes prompt to stdin)
- *   - setupStdin(proc, msg)   → proc.stdin.end(msg, 'utf-8')
- *   - handleBadStreamLine()   → empty override (silently skip non-JSON lines)
- *   - createTranslator(opts)  → new CodexExecTranslator()
- *   - validateBeforeRun(opts) → API key check (yields error result if missing)
- *
- * Key invariants:
- * 1. argv includes `approval_policy="never"` (root cause ①).
- * 2. stdin is written once via `stdin.end(prompt)` and never written again (root cause ②).
- * 3. Translator parse failures → return [] (no event), never throw, never write back (root cause ②).
- * 4. Stream ending early → finish() yields terminal event, never leaves consumer waiting (root cause ③).
- */
-import { SpawningRunner } from '../common/spawning-runner.js';
-import { pipeAllStdio, endStdinWithPrompt } from '../common/runner-utils.js';
-import { buildCodexExecArgs } from './argv.js';
-import { CodexExecTranslator } from './jsonl.js';
-import { loadCodexConfig } from '../../config/codex-config.js';
-export class CodexExecRunner extends SpawningRunner {
-    kind = 'codex';
-    sessionReader;
-    defaultModel;
-    modelProvider;
-    reasoningEffort;
-    constructor(opts) {
-        super({
-            pidDir: opts.pidDir,
-            workspace: opts.workspace,
-            stopGraceMs: opts.stopGraceMs,
-            spawnHeartbeatMs: opts.spawnHeartbeatMs,
-            pidFilePrefix: 'codex',
-            logTag: 'codex-exec-runner',
-        });
-        this.binary = 'codex';
-        this.defaultModel = opts.model;
-        this.modelProvider = opts.modelProvider;
-        this.reasoningEffort = opts.reasoningEffort;
-        this.sessionReader = opts.sessionReader;
-    }
-    getStatusInfo() {
-        // If model not explicitly set, fallback to codex config.toml
-        let model = this.defaultModel;
-        let provider = this.modelProvider;
-        if (!model || !provider) {
-            try {
-                const codexConfig = loadCodexConfig();
-                if (!model) {
-                    model = codexConfig.currentModel;
-                }
-                if (!provider) {
-                    provider = codexConfig.currentProvider;
-                }
-            }
-            catch {
-                // Ignore errors reading codex config
-            }
-        }
-        return {
-            kind: 'codex',
-            model: model ?? '(未配置)',
-            provider: provider,
-            extras: { sandbox: 'danger-full-access' },
-        };
-    }
-    /** exec 模式的 turn.completed.usage 是会话累计值，flow 字段必须 jsonl 优先
-     *  （review P3-7：桥侧统一走本接口，替代 agentKind 硬编码）。 */
-    getUsageAuthority() {
-        return 'jsonl';
-    }
-    buildArgv(opts) {
-        return buildCodexExecArgs({
-            cwd: opts.cwd,
-            model: opts.model ?? this.defaultModel,
-            modelProvider: this.modelProvider,
-            threadId: opts.sessionId,
-            reasoningEffort: opts.reasoningEffort ?? this.reasoningEffort,
-        });
-    }
-    // --- Hooks ---
-    getStdio() {
-        // ['pipe','pipe','pipe'] so we can write the prompt to stdin via setupStdin.
-        return pipeAllStdio();
-    }
-    setupStdin(proc, message) {
-        // Write prompt once and close (invariant: write once, never again).
-        endStdinWithPrompt(proc, message);
-    }
-    /** Silently skip non-JSON lines from codex stdout (e.g. warnings). */
-    handleBadStreamLine(_line) { }
-    createTranslator(_opts) {
-        // Fresh translator per run (stateful: threadId/terminal/startedTools).
-        return new CodexExecTranslator();
-    }
-    validateBeforeRun(opts) {
-        // Pre-spawn API key check: yield an error result and abort run() if the
-        // configured provider requires an env var that is not set.
-        const provider = this.modelProvider;
-        if (!provider)
-            return null;
-        try {
-            const codexConfig = loadCodexConfig();
-            const envKey = codexConfig.providerEnvKeys[provider];
-            if (envKey && !process.env[envKey]) {
-                return {
-                    type: 'result',
-                    subtype: 'error',
-                    session_id: opts.sessionId ?? '',
-                    errorMessage: `Provider "${provider}" 需要环境变量 ${envKey}，但该变量未设置。请在系统环境变量或 .env 文件中配置。`,
-                    timestamp: new Date().toISOString(),
-                };
-            }
-        }
-        catch {
-            // Ignore config read errors — let codex handle the missing config.
-        }
-        return null;
-    }
-}
-//# sourceMappingURL=runner.js.map

package/dist/runner/common/exec-translator.d.ts

@@ -1,73 +0,0 @@
-/**
- * Abstract base class for exec-stream translators (codex, opencode, pi, kimi).
- *
- * Encapsulates the shared state machine and guard logic that was duplicated
- * across every concrete translator:
- *   - Terminal-state tracking (idempotent `finish()`)
- *   - `translate()` guard (terminal → []; non-record / non-string-type → anomaly)
- *   - `recordUnknownEvent()` helper (warn-logs unknown event types)
- *   - Session / usage / error getters
- *
- * Subclasses provide:
- *   - `logTag` — prefix for warn logs
- *   - `streamEndedMessage()` — agent-specific "stream ended early" message
- *   - `translateEvent(raw)` — agent-specific event dispatch
- *
- * @see SpawningRunner for the runner that consumes translators
- */
-import type { AgentEvent, ResultEvent } from '../types.js';
-/** Why the stream ended without a natural terminal event. */
-type ExecFinishReason = 'failed' | 'interrupted' | 'timeout';
-export declare abstract class ExecTranslator {
-    protected terminal: boolean;
-    protected lastError: string | undefined;
-    protected lastUsage: NonNullable<ResultEvent['usage']> | undefined;
-    protected terminalErrorMessage: string | undefined;
-    protected terminalErrorFromAgent: boolean;
-    protected sessionId: string | undefined;
-    protected readonly startedTools: Set<string>;
-    /** Log prefix, e.g. `'[codex-exec-translator]'`. */
-    protected abstract readonly logTag: string;
-    /** Human-readable message when the stream ends before a terminal event. */
-    protected abstract streamEndedMessage(): string;
-    /** Agent-specific event dispatch. Called only for valid records with a string `type`. */
-    protected abstract translateEvent(raw: Record<string, unknown>): AgentEvent[] | null;
-    /** Translate a single parsed ndjson line into zero or more `AgentEvent`s.
-     *  P3-3: filter paths (terminal / non-record / non-string-type) return `null`
-     *  instead of `[]` to avoid a throwaway array allocation per non-emitting
-     *  event on codex/opencode hot paths. The consumer (SpawningRunner) already
-     *  handles `null` via `Array.isArray` + null guards. */
-    translate(raw: unknown): AgentEvent[] | null;
-    /** Warn-log an unknown event type and return `null` (P3-3: no throwaway []). */
-    protected recordUnknownEvent(type: string): AgentEvent[] | null;
-    /**
-     * Called when the stream ends without a natural terminal event.
-     *
-     * - Marks the translator terminal (idempotent — second call returns `[]`).
-     * - For `reason='failed'`, stores `terminalErrorMessage` so the runner can
-     *   surface it via `buildResultEvent({translatorError})`.
-     * - Returns `[]` — the runner is responsible for emitting the result event.
-     */
-    finish(reason?: ExecFinishReason): AgentEvent[];
-    /** Whether a terminal event has already been seen. */
-    isTerminal(): boolean;
-    /** Session ID captured from the agent stream (for the result event). */
-    getSessionId(): string | undefined;
-    /** Token usage captured from the terminal event (for the success result event). */
-    getLastUsage(): NonNullable<ResultEvent['usage']> | undefined;
-    /**
-     * Terminal error message captured from an agent-reported error or
-     * `finish('failed')`. Returns `undefined` if no terminal error occurred.
-     */
-    getTerminalError(): string | undefined;
-    /**
-     * True iff `getTerminalError()` was populated by an agent-reported terminal
-     * error (e.g. codex `turn.failed`). The runner uses this to pick the correct
-     * root cause for `buildResultEvent`: agent errors override signal/non-zero-code
-     * (the agent error is the root cause), but stream-ended-early errors
-     * (`finish('failed')`) yield to signal/non-zero-code (the signal is the root
-     * cause and the early stream-end is a symptom).
-     */
-    hasAgentTerminalError(): boolean;
-}
-export {};