@getpaseo/server 0.1.72 → 0.1.73

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

@@ -24,6 +24,22 @@ 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 DEFAULT_MODES = [
     {
         id: OPENCODE_BUILD_MODE_ID,
@@ -435,6 +451,16 @@ 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,
@@ -574,17 +600,24 @@ async function readOpenCodeSessionTimeline(storageRoot, sessionId) {
     return timeline;
 }
 async function readOpenCodeMessageText(storageRoot, messageId) {
+    const parts = await readOpenCodeStoredParts(storageRoot, messageId);
+    return readOpenCodeTextFromParts(parts);
+}
+async function readOpenCodeStoredParts(storageRoot, messageId) {
     const partRoot = path.join(storageRoot, "part", messageId);
     const partFiles = await findJsonFiles(partRoot);
     const parts = [];
     for (const file of partFiles) {
         const parsed = await readJsonFile(file, OpenCodeStoredPartSchema);
-        if (parsed?.type === "text" && typeof parsed.text === "string") {
+        if (parsed) {
             parts.push(parsed);
         }
     }
+    return parts.sort((left, right) => getOpenCodePartTimestamp(left) - getOpenCodePartTimestamp(right));
+}
+function readOpenCodeTextFromParts(parts) {
     return parts
-        .sort((left, right) => getOpenCodePartTimestamp(left) - getOpenCodePartTimestamp(right))
+        .filter((part) => part.type === "text" && typeof part.text === "string")
         .map((part) => part.text?.trim() ?? "")
         .filter(Boolean)
         .join("\n\n");
@@ -669,6 +702,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));
@@ -691,7 +729,7 @@ 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, new Map(this.modelContextWindows), acquisition.release, options?.persistSession);
+            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, options?.persistSession, this.recovery);
         }
         catch (error) {
             acquisition.release();
@@ -717,7 +755,7 @@ export class OpenCodeAgentClient {
         });
         try {
             await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
-            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, new Map(this.modelContextWindows), acquisition.release);
+            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, undefined, this.recovery);
         }
         catch (error) {
             acquisition.release();
@@ -1554,13 +1592,31 @@ 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`);
+}
 class OpenCodeAgentSession {
-    constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), releaseServer, persistSession = true) {
+    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,
+    }) {
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
         this.currentMode = "default";
         this.pendingPermissions = new Map();
         this.abortController = null;
+        this.pendingAbortPromise = null;
         this.accumulatedUsage = {};
         this.mcpConfigured = false;
         this.mcpSetupPromise = null;
@@ -1581,14 +1637,25 @@ 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.config = config;
         this.client = client;
         this.sessionId = sessionId;
         this.logger = logger;
+        this.storageRoot = storageRoot;
         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() {
@@ -1626,22 +1693,65 @@ class OpenCodeAgentSession {
         const turnId = this.activeForegroundTurnId;
         const turnAbortController = this.abortController;
         turnAbortController?.abort();
-        await this.client.session.abort({
-            sessionID: this.sessionId,
-            directory: this.config.cwd,
+        // COMPAT(opencodeSlowAbort): OpenCode 1.14.42+ blocks session.abort until
+        // the running tool actually stops, which can be tens of seconds for
+        // long-running tools. Cap the wait so the user-visible cancel lands
+        // quickly while still giving OpenCode a chance to confirm the abort
+        // cleanly. Drop the timeout once upstream returns abort acknowledgement
+        // before tool teardown.
+        const abortPromise = this.beginSessionAbort(turnId, "interrupt");
+        await withTimeout(abortPromise, 2000, "OpenCode session.abort").catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId, turnId }, "OpenCode session.abort exceeded the cancel cap; proceeding with local cancel");
         });
         if (turnId) {
             this.finishForegroundTurn({ type: "turn_canceled", provider: "opencode", reason: "interrupted" }, turnId);
         }
     }
+    beginSessionAbort(turnId, reason) {
+        const abortPromise = this.client.session
+            .abort({
+            sessionID: this.sessionId,
+            directory: this.config.cwd,
+        })
+            .then(() => undefined)
+            .catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId, turnId, reason }, "OpenCode session.abort rejected");
+        });
+        const trackedAbortPromise = abortPromise.finally(() => {
+            if (this.pendingAbortPromise === trackedAbortPromise) {
+                this.pendingAbortPromise = null;
+            }
+        });
+        this.pendingAbortPromise = trackedAbortPromise;
+        return trackedAbortPromise;
+    }
+    async awaitPendingAbortBeforeStartingTurn() {
+        const pendingAbortPromise = this.pendingAbortPromise;
+        if (!pendingAbortPromise) {
+            return;
+        }
+        await withTimeout(pendingAbortPromise, OPENCODE_PENDING_ABORT_START_TIMEOUT_MS, "OpenCode pending session.abort").catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId }, "OpenCode session.abort was still pending before starting the next turn");
+        });
+    }
     async startTurn(prompt, options) {
         if (this.activeForegroundTurnId) {
             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();
         const turnAbortController = new AbortController();
         this.abortController = turnAbortController;
         await this.ensureMcpServersConfigured();
@@ -1750,6 +1860,14 @@ 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", {
+                    turnId,
+                    sessionId: this.sessionId,
+                    model,
+                    effectiveMode,
+                    effectiveVariant,
+                    partTypes: parts.map((p) => p.type),
+                });
                 try {
                     const promptResponse = await this.client.session.promptAsync({
                         sessionID: this.sessionId,
@@ -1768,6 +1886,12 @@ class OpenCodeAgentSession {
                         ...(effectiveMode ? { agent: effectiveMode } : {}),
                         ...(effectiveVariant ? { variant: effectiveVariant } : {}),
                     });
+                    traceOpenCode("promptAsync.response", {
+                        turnId,
+                        hasError: promptResponse.error !== undefined,
+                        error: promptResponse.error,
+                        data: promptResponse.data,
+                    });
                     if (promptResponse.error) {
                         this.finishForegroundTurn({
                             type: "turn_failed",
@@ -1777,6 +1901,12 @@ class OpenCodeAgentSession {
                     }
                 }
                 catch (error) {
+                    traceOpenCode("promptAsync.throw", {
+                        turnId,
+                        error: error instanceof Error
+                            ? { name: error.name, message: error.message, stack: error.stack }
+                            : String(error),
+                    });
                     this.finishForegroundTurn({
                         type: "turn_failed",
                         provider: "opencode",
@@ -1794,16 +1924,39 @@ class OpenCodeAgentSession {
         };
     }
     async consumeEventStream(turnId, turnAbortController, subscriptionReady) {
+        traceOpenCode("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, sseMaxRetryAttempts: 0 });
+            const result = await this.client.event.subscribe({ directory: this.config.cwd }, { signal: turnAbortController.signal });
+            traceOpenCode("subscribe.ready", { turnId, sessionId: this.sessionId });
             subscriptionReady.resolve();
+            let eventCount = 0;
             for await (const event 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", {
+                        turnId,
+                        n: eventCount,
+                        aborted: turnAbortController.signal.aborted,
+                        activeTurnId: this.activeForegroundTurnId,
+                    });
                     break;
                 }
                 const translated = await this.translateEvent(event);
+                traceOpenCode("event.translated", {
+                    turnId,
+                    n: eventCount,
+                    count: translated.length,
+                    types: translated.map((t) => t.type),
+                });
                 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") {
@@ -1811,13 +1964,26 @@ class OpenCodeAgentSession {
                     }
                     const terminalEvent = toTerminalTurnEvent(e);
                     if (terminalEvent) {
+                        traceOpenCode("event.terminal", { turnId, type: terminalEvent.type });
                         this.finishForegroundTurn(terminalEvent, turnId);
                         return;
                     }
                     this.notifySubscribers(e, turnId);
                 }
             }
+            traceOpenCode("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;
+                }
+                traceOpenCode("turn.fail.eof", { turnId, eventCount });
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
@@ -1826,6 +1992,10 @@ class OpenCodeAgentSession {
             }
         }
         catch (error) {
+            traceOpenCode("subscribe.error", {
+                turnId,
+                error: error instanceof Error ? { name: error.name, message: error.message } : String(error),
+            });
             subscriptionReady.reject(error);
             if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
                 this.finishForegroundTurn({
@@ -1848,7 +2018,348 @@ class OpenCodeAgentSession {
             }
         }
     }
+    async recoverTurnFromPersistedCompletion(turnId) {
+        traceOpenCode("recovery.start", {
+            turnId,
+            foregroundTurnStartedAt: this.foregroundTurnStartedAt,
+            knownMessageIds: Array.from(this.foregroundKnownMessageIds),
+            sessionId: this.sessionId,
+            timeoutMs: this.recovery.timeoutMs,
+            pollIntervalMs: this.recovery.pollIntervalMs,
+        });
+        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));
+        }
+    }
+    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`, {
+                turnId,
+                attempt,
+                pendingPermissionIds: Array.from(this.pendingPermissions.keys()),
+            });
+            await new Promise((resolve) => setTimeout(resolve, this.recovery.pollIntervalMs));
+            return true;
+        }
+        traceOpenCode(cap === "liveness" ? "recovery.liveness-exhausted" : "recovery.exhausted", {
+            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");
+        });
+    }
+    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),
+                };
+            }
+            if (typeof info.time?.completed !== "number") {
+                return { kind: "in-progress", messageId: info.id, parts: item.parts };
+            }
+            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;
+            }
+            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;
+        }
+        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", {
+            turnId,
+            activeTurnId: this.activeForegroundTurnId,
+            type: event.type,
+            error: event.type === "turn_failed" ? event.error : undefined,
+            reason: event.type === "turn_canceled" ? event.reason : undefined,
+        });
         if (this.activeForegroundTurnId !== turnId) {
             return;
         }
@@ -1858,6 +2369,7 @@ class OpenCodeAgentSession {
         else {
             this.runningToolCalls.clear();
         }
+        this.foregroundTurnStartedAt = null;
         this.activeForegroundTurnId = null;
         // Abort the SSE connection so the SDK tears down the underlying fetch.
         this.abortController?.abort();
@@ -1896,6 +2408,13 @@ 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;
         for (const callback of this.subscribers) {
             try {