@getpaseo/server 0.1.73 → 0.1.75

package/dist/server/server/agent/providers/opencode-agent.js

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
 import { z } from "zod";
+import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { createProviderEnvSpec } from "../provider-launch-config.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { execCommand } from "../../../utils/spawn.js";
@@ -24,22 +25,8 @@ const OPENCODE_CAPABILITIES = {
 const OPENCODE_BUILD_MODE_ID = "build";
 const OPENCODE_FULL_ACCESS_MODE_ID = "full-access";
 const OPENCODE_STORAGE_SESSION_LIMIT = 200;
-// COMPAT(opencodeEofRecovery): added in v0.1.73 to compensate for OpenCode 1.14.42+
-// closing the /event SSE stream cleanly after `server.connected`. Drop this whole
-// recovery path once OpenCode upstream restores live event delivery and the floor
-// version reflects that.
-// Upstream: anomalyco/opencode#26697 (SSE /event closes immediately after
-// server.connected) and anomalyco/opencode#26635 (prompt_async silently discards
-// requests; SSE path broken).
-const OPENCODE_EOF_RECOVERY_TIMEOUT_MS = 5 * 60 * 1000;
-const OPENCODE_EOF_RECOVERY_POLL_INTERVAL_MS = 1000;
-const OPENCODE_RECOVERY_ABORT_TIMEOUT_MS = 2000;
 const OPENCODE_PENDING_ABORT_START_TIMEOUT_MS = 10000;
-// If OpenCode silently rejects the prompt (invalid model/mode/auth), no assistant
-// message is ever persisted. Bound the wait so the turn fails in seconds instead
-// of hanging until the completion cap. Valid models normally persist their first
-// message within a second of LLM start, so 10s leaves comfortable headroom.
-const OPENCODE_EOF_RECOVERY_LIVENESS_MS = 10000;
+const OPENCODE_RETRY_STATUS_FAILURE_MS = 10000;
 const DEFAULT_MODES = [
     {
         id: OPENCODE_BUILD_MODE_ID,
@@ -451,16 +438,6 @@ function mergeOpenCodeStepFinishUsage(usage, part) {
         usage.totalCostUsd = (usage.totalCostUsd ?? 0) + cost;
     }
 }
-function formatOpenCodeAssistantErrorMessage(error) {
-    const data = error.data;
-    if (data && typeof data === "object" && "message" in data) {
-        const message = data.message;
-        if (typeof message === "string" && message.trim().length > 0) {
-            return message.trim();
-        }
-    }
-    return error.name;
-}
 function hasNormalizedOpenCodeUsage(usage) {
     return [
         usage.inputTokens,
@@ -702,16 +679,11 @@ export class OpenCodeAgentClient {
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
         this.storageRoot = storageRoot ?? resolveOpenCodeStorageRoot();
-        this.recovery = deps.recovery ?? {
-            timeoutMs: OPENCODE_EOF_RECOVERY_TIMEOUT_MS,
-            pollIntervalMs: OPENCODE_EOF_RECOVERY_POLL_INTERVAL_MS,
-            livenessMs: OPENCODE_EOF_RECOVERY_LIVENESS_MS,
-        };
         this.runtime =
             deps.runtime ??
                 new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
     }
-    async createSession(config, _launchContext, options) {
+    async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
         const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
@@ -729,14 +701,14 @@ export class OpenCodeAgentClient {
                 throw new Error("OpenCode session creation returned no data");
             }
             await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
-            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, options?.persistSession, this.recovery);
+            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, options?.persistSession, launchContext?.agentId);
         }
         catch (error) {
             acquisition.release();
             throw error;
         }
     }
-    async resumeSession(handle, overrides, _launchContext) {
+    async resumeSession(handle, overrides, launchContext) {
         const cwd = overrides?.cwd ?? handle.metadata?.cwd;
         if (!cwd) {
             throw new Error("OpenCode resume requires the original working directory");
@@ -755,7 +727,7 @@ export class OpenCodeAgentClient {
         });
         try {
             await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
-            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, undefined, this.recovery);
+            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, undefined, launchContext?.agentId);
         }
         catch (error) {
             acquisition.release();
@@ -1592,25 +1564,23 @@ function createDeferred() {
     });
     return { promise, resolve, reject };
 }
