@amalgm/chat 0.1.0

package/dist/normalizers/opencode.js

@@ -0,0 +1,640 @@
+/**
+ * OpenCode normalizer — engine `chat-core/normalizers/opencode.js` (552
+ * lines) ported byte-exact. The engine module calls the event constructors
+ * directly; here the pure helpers (`suffixPrefixOverlap`,
+ * `openCodeErrorMessage`, `usageFromOpenCodeTokens`) are module-level
+ * exports and everything that constructs events lives behind
+ * `createOpenCodeNormalizer(events)` (axiom 7: the host injects the clock
+ * via {@link EventConstructors}).
+ *
+ * Streaming laws preserved verbatim:
+ * - per-part delta dedup via suffix-prefix overlap (`appendOpenCodeDelta`);
+ * - snapshot merges keep the longer prefix-compatible text
+ *   (`mergeOpenCodeSnapshot`);
+ * - cross-part assistant-text dedup with the 40/80-char thresholds and the
+ *   80% overlap ratio (`dedupeOpenCodeAssistantText`);
+ * - per-step usage from `step-finish` parts and internal
+ *   compaction/continuation usage from `message.updated`.
+ */
+import { mcpMetadataFromName, normalizeError, stringifyResult, summarizeToolOutput, summarizeToolRequest, titleForTool, toolKind, } from '../transcript/index.js';
+import { normalizeUsage } from '../usage/index.js';
+/** Engine opencode.js:8-9 — cross-part dedup thresholds. */
+const CROSS_PART_DEDUPE_MIN_CHARS = 40;
+const CROSS_PART_OVERLAP_MIN_CHARS = 80;
+/**
+ * Engine opencode.js:11-29. OpenCode step tokens
+ * (`{input, output, reasoning, cache:{read, write}}`) -> normalized usage.
+ * `output` includes reasoning (thought tokens ride inside output), `exact`
+ * is always true, source `'opencode_sdk'`.
+ */
+export function usageFromOpenCodeTokens(tokens, cost, contextLimit, operation = 'chat_step') {
+    const inputTokens = Number(tokens?.['input'] || 0);
+    const cacheReadTokens = Number(tokens?.['cache']?.read || 0);
+    const cacheWriteTokens = Number(tokens?.['cache']?.write || 0);
+    const thoughtTokens = Number(tokens?.['reasoning'] || 0);
+    const outputTokens = Number(tokens?.['output'] || 0) + thoughtTokens;
+    return normalizeUsage({
+        inputTokens,
+        outputTokens,
+        thoughtTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        contextLimit,
+        costUsd: cost,
+        operation,
+        source: 'opencode_sdk',
+        exact: true,
+    });
+}
+/** Engine opencode.js:31-44. Nested-error unwrap chain, JSON fallback. */
+export function openCodeErrorMessage(err, fallback = 'OpenCode session error') {
+    const e = err;
+    if (!e)
+        return fallback;
+    if (typeof e === 'string')
+        return e;
+    if (e['data']?.message)
+        return e['data'].message;
+    if (e['data']?.error?.message)
+        return e['data'].error.message;
+    if (e['cause']?.message)
+        return e['cause'].message;
+    if (e['message'])
+        return e['message'];
+    if (e['name'])
+        return e['name'];
+    try {
+        return JSON.stringify(e);
+    }
+    catch {
+        return fallback;
+    }
+}
+/** Engine opencode.js:46-48. */
+function openCodeRequestId(prefix, id) {
+    return `${prefix}_${String(id || 'unknown')}`;
+}
+/** Engine opencode.js:50-52. */
+function eventRaw(type, payload) {
+    return { raw: { source: 'opencode.sdk.event', method: type || 'unknown', payload } };
+}
+/** Engine opencode.js:54-59. */
+function commonPrefixLength(a = '', b = '') {
+    const max = Math.min(a.length, b.length);
+    let index = 0;
+    while (index < max && a[index] === b[index])
+        index += 1;
+    return index;
+}
+/**
+ * Engine opencode.js:61-67. Longest length such that `text` ends with the
+ * first `length` chars of `delta` — the overlap-dedup primitive.
+ */
+export function suffixPrefixOverlap(text = '', delta = '') {
+    const max = Math.min(text.length, delta.length);
+    for (let length = max; length > 0; length -= 1) {
+        if (text.endsWith(delta.slice(0, length)))
+            return length;
+    }
+    return 0;
+}
+/** Engine opencode.js:69-77. Snapshot merge: longer prefix-compatible text wins. */
+function mergeOpenCodeSnapshot(previousText = '', nextText = '') {
+    const latestText = previousText.length > nextText.length && previousText.startsWith(nextText)
+        ? previousText
+        : nextText;
+    return {
+        latestText,
+        deltaToEmit: latestText.slice(commonPrefixLength(previousText, latestText)),
+    };
+}
+/** Engine opencode.js:79-85. Delta append with suffix-prefix overlap trim. */
+function appendOpenCodeDelta(previousText = '', delta = '') {
+    const deltaToEmit = delta.slice(suffixPrefixOverlap(previousText, delta));
+    return {
+        nextText: `${previousText}${deltaToEmit}`,
+        deltaToEmit,
+    };
+}
+/** Engine opencode.js:87-105. Cross-part dedup: 40-char full-tail drop, 80-char / 80% overlap trim. */
+function dedupeOpenCodeAssistantText(state, text = '') {
+    if (!text)
+        return '';
+    const aggregate = String(state.assistantTextAggregate || '');
+    let emitText = text;
+    if (emitText.length >= CROSS_PART_DEDUPE_MIN_CHARS && aggregate.endsWith(emitText)) {
+        emitText = '';
+    }
+    else {
+        const overlap = suffixPrefixOverlap(aggregate, emitText);
+        const mostlyDuplicate = emitText.length >= CROSS_PART_DEDUPE_MIN_CHARS &&
+            overlap > 0 &&
+            (overlap >= CROSS_PART_OVERLAP_MIN_CHARS || overlap / emitText.length >= 0.8);
+        if (mostlyDuplicate)
+            emitText = emitText.slice(overlap);
+    }
+    if (emitText)
+        state.assistantTextAggregate = `${aggregate}${emitText}`;
+    return emitText;
+}
+/** Engine opencode.js:107-114. */
+function openCodeToolDetail(part) {
+    const toolName = part?.['tool'] || 'unknown';
+    const status = part?.['state']?.status;
+    if (status === 'completed' || status === 'error') {
+        return summarizeToolOutput(part?.['state']?.output ?? part?.['state']?.error ?? '');
+    }
+    return summarizeToolRequest(toolName, part?.['state']?.input || {}, part?.['state']?.title || '');
+}
+/** Engine opencode.js:116-121. */
+function openCodeToolData(part) {
+    return {
+        tool: part?.['tool'] || 'unknown',
+        state: part?.['state'] || {},
+    };
+}
+/** Engine opencode.js:123-141. `state.metadata.sessionId` marks subagent tools; `tool === 'task'` always does. */
+function openCodeToolMetadata(part) {
+    const toolName = part?.['tool'] || 'unknown';
+    const metadata = {
+        providerTool: toolName,
+        providerStatus: part?.['state']?.status,
+        ...mcpMetadataFromName(toolName),
+    };
+    const stateMetadata = part?.['state']?.metadata;
+    if (stateMetadata && typeof stateMetadata === 'object') {
+        Object.assign(metadata, stateMetadata);
+        if (stateMetadata.sessionId) {
+            metadata['childSessionId'] = stateMetadata.sessionId;
+            metadata['subagent'] = true;
+        }
+    }
+    if (part?.['tool'] === 'task')
+        metadata['subagent'] = true;
+    if (part?.['state']?.title)
+        metadata['title'] = part['state'].title;
+    return metadata;
+}
+/** Engine opencode.js:143-146. */
+function openCodeToolError(part) {
+    if (part?.['state']?.status !== 'error')
+        return undefined;
+    return normalizeError(part?.['state']?.error || part?.['state']?.output || 'Tool failed');
+}
+/** Engine opencode.js:148-160. */
+function openCodeToolTitle(part) {
+    const toolName = part?.['tool'] || 'unknown';
+    const input = part?.['state']?.input || {};
+    const metadata = openCodeToolMetadata(part);
+    return titleForTool({
+        name: toolName,
+        input,
+        output: part?.['state']?.output,
+        error: part?.['state']?.error,
+        metadata,
+        fallback: part?.['state']?.title || toolName,
+    });
+}
+/** Engine opencode.js:162-168. */
+function stopReasonFromOpenCodeFinish(finish) {
+    if (finish === 'length')
+        return 'max_tokens';
+    if (finish === 'content_filter')
+        return 'content_filter';
+    if (finish === 'error')
+        return 'error';
+    if (finish === 'stop')
+        return 'end_turn';
+    return null;
+}
+/** Engine opencode.js:170-173. */
+function pendingParts(state) {
+    if (!state.pendingParts)
+        state.pendingParts = new Map();
+    return state.pendingParts;
+}
+/** Engine opencode.js:175-178. */
+function messageRoles(state) {
+    if (!state.messageRoles)
+        state.messageRoles = new Map();
+    return state.messageRoles;
+}
+/** Engine opencode.js:180-183. */
+function compactionContinuationMessages(state) {
+    if (!state.compactionContinuationMessageIds)
+        state.compactionContinuationMessageIds = new Set();
+    return state.compactionContinuationMessageIds;
+}
+/** Engine opencode.js:185-187. */
+function rememberCompactionContinuation(part, state) {
+    if (part?.['messageID'])
+        compactionContinuationMessages(state).add(part['messageID']);
+}
+/** Engine opencode.js:189-193. Compaction runs + their continuation prompts bill internally. */
+function isOpenCodeInternalUsage(info, state) {
+    if (!info || info['sessionID'] !== state.providerSessionId || info['role'] !== 'assistant')
+        return false;
+    if (info['mode'] === 'compaction' || info['agent'] === 'compaction')
+        return true;
+    return Boolean(info['parentID'] && state.compactionContinuationMessageIds?.has(info['parentID']));
+}
+/** Engine opencode.js:195-206. Text/reasoning deltas fold into the cached part snapshot. */
+function cachePendingPart(part, state, delta) {
+    if (!part?.['id'])
+        return;
+    const cache = pendingParts(state);
+    const previous = cache.get(part['id'])?.part || part;
+    const next = { ...previous, ...part };
+    if (typeof delta === 'string' && (part['type'] === 'text' || part['type'] === 'reasoning')) {
+        const base = String(previous['text'] || part['text'] || '');
+        const merged = appendOpenCodeDelta(base, delta);
+        next['text'] = merged.nextText;
+    }
+    cache.set(part['id'], { part: next, delta: undefined });
+}
+/** Engine opencode.js:208-213. */
+function dropPendingParts(messageId, state) {
+    const cache = pendingParts(state);
+    for (const [partId, entry] of [...cache.entries()]) {
+        if (entry.part?.['messageID'] === messageId)
+            cache.delete(partId);
+    }
+}
+/** Engine opencode.js:338-344. Current-turn assistant filter: parent + creation-time gates. */
+function isOurAssistant(info, state) {
+    if (!info || info['sessionID'] !== state.providerSessionId || info['role'] !== 'assistant')
+        return false;
+    if (state.userMessageId && info['parentID'] && info['parentID'] !== state.userMessageId)
+        return false;
+    const created = Number(info['time']?.created || 0);
+    if (state.turnStartedAt && created && created < state.turnStartedAt)
+        return false;
+    return true;
+}
+/**
+ * Build the OpenCode normalizer over injected event constructors — the
+ * engine functions verbatim, closed over `events` instead of the ambient
+ * `require('../events')` module.
+ */
+export function createOpenCodeNormalizer(events) {
+    const { compactionFinished, compactionStarted, done, errorEvent, reasoningDelta, textDelta, toolCompleted, toolStarted, toolUpdated, usageFinal, warningEvent, } = events;
+    /** Engine opencode.js:215-224. */
+    function flushPendingParts(messageId, state) {
+        const cache = pendingParts(state);
+        const flushed = [];
+        for (const [partId, entry] of [...cache.entries()]) {
+            if (entry.part?.['messageID'] !== messageId)
+                continue;
+            cache.delete(partId);
+            flushed.push(...normalizeOpenCodePart(entry.part, state, entry.delta));
+        }
+        return flushed;
+    }
+    /** Engine opencode.js:226-336. One part (streamed or snapshot) -> amalgm events. */
+    function normalizeOpenCodePart(partInput, state, delta) {
+        const part = partInput;
+        if (!part || part['sessionID'] !== state.providerSessionId)
+            return [];
+        if (part['type'] === 'compaction') {
+            if (part['tail_start_id'])
+                return [];
+            if (!state.compactionsStarted)
+                state.compactionsStarted = new Set();
+            const compactionId = part['id'] || part['messageID'] || 'opencode-compaction';
+            if (state.compactionsStarted.has(compactionId))
+                return [];
+            state.compactionsStarted.add(compactionId);
+            return [compactionStarted({
+                    providerSessionId: state.providerSessionId,
+                    trigger: part['auto'] === false ? 'manual' : 'auto',
+                    ...eventRaw('part/compaction', part),
+                })];
+        }
+        if (!state.assistantMessageIds.has(part['messageID']))
+            return [];
+        if (part['id'] && part['type']) {
+            if (!state.partTypes)
+                state.partTypes = new Map();
+            state.partTypes.set(part['id'], part['type']);
+        }
+        if (part['metadata']?.compaction_continue) {
+            rememberCompactionContinuation(part, state);
+            return [];
+        }
+        const seen = state.partText.get(part['id']) || '';
+        if (part['type'] === 'text') {
+            const merged = typeof delta === 'string'
+                ? appendOpenCodeDelta(seen, delta)
+                : mergeOpenCodeSnapshot(seen, String(part['text'] || ''));
+            const text = dedupeOpenCodeAssistantText(state, merged['deltaToEmit']);
+            state.partText.set(part['id'], merged['latestText'] || merged['nextText'] || `${seen}${text}`);
+            return text ? [textDelta(text, { providerSessionId: state.providerSessionId, ts: part['time']?.start, ...eventRaw(`part/${part['type']}`, part) })] : [];
+        }
+        if (part['type'] === 'reasoning') {
+            const merged = typeof delta === 'string'
+                ? appendOpenCodeDelta(seen, delta)
+                : mergeOpenCodeSnapshot(seen, String(part['text'] || ''));
+            const text = merged['deltaToEmit'];
+            state.partText.set(part['id'], merged['latestText'] || merged['nextText'] || `${seen}${text}`);
+            return text ? [reasoningDelta(text, { providerSessionId: state.providerSessionId, ts: part['time']?.start, ...eventRaw(`part/${part['type']}`, part) })] : [];
+        }
+        if (part['type'] === 'tool') {
+            const toolId = part['callID'] || part['id'];
+            const status = part['state']?.status;
+            const toolName = part['tool'] || 'unknown';
+            const input = part['state']?.input || {};
+            const metadata = openCodeToolMetadata(part);
+            const title = openCodeToolTitle(part);
+            const kind = toolKind(toolName, input, metadata);
+            const timing = part['state']?.time || part['time'];
+            if (status === 'pending' || status === 'running') {
+                const detail = openCodeToolDetail(part);
+                if (state.toolsStarted.has(toolId)) {
+                    return [toolUpdated(toolId, {
+                            providerSessionId: state.providerSessionId,
+                            toolName,
+                            title,
+                            kind,
+                            detail,
+                            inputDelta: input,
+                            status: 'in_progress',
+                            metadata,
+                            timing,
+                            data: openCodeToolData(part),
+                            ...eventRaw('part/tool', part),
+                        })];
+                }
+                state.toolsStarted.add(toolId);
+                return [toolStarted(toolId, {
+                        providerSessionId: state.providerSessionId,
+                        toolName,
+                        title,
+                        kind,
+                        detail,
+                        input,
+                        ts: part['state']?.time?.start,
+                        metadata,
+                        timing,
+                        data: openCodeToolData(part),
+                        ...eventRaw('part/tool', part),
+                    })];
+            }
+            if ((status === 'completed' || status === 'error') && !state.toolsCompleted.has(toolId)) {
+                state.toolsCompleted.add(toolId);
+                const output = part['state']?.output ?? part['state']?.error ?? '';
+                const detail = openCodeToolDetail(part);
+                return [toolCompleted(toolId, {
+                        providerSessionId: state.providerSessionId,
+                        toolName,
+                        title,
+                        kind,
+                        detail,
+                        input,
+                        output,
+                        result: stringifyResult(output),
+                        isError: status === 'error',
+                        error: openCodeToolError(part),
+                        ts: part['state']?.time?.end,
+                        metadata,
+                        timing,
+                        data: openCodeToolData(part),
+                        ...eventRaw('part/tool', part),
+                    })];
+            }
+        }
+        if (part['type'] === 'step-finish') {
+            const stopReason = stopReasonFromOpenCodeFinish(part['reason']);
+            if (stopReason)
+                state.pendingStopReason = stopReason;
+            return [usageFinal(usageFromOpenCodeTokens(part['tokens'], part['cost'], state.contextLimit), { providerSessionId: state.providerSessionId, ...eventRaw('part/step-finish', part) })];
+        }
+        return [];
+    }
+    /** Engine opencode.js:346-509. One SDK event -> amalgm events. */
+    function normalizeOpenCodeEvent(event, state) {
+        const payload = (event?.['payload'] || event);
+        if (!payload || typeof payload !== 'object')
+            return [];
+        const raw = eventRaw(payload['type'], event);
+        if (payload['type'] === 'message.updated') {
+            const info = payload['properties']?.info;
+            if (info?.id && info.sessionID === state.providerSessionId && info.role) {
+                messageRoles(state).set(info.id, info.role);
+                if (info.role === 'user') {
+                    const created = Number(info.time?.created || 0);
+                    const isCurrentTurnUser = !state.turnStartedAt || !created || created >= state.turnStartedAt;
+                    if (!state.userMessageId && isCurrentTurnUser)
+                        state.userMessageId = info.id;
+                    dropPendingParts(info.id, state);
+                    return [];
+                }
+            }
+        }
+        if (payload['type'] === 'message.part.delta') {
+            const props = payload['properties'] || {};
+            const delta = typeof props.delta === 'string' ? props.delta : '';
+            if (!delta)
+                return [];
+            if (!state.assistantMessageIds.has(props.messageID)) {
+                const pending = state.pendingParts?.get(props.partID);
+                if (pending?.part)
+                    cachePendingPart(pending.part, state, delta);
+                return [];
+            }
+            const knownType = state.partTypes?.get(props.partID);
+            const previous = state.partText.get(props.partID) || '';
+            const merged = appendOpenCodeDelta(previous, delta);
+            state.partText.set(props.partID, merged.nextText);
+            if (!merged.deltaToEmit)
+                return [];
+            if (knownType === 'text' || (!knownType && props.field === 'text')) {
+                const text = dedupeOpenCodeAssistantText(state, merged.deltaToEmit);
+                return text ? [textDelta(text, { providerSessionId: state.providerSessionId, ts: payload['time'] || payload['properties']?.time, ...raw })] : [];
+            }
+            if (knownType === 'reasoning' || props.field === 'reasoning' || props.field === 'thinking') {
+                return [reasoningDelta(merged.deltaToEmit, { providerSessionId: state.providerSessionId, ...raw })];
+            }
+            return [];
+        }
+        if (payload['type'] === 'message.part.updated') {
+            const part = payload['properties']?.part;
+            if (part?.id && part?.type) {
+                if (!state.partTypes)
+                    state.partTypes = new Map();
+                state.partTypes.set(part.id, part.type);
+            }
+            if (part?.metadata?.compaction_continue) {
+                rememberCompactionContinuation(part, state);
+                return [];
+            }
+            const role = part?.messageID ? state.messageRoles?.get(part.messageID) : undefined;
+            if (role && role !== 'assistant')
+                return [];
+            if (part?.type === 'compaction')
+                return normalizeOpenCodePart(part, state, payload['properties']?.delta);
+            if (part?.messageID && !state.assistantMessageIds.has(part.messageID)) {
+                cachePendingPart(part, state, payload['properties']?.delta);
+                return [];
+            }
+            const partEvents = normalizeOpenCodePart(part, state, payload['properties']?.delta);
+            if (part?.type === 'step-finish' && part.messageID)
+                state.usageEmittedForAssistant.add(part.messageID);
+            return partEvents;
+        }
+        if (payload['type'] === 'message.updated') {
+            const info = payload['properties']?.info;
+            if (isOpenCodeInternalUsage(info, state)) {
+                if (info.id && info.tokens && (info.finish || info.time?.completed)) {
+                    if (state.finishedAssistantIds.has(info.id))
+                        return [];
+                    state.finishedAssistantIds.add(info.id);
+                    const operation = info.mode === 'compaction' || info.agent === 'compaction' ? 'compaction' : 'chat_step';
+                    return [usageFinal(usageFromOpenCodeTokens(info.tokens, info.cost, state.contextLimit, operation), { providerSessionId: state.providerSessionId, ...raw })];
+                }
+                return [];
+            }
+            if (!isOurAssistant(info, state))
+                return [];
+            if (info.id) {
+                state.assistantMessageIds.add(info.id);
+                state.sawTurnActivity = true;
+            }
+            const flushed = info.id ? flushPendingParts(info.id, state) : [];
+            if (info.tokens && (info.finish || info.time?.completed)) {
+                if (state.finishedAssistantIds.has(info.id))
+                    return [];
+                state.finishedAssistantIds.add(info.id);
+                const finishEvents = [...flushed];
+                if (!state.usageEmittedForAssistant.has(info.id)) {
+                    state.usageEmittedForAssistant.add(info.id);
+                    finishEvents.push(usageFinal(usageFromOpenCodeTokens(info.tokens, info.cost, state.contextLimit), { providerSessionId: state.providerSessionId, ...raw }));
+                }
+                if (!state.doneEmitted && (info.finish === 'stop' || info.finish === 'length' || info.finish === 'content_filter')) {
+                    state.pendingStopReason = stopReasonFromOpenCodeFinish(info.finish) || 'end_turn';
+                }
+                return finishEvents;
+            }
+            return flushed;
+        }
+        if (payload['type'] === 'session.compacted' && payload['properties']?.sessionID === state.providerSessionId) {
+            return [compactionFinished({
+                    providerSessionId: state.providerSessionId,
+                    trigger: 'auto',
+                    ...raw,
+                })];
+        }
+        if (payload['type'] === 'session.error' && payload['properties']?.sessionID === state.providerSessionId) {
+            const err = payload['properties']?.error;
+            const message = openCodeErrorMessage(err);
+            if (state.doneEmitted)
+                return [errorEvent(message, { providerSessionId: state.providerSessionId, ...raw })];
+            state.doneEmitted = true;
+            return [errorEvent(message, { providerSessionId: state.providerSessionId, ...raw }), done({ providerSessionId: state.providerSessionId, stopReason: 'error', ...raw })];
+        }
+        if (payload['type'] === 'permission.asked' || payload['type'] === 'permission.replied')
+            return [];
+        if (payload['type'] === 'question.asked') {
+            const props = payload['properties'] || {};
+            if (props.sessionID && props.sessionID !== state.providerSessionId)
+                return [];
+            const id = openCodeRequestId('question', props.id);
+            return [toolStarted(id, {
+                    providerSessionId: state.providerSessionId,
+                    toolName: 'AskUserQuestion',
+                    title: 'Question',
+                    kind: 'question',
+                    detail: 'Question',
+                    input: {
+                        questions: props.questions || props.question || [],
+                    },
+                    metadata: { providerEvent: payload['type'], question: true },
+                    data: { question: props },
+                    ts: payload['time'],
+                    ...raw,
+                })];
+        }
+        if (payload['type'] === 'question.replied' || payload['type'] === 'question.rejected') {
+            const props = payload['properties'] || {};
+            if (props.sessionID && props.sessionID !== state.providerSessionId)
+                return [];
+            const id = openCodeRequestId('question', props.requestID || props.id);
+            const rejected = payload['type'] === 'question.rejected';
+            return [toolCompleted(id, {
+                    providerSessionId: state.providerSessionId,
+                    toolName: 'AskUserQuestion',
+                    title: 'Question',
+                    kind: 'question',
+                    detail: rejected ? 'Question rejected' : 'Question answered',
+                    result: rejected ? 'Question rejected' : JSON.stringify(props.answers || {}),
+                    output: props,
+                    isError: rejected,
+                    error: rejected ? normalizeError('Question rejected') : undefined,
+                    metadata: { providerEvent: payload['type'], question: true },
+                    data: { question: props },
+                    ts: payload['time'],
+                    ...raw,
+                })];
+        }
+        if ((payload['type'] === 'session.idle' || payload['type'] === 'session.status') && payload['properties']?.sessionID === state.providerSessionId) {
+            const status = payload['properties']?.status;
+            if (status?.type === 'busy' || status === 'busy')
+                state.sawBusy = true;
+            if (status?.type === 'retry') {
+                const attempt = status.attempt ?? status.count ?? status.retry ?? '?';
+                const reason = status.message || openCodeErrorMessage(status.error, 'unknown upstream error');
+                const message = `OpenCode upstream retrying: ${reason} (attempt ${attempt})`;
+                return [warningEvent(message, { providerSessionId: state.providerSessionId, ...raw })];
+            }
+            if ((!status || status === 'idle' || status?.type === 'idle') && state.sawTurnActivity && !state.doneEmitted) {
+                state.doneEmitted = true;
+                return [done({ providerSessionId: state.providerSessionId, stopReason: state.pendingStopReason, ...raw })];
+            }
+        }
+        return [];
+    }
+    /** Engine opencode.js:511-543. Prompt-RPC resolution -> parts + usage + done. */
+    function normalizeOpenCodePromptResult(dataInput, state) {
+        const data = dataInput;
+        const raw = eventRaw('prompt.result', data);
+        const resultError = data?.['error'] || data?.['info']?.error;
+        if (resultError) {
+            const message = openCodeErrorMessage(resultError);
+            if (state.doneEmitted)
+                return [errorEvent(message, { providerSessionId: state.providerSessionId, ...raw })];
+            state.doneEmitted = true;
+            return [errorEvent(message, { providerSessionId: state.providerSessionId, ...raw }), done({ providerSessionId: state.providerSessionId, stopReason: 'error', ...raw })];
+        }
+        const info = data?.['info'];
+        if (!info?.id)
+            return [];
+        if (!isOurAssistant(info, state))
+            return [];
+        state.assistantMessageIds.add(info.id);
+        state.sawTurnActivity = true;
+        const resultEvents = [];
+        for (const part of data?.['parts'] || []) {
+            resultEvents.push(...normalizeOpenCodePart(part, state));
+        }
+        const finished = Boolean(info.finish || info.time?.completed);
+        if (!finished)
+            return resultEvents;
+        if (info.tokens && !state.usageEmittedForAssistant.has(info.id)) {
+            state.usageEmittedForAssistant.add(info.id);
+            resultEvents.push(usageFinal(usageFromOpenCodeTokens(info.tokens, info.cost, state.contextLimit), { providerSessionId: state.providerSessionId, ...raw }));
+        }
+        if (!state.doneEmitted) {
+            state.doneEmitted = true;
+            const stopReason = info.finish === 'length' ? 'max_tokens'
+                : info.finish === 'content_filter' ? 'content_filter'
+                    : 'end_turn';
+            resultEvents.push(done({ providerSessionId: state.providerSessionId, stopReason, ...raw }));
+        }
+        return resultEvents;
+    }
+    return {
+        normalizeOpenCodeEvent,
+        normalizeOpenCodePart,
+        normalizeOpenCodePromptResult,
+    };
+}
+//# sourceMappingURL=opencode.js.map