@osdlc/agent-call 0.0.1-stage → 0.4.1

package/dist/adapters/codex.js

@@ -0,0 +1,374 @@
+import { CONVERSATION_SCHEMA, } from '../conversation.js';
+import { note, TMP_TOKEN } from '../plan.js';
+import { applyPermissionMode, asNumber, asString, buildEffectivePrompt, get, modelFlag, parseJsonLines, tryParseJson, } from './shared.js';
+const LAST_MESSAGE_FILE = 'last-message.txt';
+const SCHEMA_FILE = 'output-schema.json';
+/**
+ * OpenAI Codex CLI (`codex exec`). Sandbox modes map cleanly onto the
+ * canonical permission postures; structured output is native via
+ * `--output-schema`; tool-level rules are not expressible.
+ */
+export function codexAdapter(options = {}) {
+    const binary = options.binary ?? 'codex';
+    return {
+        name: 'codex',
+        binary,
+        plan(spec) {
+            return planCodex(binary, spec);
+        },
+        parseResult(planned, raw) {
+            return parseCodex(planned, raw);
+        },
+        toConversation(planned, raw) {
+            return codexConversation(planned, raw);
+        },
+    };
+}
+/**
+ * `-c model_reasoning_effort="<level>"`, quoted as codex's TOML override
+ * expects. The level passes through as given; which levels a model takes
+ * is the caller's to know (`codex debug models` lists them).
+ */
+export function codexEffortArgv(effort) {
+    return ['-c', `model_reasoning_effort="${effort}"`];
+}
+function planCodex(binary, spec) {
+    const notes = [];
+    const tempFiles = [];
+    const argv = [binary, 'exec'];
+    const session = spec.session;
+    const resuming = session?.resume !== undefined || session?.continueLast === true;
+    if (resuming) {
+        argv.push('resume');
+        if (session?.resume !== undefined)
+            argv.push(session.resume);
+        else
+            argv.push('--last');
+        note(notes, session?.resume !== undefined ? 'session.resume' : 'session.continueLast', 'native', 'codex exec resume');
+    }
+    if (session?.id !== undefined) {
+        note(notes, 'session.id', 'dropped', 'codex assigns thread ids itself');
+    }
+    if (session?.persist === false) {
+        argv.push('--ephemeral');
+        note(notes, 'session.persist', 'native', '--ephemeral');
+    }
+    // Requested format → CLI reality: `--json` is a JSONL event stream, so it
+    // backs both "json" (we aggregate) and "stream-json" (events exposed).
+    const format = spec.output?.format ?? 'json';
+    if (format !== 'text') {
+        argv.push('--json');
+        if (format === 'json') {
+            note(notes, 'output.format', 'approximated', 'codex emits JSONL events; aggregated into a single result');
+        }
+    }
+    else {
+        note(notes, 'output.format', 'approximated', 'codex text output interleaves progress logs; final answer read from --output-last-message');
+    }
+    // Clean final answer regardless of format.
+    argv.push('--output-last-message', `${TMP_TOKEN}/${LAST_MESSAGE_FILE}`);
+    tempFiles.push({ name: LAST_MESSAGE_FILE, content: '', readBack: true });
+    argv.push('--color', 'never');
+    // The canonical spec is directory-driven, not git-driven; don't refuse
+    // to run in non-repo working directories.
+    argv.push('--skip-git-repo-check');
+    if (spec.model !== undefined)
+        argv.push(...modelFlag(spec.model));
+    if (spec.effort !== undefined) {
+        argv.push(...codexEffortArgv(spec.effort));
+        note(notes, 'effort', 'native', `model_reasoning_effort="${spec.effort}"`);
+    }
+    if (spec.mcp?.servers !== undefined) {
+        for (const [name, server] of Object.entries(spec.mcp.servers)) {
+            for (const [key, value] of Object.entries(server)) {
+                if (value === null || value === undefined)
+                    continue;
+                argv.push('-c', `mcp_servers.${name}.${key}=${toToml(value)}`);
+            }
+        }
+        note(notes, 'mcp.servers', 'approximated', 'rendered as -c mcp_servers.* config overrides');
+        if (spec.mcp.strict === true) {
+            note(notes, 'mcp.strict', 'dropped', 'codex has no ignore-other-servers flag; overrides merge with config.toml');
+        }
+    }
+    const permissions = spec.permissions;
+    applyPermissionMode(argv, notes, permissions?.mode, {
+        'read-only': {
+            argv: ['--sandbox', 'read-only'],
+            support: 'native',
+            detail: '--sandbox read-only',
+        },
+        edits: {
+            argv: ['--sandbox', 'workspace-write'],
+            support: 'approximated',
+            detail: 'edits mapped to --sandbox workspace-write (also permits workspace commands)',
+        },
+        'full-auto': {
+            argv: ['--sandbox', 'workspace-write'],
+            support: 'native',
+            detail: '--sandbox workspace-write',
+        },
+        bypass: {
+            argv: ['--dangerously-bypass-approvals-and-sandbox'],
+            support: 'native',
+            detail: '--dangerously-bypass-approvals-and-sandbox',
+        },
+    });
+    if ((permissions?.allowTools ?? []).length > 0) {
+        note(notes, 'permissions.allowTools', 'dropped', 'codex has no per-tool allow rules; use permissions.mode');
+    }
+    if ((permissions?.denyTools ?? []).length > 0) {
+        note(notes, 'permissions.denyTools', 'dropped', 'codex has no per-tool deny rules; use permissions.mode');
+    }
+    for (const dir of spec.context?.dirs ?? []) {
+        argv.push('--add-dir', dir);
+    }
+    if ((spec.context?.dirs ?? []).length > 0) {
+        note(notes, 'context.dirs', 'native', '--add-dir');
+    }
+    if (spec.output?.schema !== undefined) {
+        tempFiles.push({
+            name: SCHEMA_FILE,
+            content: JSON.stringify(spec.output.schema),
+        });
+        argv.push('--output-schema', `${TMP_TOKEN}/${SCHEMA_FILE}`);
+        note(notes, 'output.schema', 'native', '--output-schema');
+    }
+    if (spec.plugins !== undefined) {
+        note(notes, 'plugins', 'dropped', 'session-only plugins are claude only');
+    }
+    if (spec.budgetUsd !== undefined) {
+        note(notes, 'budgetUsd', 'dropped', 'codex has no budget cap flag');
+    }
+    argv.push(...(spec.extraArgs ?? []));
+    const prompt = buildEffectivePrompt(spec, { schemaNative: true }, notes);
+    // `-` reads the prompt from stdin — avoids argv length limits.
+    argv.push('-');
+    return {
+        agent: 'codex',
+        argv,
+        stdin: prompt,
+        env: { ...spec.env },
+        cwd: spec.cwd,
+        outputFormat: format,
+        tempFiles,
+        notes,
+        spec,
+    };
+}
+/** Render a JSON value as a TOML literal for `-c key=value` overrides. */
+function toToml(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(toToml).join(', ')}]`;
+    }
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .map(([k, v]) => `${k} = ${toToml(v)}`)
+            .join(', ');
+        return `{${entries}}`;
+    }
+    return JSON.stringify(value);
+}
+function parseCodex(planned, raw) {
+    const lastMessage = raw.files?.[LAST_MESSAGE_FILE]?.trim();
+    if (planned.outputFormat === 'text') {
+        const text = lastMessage !== undefined && lastMessage !== '' ? lastMessage : raw.stdout.trim();
+        return withStructured(planned, { text });
+    }
+    const events = parseJsonLines(raw.stdout);
+    let text = lastMessage ?? '';
+    let answered = lastMessage !== undefined && lastMessage !== '';
+    let sessionId;
+    let usage;
+    let errorDetail;
+    let turnFailed = false;
+    for (const event of events) {
+        const type = get(event, 'type');
+        if (type === 'thread.started') {
+            sessionId = asString(get(event, 'thread_id'));
+        }
+        else if (type === 'turn.completed') {
+            usage = codexUsage(get(event, 'usage'));
+        }
+        else if (type === 'turn.failed') {
+            turnFailed = true;
+            errorDetail = asString(get(event, 'error', 'message')) ?? errorDetail ?? 'turn failed';
+        }
+        else if (type === 'item.completed') {
+            const item = get(event, 'item');
+            const itemType = get(item, 'item_type') ?? get(item, 'type');
+            if (itemType === 'agent_message') {
+                const itemText = asString(get(item, 'text'));
+                if (itemText !== undefined) {
+                    text = itemText;
+                    answered = true;
+                }
+            }
+            else if (itemType === 'error') {
+                errorDetail = asString(get(item, 'message'));
+            }
+        }
+        else if (type === 'error') {
+            errorDetail = asString(get(event, 'message')) ?? 'codex reported an error';
+        }
+        else {
+            // Legacy event shape: {"id": ..., "msg": {"type": "agent_message", ...}}
+            const msgType = get(event, 'msg', 'type');
+            if (msgType === 'agent_message') {
+                const legacyText = asString(get(event, 'msg', 'message'));
+                if (legacyText !== undefined) {
+                    text = legacyText;
+                    answered = true;
+                }
+            }
+            else if (msgType === 'token_count') {
+                usage = codexUsage(get(event, 'msg', 'info', 'total_token_usage')) ?? usage;
+            }
+            else if (msgType === 'error') {
+                errorDetail = asString(get(event, 'msg', 'message'));
+            }
+        }
+    }
+    // codex emits warning-level `error` items (e.g. config deprecations) on
+    // runs that still answer; only fail when the turn failed or nothing came back.
+    const isError = turnFailed || (errorDetail !== undefined && !answered);
+    return withStructured(planned, {
+        text,
+        sessionId,
+        usage,
+        events,
+        isError,
+        errorDetail,
+    });
+}
+function withStructured(planned, parsed) {
+    if (planned.spec.output?.schema !== undefined && parsed.text !== '') {
+        parsed.structured = tryParseJson(parsed.text);
+    }
+    return parsed;
+}
+function codexUsage(usage) {
+    if (usage === null || typeof usage !== 'object')
+        return undefined;
+    return {
+        inputTokens: asNumber(get(usage, 'input_tokens')),
+        outputTokens: asNumber(get(usage, 'output_tokens')),
+        cacheReadTokens: asNumber(get(usage, 'cached_input_tokens')),
+    };
+}
+function codexConversation(planned, raw) {
+    const parsed = parseCodex(planned, raw);
+    const messages = [
+        { role: 'user', parts: [{ type: 'text', text: planned.stdin ?? '' }] },
+    ];
+    for (const event of parsed.events ?? []) {
+        if (get(event, 'type') !== 'item.completed')
+            continue;
+        const item = get(event, 'item');
+        const itemType = get(item, 'item_type') ?? get(item, 'type');
+        if (itemType === 'agent_message') {
+            const text = asString(get(item, 'text'));
+            if (text !== undefined) {
+                messages.push({ role: 'assistant', parts: [{ type: 'text', text }] });
+            }
+        }
+        else if (itemType === 'reasoning') {
+            const text = asString(get(item, 'text'));
+            if (text !== undefined) {
+                messages.push({ role: 'assistant', parts: [{ type: 'reasoning', text }] });
+            }
+        }
+        else if (itemType === 'command_execution') {
+            const callId = asString(get(item, 'id'));
+            messages.push({
+                role: 'assistant',
+                parts: [
+                    {
+                        type: 'tool-call',
+                        callId,
+                        name: 'shell',
+                        input: { command: get(item, 'command') },
+                    },
+                ],
+            });
+            messages.push({
+                role: 'tool',
+                parts: [
+                    {
+                        type: 'tool-result',
+                        callId,
+                        name: 'shell',
+                        output: {
+                            output: get(item, 'aggregated_output'),
+                            exitCode: get(item, 'exit_code'),
+                        },
+                        isError: asNumber(get(item, 'exit_code')) !== 0,
+                    },
+                ],
+            });
+        }
+        else if (itemType === 'file_change') {
+            messages.push({
+                role: 'assistant',
+                parts: [
+                    {
+                        type: 'tool-call',
+                        callId: asString(get(item, 'id')),
+                        name: 'apply_patch',
+                        input: { changes: get(item, 'changes') },
+                    },
+                ],
+            });
+        }
+        else if (itemType === 'mcp_tool_call') {
+            messages.push({
+                role: 'assistant',
+                parts: [
+                    {
+                        type: 'tool-call',
+                        callId: asString(get(item, 'id')),
+                        name: asString(get(item, 'tool')) ?? 'mcp',
+                        input: get(item, 'arguments'),
+                    },
+                ],
+            });
+        }
+        else if (itemType === 'web_search') {
+            messages.push({
+                role: 'assistant',
+                parts: [
+                    {
+                        type: 'tool-call',
+                        callId: asString(get(item, 'id')),
+                        name: 'web_search',
+                        input: { query: get(item, 'query') },
+                    },
+                ],
+            });
+        }
+    }
+    // No events (text format): still record the final answer.
+    if (messages.length === 1 && parsed.text !== '') {
+        messages.push({
+            role: 'assistant',
+            parts: [{ type: 'text', text: parsed.text }],
+        });
+    }
+    return {
+        schema: CONVERSATION_SCHEMA,
+        agent: 'codex',
+        sessionId: parsed.sessionId,
+        messages,
+        usage: parsed.usage,
+        stopReason: parsed.isError === true ? 'error' : undefined,
+        raw: {
+            format: 'codex/jsonl',
+            data: (parsed.events?.length ?? 0) > 0 ? parsed.events : raw.stdout,
+        },
+    };
+}

package/dist/adapters/custom.d.ts

@@ -0,0 +1,31 @@
+import type { AgentCallSpec } from '../spec.js';
+import type { AgentAdapter, ParsedOutput } from './types.js';
+/** Options for {@link customAdapter}. */
+export interface CustomAdapterOptions {
+    /** Adapter name, reported as `PlannedCall.agent`. */
+    name: string;
+    /** Binary to spawn. */
+    binary: string;
+    /**
+     * Build the args (after the binary) for a spec. The effective prompt —
+     * spec.prompt with context/system/schema folded in — is provided so simple
+     * CLIs get the emulation layer for free. Place it in the returned args, or
+     * set `promptVia: 'stdin'` to send it on stdin instead. Whatever `args`
+     * throws propagates out of planning.
+     */
+    args: (spec: AgentCallSpec, effectivePrompt: string) => string[];
+    /** How the prompt travels. Default: `"argv"` (your `args` must place it). */
+    promptVia?: 'argv' | 'stdin';
+    /**
+     * Optional custom parse; default returns trimmed stdout as text. If it
+     * throws, `callAgent` resolves `ok: false` with reason `agent-error`.
+     */
+    parse?: (stdout: string, stderr: string) => ParsedOutput;
+}
+/**
+ * Escape hatch for agents this package has no adapter for: aider, goose,
+ * anything with a one-shot CLI. Context, system prompt and schema are folded
+ * into the prompt, and `permissions.mode` is noted as dropped. Any other spec
+ * field is the `args` builder's to handle; it is not noted if left out.
+ */
+export declare function customAdapter(options: CustomAdapterOptions): AgentAdapter;

package/dist/adapters/custom.js

@@ -0,0 +1,42 @@
+import { note } from '../plan.js';
+import { buildEffectivePrompt } from './shared.js';
+/**
+ * Escape hatch for agents this package has no adapter for: aider, goose,
+ * anything with a one-shot CLI. Context, system prompt and schema are folded
+ * into the prompt, and `permissions.mode` is noted as dropped. Any other spec
+ * field is the `args` builder's to handle; it is not noted if left out.
+ */
+export function customAdapter(options) {
+    return {
+        name: options.name,
+        binary: options.binary,
+        plan(spec) {
+            const notes = [];
+            const effectivePrompt = buildEffectivePrompt(spec, {}, notes);
+            if (spec.permissions?.mode !== undefined) {
+                note(notes, 'permissions.mode', 'dropped', `custom adapter "${options.name}" defines no permission mapping`);
+            }
+            const argv = [
+                options.binary,
+                ...options.args(spec, effectivePrompt),
+                ...(spec.extraArgs ?? []),
+            ];
+            return {
+                agent: options.name,
+                argv,
+                stdin: options.promptVia === 'stdin' ? effectivePrompt : undefined,
+                env: { ...spec.env },
+                cwd: spec.cwd,
+                outputFormat: spec.output?.format ?? 'text',
+                tempFiles: [],
+                notes,
+                spec,
+            };
+        },
+        parseResult(_planned, raw) {
+            if (options.parse)
+                return options.parse(raw.stdout, raw.stderr);
+            return { text: raw.stdout.trim() };
+        },
+    };
+}

package/dist/adapters/opencode.d.ts

@@ -0,0 +1,12 @@
+import type { AgentAdapter } from './types.js';
+/** Options for {@link opencodeAdapter}. */
+export interface OpencodeAdapterOptions {
+    /** Binary to spawn. Default: the CLI's own name. */
+    binary?: string;
+}
+/**
+ * opencode (`opencode run`). Context files attach natively (`-f`);
+ * permissions travel via the OPENCODE_PERMISSION env JSON; `--format json`
+ * is a raw event stream backing both json and stream-json requests.
+ */
+export declare function opencodeAdapter(options?: OpencodeAdapterOptions): AgentAdapter;

package/dist/adapters/opencode.js

@@ -0,0 +1,207 @@
+import { CONVERSATION_SCHEMA, } from '../conversation.js';
+import { note } from '../plan.js';
+import { asString, buildEffectivePrompt, get, parseJsonLines, tryParseJson } from './shared.js';
+/**
+ * opencode (`opencode run`). Context files attach natively (`-f`);
+ * permissions travel via the OPENCODE_PERMISSION env JSON; `--format json`
+ * is a raw event stream backing both json and stream-json requests.
+ */
+export function opencodeAdapter(options = {}) {
+    const binary = options.binary ?? 'opencode';
+    return {
+        name: 'opencode',
+        binary,
+        plan(spec) {
+            return planOpencode(binary, spec);
+        },
+        parseResult(planned, raw) {
+            return parseOpencode(planned, raw);
+        },
+        toConversation(planned, raw) {
+            return opencodeConversation(planned, raw);
+        },
+    };
+}
+const PERMISSION_ENV = {
+    'read-only': { edit: 'deny', bash: 'deny', webfetch: 'allow' },
+    edits: { edit: 'allow', bash: 'deny', webfetch: 'allow' },
+    'full-auto': { edit: 'allow', bash: 'allow', webfetch: 'allow' },
+    bypass: { edit: 'allow', bash: 'allow', webfetch: 'allow' },
+};
+function planOpencode(binary, spec) {
+    const notes = [];
+    const env = { ...spec.env };
+    const argv = [binary, 'run'];
+    const format = spec.output?.format ?? 'json';
+    if (format !== 'text') {
+        argv.push('--format', 'json');
+        if (format === 'json') {
+            note(notes, 'output.format', 'approximated', 'opencode emits raw JSON events; aggregated into a single result');
+        }
+    }
+    if (spec.model !== undefined) {
+        argv.push('--model', spec.model);
+        if (!spec.model.includes('/')) {
+            note(notes, 'model', 'approximated', 'opencode expects "provider/model"; passed through as given');
+        }
+    }
+    if (spec.effort !== undefined) {
+        argv.push('--variant', spec.effort);
+        note(notes, 'effort', 'approximated', '--variant (provider-specific reasoning effort; values depend on the model)');
+    }
+    if (spec.mcp?.servers !== undefined) {
+        note(notes, 'mcp.servers', 'dropped', 'opencode takes MCP servers from opencode.json, not a flag');
+    }
+    const permissions = spec.permissions;
+    if (permissions?.mode !== undefined && permissions.mode !== 'default') {
+        env['OPENCODE_PERMISSION'] = JSON.stringify(PERMISSION_ENV[permissions.mode]);
+        note(notes, 'permissions.mode', 'approximated', `mapped to OPENCODE_PERMISSION=${env['OPENCODE_PERMISSION']} ("ask" would hang a headless run, so gated tools are denied)`);
+    }
+    if ((permissions?.allowTools ?? []).length > 0) {
+        note(notes, 'permissions.allowTools', 'dropped', 'no CLI flag; use permission patterns in opencode.json');
+    }
+    if ((permissions?.denyTools ?? []).length > 0) {
+        note(notes, 'permissions.denyTools', 'dropped', 'no CLI flag; use permission patterns in opencode.json');
+    }
+    for (const file of spec.context?.files ?? []) {
+        argv.push('--file', file);
+    }
+    if ((spec.context?.files ?? []).length > 0) {
+        note(notes, 'context.files', 'native', '--file attachments');
+    }
+    if ((spec.context?.dirs ?? []).length > 0) {
+        note(notes, 'context.dirs', 'dropped', 'opencode scopes to its working directory; no add-dir flag');
+    }
+    const session = spec.session;
+    if (session?.resume !== undefined) {
+        argv.push('--session', session.resume);
+        note(notes, 'session.resume', 'native', '--session');
+    }
+    else if (session?.continueLast === true) {
+        argv.push('--continue');
+        note(notes, 'session.continueLast', 'native', '--continue');
+    }
+    if (session?.id !== undefined) {
+        note(notes, 'session.id', 'dropped', 'opencode assigns session ids itself');
+    }
+    if (session?.persist === false) {
+        note(notes, 'session.persist', 'dropped', 'opencode always persists sessions');
+    }
+    if (spec.plugins !== undefined) {
+        note(notes, 'plugins', 'dropped', 'session-only plugins are claude only');
+    }
+    if (spec.budgetUsd !== undefined) {
+        note(notes, 'budgetUsd', 'dropped', 'opencode has no budget cap flag');
+    }
+    argv.push(...(spec.extraArgs ?? []));
+    const prompt = buildEffectivePrompt(spec, { filesNative: true }, notes);
+    argv.push(prompt);
+    return {
+        agent: 'opencode',
+        argv,
+        env,
+        cwd: spec.cwd,
+        prompt,
+        outputFormat: format,
+        tempFiles: [],
+        notes,
+        spec,
+    };
+}
+function parseOpencode(planned, raw) {
+    if (planned.outputFormat === 'text') {
+        const parsed = { text: raw.stdout.trim() };
+        if (planned.spec.output?.schema !== undefined) {
+            parsed.structured = tryParseJson(parsed.text);
+        }
+        return parsed;
+    }
+    const events = parseJsonLines(raw.stdout);
+    const textByPart = new Map();
+    let sessionId;
+    let errorDetail;
+    let order = 0;
+    for (const event of events) {
+        // Both shapes seen in the wild: a bare part object, or an event wrapping
+        // one at `properties.part` / `part`.
+        const part = get(event, 'properties', 'part') ?? get(event, 'part') ?? event;
+        const partType = get(part, 'type');
+        if (partType === 'text') {
+            const text = asString(get(part, 'text'));
+            const id = asString(get(part, 'id')) ?? `#${order++}`;
+            if (text !== undefined)
+                textByPart.set(id, text);
+            sessionId = asString(get(part, 'sessionID')) ?? asString(get(part, 'sessionId')) ?? sessionId;
+        }
+        else if (partType === 'error' || get(event, 'type') === 'error') {
+            errorDetail =
+                asString(get(part, 'message')) ??
+                    asString(get(event, 'properties', 'message')) ??
+                    'opencode reported an error';
+        }
+    }
+    const text = [...textByPart.values()].join('\n').trim();
+    const parsed = {
+        text,
+        sessionId,
+        events,
+        isError: errorDetail !== undefined,
+        errorDetail,
+    };
+    if (planned.spec.output?.schema !== undefined && text !== '') {
+        parsed.structured = tryParseJson(text);
+    }
+    return parsed;
+}
+function opencodeConversation(planned, raw) {
+    const parsed = parseOpencode(planned, raw);
+    const prompt = planned.prompt ?? '';
+    const messages = [
+        { role: 'user', parts: [{ type: 'text', text: prompt }] },
+    ];
+    const assistantParts = [];
+    for (const event of parsed.events ?? []) {
+        const part = get(event, 'properties', 'part') ?? get(event, 'part') ?? event;
+        const partType = get(part, 'type');
+        if (partType === 'tool') {
+            assistantParts.push({
+                type: 'tool-call',
+                callId: asString(get(part, 'callID')) ?? asString(get(part, 'id')),
+                name: asString(get(part, 'tool')) ?? 'unknown',
+                input: get(part, 'state', 'input'),
+            });
+            const output = get(part, 'state', 'output');
+            if (output !== undefined) {
+                assistantParts.push({
+                    type: 'tool-result',
+                    callId: asString(get(part, 'callID')) ?? asString(get(part, 'id')),
+                    name: asString(get(part, 'tool')) ?? undefined,
+                    output,
+                    isError: get(part, 'state', 'status') === 'error',
+                });
+            }
+        }
+        else if (partType === 'reasoning') {
+            const text = asString(get(part, 'text'));
+            if (text !== undefined)
+                assistantParts.push({ type: 'reasoning', text });
+        }
+    }
+    if (parsed.text !== '') {
+        assistantParts.push({ type: 'text', text: parsed.text });
+    }
+    if (assistantParts.length > 0) {
+        messages.push({ role: 'assistant', parts: assistantParts });
+    }
+    return {
+        schema: CONVERSATION_SCHEMA,
+        agent: 'opencode',
+        sessionId: parsed.sessionId,
+        messages,
+        stopReason: parsed.isError === true ? 'error' : undefined,
+        raw: {
+            format: 'opencode/json-events',
+            data: (parsed.events?.length ?? 0) > 0 ? parsed.events : raw.stdout,
+        },
+    };
+}