-const OPENCODE_TRACE_ENABLED = process.env.PASEO_OPENCODE_TRACE === "1";
-function traceOpenCode(tag, data = {}) {
-    if (!OPENCODE_TRACE_ENABLED)
-        return;
-    const line = JSON.stringify({ ts: new Date().toISOString(), tag, ...data }, (_k, v) => {
-        if (v instanceof Error)
-            return { name: v.name, message: v.message, stack: v.stack };
-        if (typeof v === "bigint")
-            return v.toString();
-        return v;
-    });
-    process.stderr.write(`[opencode-trace] ${line}\n`);
+function unwrapOpenCodeGlobalEvent(event) {
+    const record = readOpenCodeRecord(event);
+    if (!record) {
+        return null;
+    }
+    const payload = readOpenCodeRecord(record.payload);
+    if (typeof payload?.type === "string") {
+        return payload;
+    }
+    if (typeof record.type === "string") {
+        return record;
+    }
+    return null;
 }
 class OpenCodeAgentSession {
-    constructor(config, client, sessionId, logger, storageRoot, modelContextWindowsByModelKey = new Map(), releaseServer, persistSession = true, recovery = {
-        timeoutMs: OPENCODE_EOF_RECOVERY_TIMEOUT_MS,
-        pollIntervalMs: OPENCODE_EOF_RECOVERY_POLL_INTERVAL_MS,
-        livenessMs: OPENCODE_EOF_RECOVERY_LIVENESS_MS,
-    }) {
+    constructor(config, client, sessionId, logger, _storageRoot, modelContextWindowsByModelKey = new Map(), releaseServer, persistSession = true, agentId) {
+        this.agentId = agentId;
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
         this.currentMode = "default";
@@ -1637,25 +1607,15 @@ class OpenCodeAgentSession {
         this.subAgentCallIdByChildSessionId = new Map();
         this.pendingChildToolPartsBySessionId = new Map();
         this.deletedFromProvider = false;
-        this.foregroundAssistantMessageEmitted = false;
-        this.foregroundAssistantText = "";
-        this.foregroundUsageUpdated = false;
-        this.foregroundKnownMessageIds = new Set();
-        this.foregroundEmittedQuestionIds = new Set();
-        this.foregroundEmittedPermissionIds = new Set();
-        this.foregroundEmittedReasoningTextLengthByPartId = new Map();
-        this.foregroundEmittedToolCallSignatureByCallId = new Map();
-        this.foregroundTurnStartedAt = null;
+        this.retryFailureTimer = null;
         this.config = config;
         this.client = client;
         this.sessionId = sessionId;
-        this.logger = logger;
-        this.storageRoot = storageRoot;
+        this.logger = logger.child({ agentId: this.agentId });
         this.modelContextWindowsByModelKey = modelContextWindowsByModelKey;
         this.currentMode = normalizeOpenCodeModeId(config.modeId);
         this.releaseServer = releaseServer ?? null;
         this.persistSession = persistSession;
-        this.recovery = recovery;
         this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(config.model);
     }
     get id() {
@@ -1739,19 +1699,11 @@ class OpenCodeAgentSession {
             throw new Error("A foreground turn is already active");
         }
         await this.awaitPendingAbortBeforeStartingTurn();
-        this.foregroundTurnStartedAt = Date.now();
         this.runningToolCalls.clear();
         this.subAgentsByCallId.clear();
         this.subAgentCallIdByChildSessionId.clear();
         this.pendingChildToolPartsBySessionId.clear();
-        this.foregroundAssistantMessageEmitted = false;
-        this.foregroundAssistantText = "";
-        this.foregroundUsageUpdated = false;
-        this.foregroundEmittedQuestionIds.clear();
-        this.foregroundEmittedPermissionIds.clear();
-        this.foregroundEmittedReasoningTextLengthByPartId.clear();
-        this.foregroundEmittedToolCallSignatureByCallId.clear();
-        this.foregroundKnownMessageIds = await this.readPersistedSessionMessageIds();
+        this.clearRetryFailureTimer();
         const turnAbortController = new AbortController();
         this.abortController = turnAbortController;
         await this.ensureMcpServersConfigured();
@@ -1860,7 +1812,7 @@ class OpenCodeAgentSession {
             // SDK input validation) is caught alongside async rejections. A plain
             // `.then().catch()` chain would let a sync throw escape unhandled.
             void (async () => {
-                traceOpenCode("promptAsync.start", {
+                this.traceOpenCode("provider.opencode.prompt_async.start", {
                     turnId,
                     sessionId: this.sessionId,
                     model,
@@ -1886,7 +1838,7 @@ class OpenCodeAgentSession {
                         ...(effectiveMode ? { agent: effectiveMode } : {}),
                         ...(effectiveVariant ? { variant: effectiveVariant } : {}),
                     });
-                    traceOpenCode("promptAsync.response", {
+                    this.traceOpenCode("provider.opencode.prompt_async.response", {
                         turnId,
                         hasError: promptResponse.error !== undefined,
                         error: promptResponse.error,
@@ -1901,7 +1853,7 @@ class OpenCodeAgentSession {
                     }
                 }
                 catch (error) {
-                    traceOpenCode("promptAsync.throw", {
+                    this.traceOpenCode("provider.opencode.prompt_async.throw", {
                         turnId,
                         error: error instanceof Error
                             ? { name: error.name, message: error.message, stack: error.stack }
@@ -1924,66 +1876,49 @@ class OpenCodeAgentSession {
         };
     }
     async consumeEventStream(turnId, turnAbortController, subscriptionReady) {
-        traceOpenCode("subscribe.start", { turnId, sessionId: this.sessionId, cwd: this.config.cwd });
+        this.traceOpenCode("provider.opencode.subscribe.start", {
+            turnId,
+            sessionId: this.sessionId,
+            cwd: this.config.cwd,
+        });
         try {
-            const result = await this.client.event.subscribe({ directory: this.config.cwd }, { signal: turnAbortController.signal });
-            traceOpenCode("subscribe.ready", { turnId, sessionId: this.sessionId });
-            subscriptionReady.resolve();
+            const result = await this.client.global.event({
+                signal: turnAbortController.signal,
+                sseMaxRetryAttempts: 0,
+            });
             let eventCount = 0;
-            for await (const event of result.stream) {
+            let subscriptionReadyResolved = false;
+            for await (const rawEvent of result.stream) {
                 eventCount += 1;
-                traceOpenCode("event.raw", {
-                    turnId,
-                    n: eventCount,
-                    type: event.type,
-                    properties: event.properties,
-                });
-                if (turnAbortController.signal.aborted || this.activeForegroundTurnId !== turnId) {
-                    traceOpenCode("event.skip", {
+                if (!subscriptionReadyResolved) {
+                    subscriptionReadyResolved = true;
+                    this.traceOpenCode("provider.opencode.subscribe.ready", {
                         turnId,
-                        n: eventCount,
-                        aborted: turnAbortController.signal.aborted,
-                        activeTurnId: this.activeForegroundTurnId,
+                        sessionId: this.sessionId,
                     });
-                    break;
+                    subscriptionReady.resolve();
                 }
-                const translated = await this.translateEvent(event);
-                traceOpenCode("event.translated", {
+                const shouldContinue = await this.consumeOpenCodeStreamEvent({
+                    rawEvent,
+                    eventCount,
                     turnId,
-                    n: eventCount,
-                    count: translated.length,
-                    types: translated.map((t) => t.type),
+                    turnAbortController,
                 });
-                for (const e of translated) {
-                    if (this.activeForegroundTurnId !== turnId) {
-                        traceOpenCode("event.translated.skip-active", { turnId, type: e.type });
-                        return;
-                    }
-                    if (e.type === "timeline" && e.item.type === "tool_call") {
-                        this.trackToolCall(e.item);
-                    }
-                    const terminalEvent = toTerminalTurnEvent(e);
-                    if (terminalEvent) {
-                        traceOpenCode("event.terminal", { turnId, type: terminalEvent.type });
-                        this.finishForegroundTurn(terminalEvent, turnId);
-                        return;
-                    }
-                    this.notifySubscribers(e, turnId);
+                if (!shouldContinue) {
+                    return;
                 }
             }
-            traceOpenCode("stream.eof", {
+            this.traceOpenCode("provider.opencode.stream.eof", {
                 turnId,
                 eventCount,
                 aborted: turnAbortController.signal.aborted,
                 stillActive: this.activeForegroundTurnId === turnId,
             });
             if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
-                const recovered = await this.recoverTurnFromPersistedCompletion(turnId);
-                traceOpenCode("recovery.result", { turnId, recovered });
-                if (recovered) {
-                    return;
+                this.traceOpenCode("provider.opencode.turn.fail_eof", { turnId, eventCount });
+                if (!subscriptionReadyResolved) {
+                    subscriptionReady.reject(new Error("OpenCode event stream ended before it became ready"));
                 }
-                traceOpenCode("turn.fail.eof", { turnId, eventCount });
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
@@ -1992,7 +1927,7 @@ class OpenCodeAgentSession {
             }
         }
         catch (error) {
-            traceOpenCode("subscribe.error", {
+            this.traceOpenCode("provider.opencode.subscribe.error", {
                 turnId,
                 error: error instanceof Error ? { name: error.name, message: error.message } : String(error),
             });
@@ -2018,342 +1953,62 @@ class OpenCodeAgentSession {
             }
         }
     }
-    async recoverTurnFromPersistedCompletion(turnId) {
-        traceOpenCode("recovery.start", {
+    async consumeOpenCodeStreamEvent(params) {
+        const { rawEvent, eventCount, turnId, turnAbortController } = params;
+        const event = unwrapOpenCodeGlobalEvent(rawEvent);
+        this.traceOpenCode("provider.opencode.raw_event", {
             turnId,
-            foregroundTurnStartedAt: this.foregroundTurnStartedAt,
-            knownMessageIds: Array.from(this.foregroundKnownMessageIds),
-            sessionId: this.sessionId,
-            timeoutMs: this.recovery.timeoutMs,
-            pollIntervalMs: this.recovery.pollIntervalMs,
+            n: eventCount,
+            type: event?.type,
+            rawType: readOpenCodeRecord(rawEvent)?.type,
+            directory: readOpenCodeRecord(rawEvent)?.directory,
+            rawEvent,
+            properties: event?.properties,
         });
-        const startedAt = this.foregroundTurnStartedAt;
-        if (startedAt === null) {
-            traceOpenCode("recovery.no-start-time", { turnId });
-            return false;
-        }
-        const completionDeadline = Date.now() + this.recovery.timeoutMs;
-        const livenessDeadline = Date.now() + this.recovery.livenessMs;
-        let attempt = 0;
-        let observedActivity = false;
-        while (true) {
-            if (this.activeForegroundTurnId !== turnId) {
-                traceOpenCode("recovery.cancelled", { turnId, attempt });
-                return true;
-            }
-            attempt += 1;
-            const emittedPromptIds = await this.pollPendingQuestionsAndPermissions(turnId);
-            if (emittedPromptIds > 0) {
-                observedActivity = true;
-            }
-            const outcome = await this.fetchAssistantOutcomeFromMessagesApi(startedAt);
-            traceOpenCode("recovery.poll", {
-                turnId,
-                attempt,
-                kind: outcome?.kind ?? "none",
-                messageId: outcome?.messageId,
-                emittedPromptIds,
-            });
-            if (outcome?.kind === "failure") {
-                this.foregroundKnownMessageIds.add(outcome.messageId);
-                this.finishForegroundTurn({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: outcome.error,
-                }, turnId);
-                return true;
-            }
-            if (outcome?.kind === "completion") {
-                this.emitIncrementalAssistantParts(outcome.parts, turnId);
-                return this.applyRecoveredAssistantCompletion(outcome, turnId);
-            }
-            if (outcome?.kind === "in-progress") {
-                observedActivity = true;
-                this.emitIncrementalAssistantParts(outcome.parts, turnId);
-            }
-            const now = Date.now();
-            if (!observedActivity && now >= livenessDeadline) {
-                const deferred = await this.deferForPendingPermissionOrFailRecoveredTurnAfterCap(turnId, attempt, "liveness");
-                if (deferred) {
-                    continue;
-                }
-                return true;
-            }
-            if (now >= completionDeadline) {
-                const deferred = await this.deferForPendingPermissionOrFailRecoveredTurnAfterCap(turnId, attempt, "completion");
-                if (deferred) {
-                    continue;
-                }
-                return true;
-            }
-            const waitMs = Math.min(this.recovery.pollIntervalMs, completionDeadline - now);
-            await new Promise((resolve) => setTimeout(resolve, waitMs));
+        if (!event) {
+            return true;
         }
-    }
-    async deferForPendingPermissionOrFailRecoveredTurnAfterCap(turnId, attempt, cap) {
-        if (this.pendingPermissions.size > 0) {
-            // A pending OpenCode question/permission means the turn is blocked on
-            // user input, not dead. Keep polling until the user response lets the
-            // assistant finish or the turn is canceled.
-            traceOpenCode(`recovery.${cap}-deferred-for-permission`, {
+        if (turnAbortController.signal.aborted || this.activeForegroundTurnId !== turnId) {
+            this.traceOpenCode("provider.opencode.event.skip", {
                 turnId,
-                attempt,
-                pendingPermissionIds: Array.from(this.pendingPermissions.keys()),
+                n: eventCount,
+                aborted: turnAbortController.signal.aborted,
+                activeTurnId: this.activeForegroundTurnId,
             });
-            await new Promise((resolve) => setTimeout(resolve, this.recovery.pollIntervalMs));
-            return true;
+            return false;
         }
-        traceOpenCode(cap === "liveness" ? "recovery.liveness-exhausted" : "recovery.exhausted", {
+        this.armRetryFailureTimerForStatus(event, turnId);
+        const translated = await this.translateEvent(event);
+        this.traceOpenCode("provider.opencode.parsed_event", {
             turnId,
-            attempt,
-        });
-        await this.failRecoveredTurnAfterCap(turnId, cap);
-        return false;
-    }
-    async failRecoveredTurnAfterCap(turnId, cap) {
-        await this.abortOpenCodeSessionAfterRecoveryCap(turnId, cap);
-        this.finishForegroundTurn({
-            type: "turn_failed",
-            provider: "opencode",
-            error: "OpenCode event stream ended before the turn reached a terminal state",
-        }, turnId);
-    }
-    async abortOpenCodeSessionAfterRecoveryCap(turnId, cap) {
-        const abortPromise = this.beginSessionAbort(turnId, `recovery-${cap}`);
-        await withTimeout(abortPromise, OPENCODE_RECOVERY_ABORT_TIMEOUT_MS, "OpenCode session.abort").catch((error) => {
-            this.logger.warn({ err: error, sessionId: this.sessionId, turnId, cap }, "OpenCode session.abort exceeded the EOF recovery cap");
+            n: eventCount,
+            count: translated.length,
+            types: translated.map((t) => t.type),
+            events: translated,
         });
-    }
-    async pollPendingQuestionsAndPermissions(turnId) {
-        const [questionsResponse, permissionsResponse] = await Promise.all([
-            Promise.resolve()
-                .then(() => this.client.question.list({ directory: this.config.cwd }))
-                .catch((error) => {
-                traceOpenCode("recovery.question-list.throw", {
-                    turnId,
-                    error: error instanceof Error
-                        ? { name: error.name, message: error.message, stack: error.stack }
-                        : String(error),
-                });
-                return null;
-            }),
-            Promise.resolve()
-                .then(() => this.client.permission.list({ directory: this.config.cwd }))
-                .catch((error) => {
-                traceOpenCode("recovery.permission-list.throw", {
-                    turnId,
-                    error: error instanceof Error
-                        ? { name: error.name, message: error.message, stack: error.stack }
-                        : String(error),
-                });
-                return null;
-            }),
-        ]);
-        if (this.activeForegroundTurnId !== turnId)
-            return 0;
-        let emitted = 0;
-        for (const question of questionsResponse?.data ?? []) {
-            if (question.sessionID !== this.sessionId)
-                continue;
-            if (this.foregroundEmittedQuestionIds.has(question.id))
-                continue;
-            this.foregroundEmittedQuestionIds.add(question.id);
-            emitted += 1;
-            const synthetic = {
-                id: question.id,
-                type: "question.asked",
-                properties: question,
-            };
-            const events = await this.translateEvent(synthetic);
-            for (const event of events) {
-                this.notifySubscribers(event, turnId);
-            }
-        }
-        for (const permission of permissionsResponse?.data ?? []) {
-            if (permission.sessionID !== this.sessionId)
-                continue;
-            if (this.foregroundEmittedPermissionIds.has(permission.id))
-                continue;
-            this.foregroundEmittedPermissionIds.add(permission.id);
-            emitted += 1;
-            const synthetic = {
-                id: permission.id,
-                type: "permission.asked",
-                properties: permission,
-            };
-            const events = await this.translateEvent(synthetic);
-            for (const event of events) {
-                this.notifySubscribers(event, turnId);
-            }
-        }
-        return emitted;
-    }
-    async fetchAssistantOutcomeFromMessagesApi(startedAt) {
-        const response = await Promise.resolve()
-            .then(() => this.client.session.messages({
-            sessionID: this.sessionId,
-            directory: this.config.cwd,
-        }))
-            .catch((error) => {
-            traceOpenCode("recovery.messages.throw", {
-                error: error instanceof Error
-                    ? { name: error.name, message: error.message, stack: error.stack }
-                    : String(error),
-            });
-            return null;
-        });
-        if (response === null) {
-            return null;
-        }
-        if (response.error || !response.data) {
-            return null;
-        }
-        for (let index = response.data.length - 1; index >= 0; index -= 1) {
-            const item = response.data[index];
-            if (!item)
-                continue;
-            const info = item.info;
-            if (info.role !== "assistant")
-                continue;
-            if (this.foregroundKnownMessageIds.has(info.id))
-                continue;
-            if (typeof info.time?.created === "number" && info.time.created < startedAt)
-                continue;
-            if (info.error) {
-                return {
-                    kind: "failure",
-                    messageId: info.id,
-                    error: formatOpenCodeAssistantErrorMessage(info.error),
-                };
+        for (const e of translated) {
+            if (this.activeForegroundTurnId !== turnId) {
+                this.traceOpenCode("provider.opencode.parsed_event.skip_active", { turnId, type: e.type });
+                return false;
             }
-            if (typeof info.time?.completed !== "number") {
-                return { kind: "in-progress", messageId: info.id, parts: item.parts };
+            if (e.type === "timeline" && e.item.type === "tool_call") {
+                this.trackToolCall(e.item);
             }
-            let text = item.parts
-                .filter((part) => part.type === "text")
-                .map((part) => (part.text ?? "").trim())
-                .filter((part) => part.length > 0)
-                .join("\n\n");
-            if (!text) {
-                text = stringifyStructuredAssistantMessage(info.structured) ?? "";
-            }
-            if (!text)
-                continue;
-            const usage = {};
-            mergeOpenCodeStepFinishUsage(usage, { cost: info.cost, tokens: info.tokens });
-            return { kind: "completion", messageId: info.id, text, parts: item.parts, usage };
-        }
-        return null;
-    }
-    emitIncrementalAssistantParts(parts, turnId) {
-        for (const part of parts) {
-            if (part.type === "reasoning" && part.text) {
-                const emittedTextLength = this.foregroundEmittedReasoningTextLengthByPartId.get(part.id) ?? 0;
-                if (part.text.length <= emittedTextLength)
-                    continue;
-                const text = part.text.slice(emittedTextLength);
-                this.foregroundEmittedReasoningTextLengthByPartId.set(part.id, part.text.length);
-                this.notifySubscribers({
-                    type: "timeline",
-                    provider: "opencode",
-                    item: { type: "reasoning", text },
-                }, turnId);
-                continue;
+            const terminalEvent = toTerminalTurnEvent(e);
+            if (terminalEvent) {
+                this.traceOpenCode("provider.opencode.event.terminal", {
+                    turnId,
+                    type: terminalEvent.type,
+                });
+                this.finishForegroundTurn(terminalEvent, turnId);
+                return false;
             }
-            if (part.type !== "tool")
-                continue;
-            const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
-            if (!parsedToolPart.success || !parsedToolPart.data)
-                continue;
-            const callId = parsedToolPart.data.callId;
-            const signature = this.createRecoveredToolCallSignature(part, parsedToolPart.data);
-            const lastSignature = this.foregroundEmittedToolCallSignatureByCallId.get(callId);
-            if (lastSignature === signature)
-                continue;
-            this.foregroundEmittedToolCallSignatureByCallId.set(callId, signature);
-            this.trackToolCall(parsedToolPart.data);
-            this.notifySubscribers({
-                type: "timeline",
-                provider: "opencode",
-                item: parsedToolPart.data,
-            }, turnId);
-        }
-    }
-    createRecoveredToolCallSignature(part, item) {
-        const state = part
-            .state;
-        return JSON.stringify([
-            item.callId,
-            item.status,
-            state?.input ?? null,
-            state?.output ?? null,
-            state?.error ?? null,
-        ]);
-    }
-    applyRecoveredAssistantCompletion(completion, turnId) {
-        if (this.activeForegroundTurnId !== turnId) {
-            return false;
-        }
-        this.foregroundKnownMessageIds.add(completion.messageId);
-        this.logger.warn({ sessionId: this.sessionId, turnId }, "Recovered OpenCode turn completion via messages API after SSE EOF");
-        const recoveryText = this.resolvePersistedAssistantRecoveryText(completion.text);
-        if (recoveryText === null) {
-            return false;
+            this.notifySubscribers(e, turnId);
         }
-        if (recoveryText.length > 0) {
-            this.notifySubscribers({
-                type: "timeline",
-                provider: "opencode",
-                item: { type: "assistant_message", text: recoveryText },
-            }, turnId);
-            this.foregroundAssistantMessageEmitted = true;
-        }
-        if (hasNormalizedOpenCodeUsage(completion.usage) && !this.foregroundUsageUpdated) {
-            this.accumulatedUsage = {
-                ...this.accumulatedUsage,
-                ...completion.usage,
-            };
-            this.notifySubscribers({
-                type: "usage_updated",
-                provider: "opencode",
-                usage: { ...this.accumulatedUsage },
-            }, turnId);
-            this.foregroundUsageUpdated = true;
-        }
-        this.finishForegroundTurn({
-            type: "turn_completed",
-            provider: "opencode",
-            usage: hasNormalizedOpenCodeUsage(this.accumulatedUsage)
-                ? { ...this.accumulatedUsage }
-                : undefined,
-        }, turnId);
         return true;
     }
-    resolvePersistedAssistantRecoveryText(completedText) {
-        if (!this.foregroundAssistantMessageEmitted) {
-            return completedText;
-        }
-        if (completedText === this.foregroundAssistantText) {
-            return "";
-        }
-        return completedText.startsWith(this.foregroundAssistantText)
-            ? completedText.slice(this.foregroundAssistantText.length)
-            : null;
-    }
-    async readPersistedSessionMessageIds() {
-        const messageRoot = path.join(this.storageRoot, "message", this.sessionId);
-        const messageFiles = await findJsonFiles(messageRoot);
-        const messageIds = new Set();
-        for (const file of messageFiles) {
-            const parsed = await readJsonFile(file, OpenCodeStoredMessageSchema);
-            if (parsed?.sessionID === this.sessionId) {
-                messageIds.add(parsed.id);
-            }
-        }
-        return messageIds;
-    }
     finishForegroundTurn(event, turnId) {
-        traceOpenCode("finishForegroundTurn", {
+        this.traceOpenCode("provider.opencode.finish_foreground_turn", {
             turnId,
             activeTurnId: this.activeForegroundTurnId,
             type: event.type,
@@ -2369,7 +2024,7 @@ class OpenCodeAgentSession {
         else {
             this.runningToolCalls.clear();
         }
-        this.foregroundTurnStartedAt = null;
+        this.clearRetryFailureTimer();
         this.activeForegroundTurnId = null;
         // Abort the SSE connection so the SDK tears down the underlying fetch.
         this.abortController?.abort();
@@ -2383,6 +2038,37 @@ class OpenCodeAgentSession {
         }
         this.runningToolCalls.delete(item.callId);
     }
+    armRetryFailureTimerForStatus(event, turnId) {
+        if (this.retryFailureTimer || event.type !== "session.status") {
+            return;
+        }
+        if (event.properties.sessionID !== this.sessionId || event.properties.status.type !== "retry") {
+            return;
+        }
+        const retry = event.properties.status;
+        const message = typeof retry.message === "string" ? retry.message.trim() : "";
+        const error = message
+            ? `OpenCode provider retry did not recover: ${message}`
+            : "OpenCode provider retry did not recover";
+        this.retryFailureTimer = setTimeout(() => {
+            this.retryFailureTimer = null;
+            if (this.activeForegroundTurnId !== turnId) {
+                return;
+            }
+            this.finishForegroundTurn({
+                type: "turn_failed",
+                provider: "opencode",
+                error,
+            }, turnId);
+        }, OPENCODE_RETRY_STATUS_FAILURE_MS);
+    }
+    clearRetryFailureTimer() {
+        if (!this.retryFailureTimer) {
+            return;
+        }
+        clearTimeout(this.retryFailureTimer);
+        this.retryFailureTimer = null;
+    }
     synthesizeInterruptedToolCalls(turnId) {
         for (const item of this.runningToolCalls.values()) {
             const error = { message: "Tool execution aborted" };
@@ -2408,14 +2094,11 @@ class OpenCodeAgentSession {
     }
     notifySubscribers(event, turnIdOverride) {
         const turnId = turnIdOverride ?? this.activeForegroundTurnId;
-        if (event.type === "timeline" && event.item.type === "assistant_message") {
-            this.foregroundAssistantMessageEmitted = true;
-            this.foregroundAssistantText += event.item.text;
-        }
-        if (event.type === "usage_updated") {
-            this.foregroundUsageUpdated = true;
-        }
         const tagged = turnId ? { ...event, turnId } : event;
+        this.traceOpenCode("provider.opencode.event_emit", {
+            turnId: getAgentStreamEventTurnId(tagged),
+            event: tagged,
+        });
         for (const callback of this.subscribers) {
             try {
                 callback(tagged);
@@ -2428,6 +2111,15 @@ class OpenCodeAgentSession {
     createTurnId() {
         return `opencode-turn-${this.nextTurnOrdinal++}`;
     }
+    traceOpenCode(msg, data = {}) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "opencode",
+            sessionId: this.sessionId,
+            turnId: data.turnId ?? this.activeForegroundTurnId ?? undefined,
+            ...data,
+        }, msg);
+    }
     async *streamHistory() {
         const response = await this.client.session.messages({
             sessionID: this.sessionId,