@getpaseo/server 0.1.71 → 0.1.73

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

@@ -1,19 +1,18 @@
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
-import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
-import net from "node:net";
-import { z } from "zod";
-import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
-import { terminateWithTreeKill } from "../../../utils/tree-kill.js";
+import { z } from "zod";
+import { createProviderEnvSpec } from "../provider-launch-config.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
-import { execCommand, spawnProcess } from "../../../utils/spawn.js";
+import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
+import { OpenCodeServerManager } from "./opencode/server-manager.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { createSdkOpenCodeClient, } from "./opencode/runtime.js";
 const OPENCODE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -25,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,
@@ -82,8 +97,6 @@ const OpenCodeStoredPartSchema = z
     .passthrough();
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
-const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
-const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
     { name: "compact", description: "Compact the current session", argumentHint: "" },
     { name: "summarize", description: "Compact the current session", argumentHint: "" },
@@ -162,13 +175,6 @@ const OpencodeToolPartToTimelineItemSchema = OpencodeToolPartTimelineEnvelopeSch
     output: part.output,
     error: part.error,
 }));
-async function resolveOpenCodeBinary() {
-    const found = await findExecutable("opencode");
-    if (found) {
-        return found;
-    }
-    throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
-}
 function toOpenCodeMcpConfig(config) {
     if (config.type === "stdio") {
         return {
@@ -278,22 +284,6 @@ function isAlreadyPresentMcpError(error) {
     const normalized = toDiagnosticErrorMessage(error).toLowerCase();
     return MCP_ALREADY_PRESENT_ERROR_TOKENS.some((token) => normalized.includes(token));
 }
-async function findAvailablePort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (address && typeof address === "object") {
-                const port = address.port;
-                server.close(() => resolve(port));
-            }
-            else {
-                server.close(() => reject(new Error("Failed to get port")));
-            }
-        });
-        server.on("error", reject);
-    });
-}
 function resolvePartDedupeKey(part, partType) {
     if (part.id.trim().length > 0) {
         return `${partType}:${part.id}`;
@@ -461,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,
@@ -600,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");
@@ -670,244 +677,45 @@ export const __openCodeInternals = {
         return OpenCodeAgentSession;
     },
 };
-export class OpenCodeServerManager {
-    constructor(logger, runtimeSettings) {
-        this.currentServer = null;
-        this.retiredServers = new Set();
-        this.startPromise = null;
-        this.forcedRefreshPromise = null;
-        this.logger = logger;
-        this.runtimeSettings = runtimeSettings;
-        this.runtimeSettingsKey = JSON.stringify(runtimeSettings ?? {});
+class ProductionOpenCodeRuntime {
+    constructor(serverManager) {
+        this.serverManager = serverManager;
     }
-    static getInstance(logger, runtimeSettings) {
-        const nextSettingsKey = JSON.stringify(runtimeSettings ?? {});
-        if (!OpenCodeServerManager.instance) {
-            OpenCodeServerManager.instance = new OpenCodeServerManager(logger, runtimeSettings);
-            OpenCodeServerManager.registerExitHandler();
-        }
-        else if (OpenCodeServerManager.instance.runtimeSettingsKey !== nextSettingsKey) {
-            logger.warn({
-                existingRuntimeSettings: OpenCodeServerManager.instance.runtimeSettingsKey,
-                requestedRuntimeSettings: nextSettingsKey,
-            }, "OpenCode server manager already initialized with different runtime settings");
-        }
-        return OpenCodeServerManager.instance;
+    async acquireServer(options) {
+        return this.serverManager.acquire(options);
     }
-    static registerExitHandler() {
-        if (OpenCodeServerManager.exitHandlerRegistered) {
-            return;
-        }
-        OpenCodeServerManager.exitHandlerRegistered = true;
-        const cleanup = () => {
-            const instance = OpenCodeServerManager.instance;
-            void instance?.shutdown();
-        };
-        process.on("exit", cleanup);
-        process.on("SIGTERM", cleanup);
-        process.on("SIGINT", cleanup);
-    }
-    async ensureRunning() {
-        const acquisition = await this.acquire({ force: false });
-        acquisition.release();
-        return acquisition.server;
-    }
-    async acquire(options) {
-        const server = options.force
-            ? await this.getForcedRefreshServer()
-            : await this.getCurrentServer();
-        server.refCount += 1;
-        let released = false;
-        return {
-            server: { port: server.port, url: server.url },
-            release: () => {
-                if (released) {
-                    return;
-                }
-                released = true;
-                server.refCount -= 1;
-                this.cleanupRetiredServers();
-            },
-        };
+    async ensureServerRunning() {
+        return this.serverManager.ensureRunning();
     }
-    async getForcedRefreshServer() {
-        if (this.forcedRefreshPromise) {
-            return this.forcedRefreshPromise;
-        }
-        this.forcedRefreshPromise = Promise.resolve()
-            .then(async () => {
-            await this.rotateCurrentServer();
-            return this.getCurrentServer();
-        })
-            .finally(() => {
-            this.forcedRefreshPromise = null;
-        });
-        return this.forcedRefreshPromise;
-    }
-    async getCurrentServer() {
-        if (this.startPromise) {
-            return this.startPromise;
-        }
-        if (this.currentServer && !this.currentServer.process.killed) {
-            return this.currentServer;
-        }
-        this.startPromise = this.startServer();
-        try {
-            const result = await this.startPromise;
-            if (!result.retired) {
-                this.currentServer = result;
-            }
-            return result;
-        }
-        finally {
-            this.startPromise = null;
-        }
-    }
-    async rotateCurrentServer() {
-        const existing = this.currentServer;
-        if (existing) {
-            existing.retired = true;
-            this.retiredServers.add(existing);
-            this.currentServer = null;
-            this.cleanupRetiredServers();
-        }
-        if (this.startPromise) {
-            const pending = await this.startPromise;
-            pending.retired = true;
-            this.retiredServers.add(pending);
-            this.currentServer = null;
-            this.cleanupRetiredServers();
-        }
-    }
-    async startServer() {
-        const port = await findAvailablePort();
-        const url = `http://127.0.0.1:${port}`;
-        const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
-        return new Promise((resolve, reject) => {
-            const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
-                detached: process.platform !== "win32",
-                stdio: ["ignore", "pipe", "pipe"],
-                ...createProviderEnvSpec({ runtimeSettings: this.runtimeSettings }),
-            });
-            let started = false;
-            let stderrBuffer = "";
-            let stdoutBuffer = "";
-            const STARTUP_BUFFER_CAP = 8192;
-            const appendCapped = (current, chunk) => {
-                if (current.length >= STARTUP_BUFFER_CAP) {
-                    return current;
-                }
-                const remaining = STARTUP_BUFFER_CAP - current.length;
-                return current + chunk.slice(0, remaining);
-            };
-            const buildStartupErrorMessage = (headline) => {
-                const sections = [headline];
-                const stderrTrimmed = stderrBuffer.trim();
-                if (stderrTrimmed.length > 0) {
-                    sections.push(`stderr: ${stderrTrimmed}`);
-                }
-                const stdoutTrimmed = stdoutBuffer.trim();
-                if (stdoutTrimmed.length > 0) {
-                    sections.push(`stdout: ${stdoutTrimmed}`);
-                }
-                return sections.join("\n");
-            };
-            const timeout = setTimeout(() => {
-                if (!started) {
-                    reject(new Error(buildStartupErrorMessage("OpenCode server startup timeout")));
-                }
-            }, 30000);
-            serverProcess.stdout?.on("data", (data) => {
-                const output = data.toString();
-                stdoutBuffer = appendCapped(stdoutBuffer, output);
-                if (output.includes("listening on") && !started) {
-                    started = true;
-                    clearTimeout(timeout);
-                    resolve({
-                        process: serverProcess,
-                        port,
-                        url,
-                        refCount: 0,
-                        retired: false,
-                    });
-                }
-            });
-            serverProcess.stderr?.on("data", (data) => {
-                const output = data.toString();
-                stderrBuffer = appendCapped(stderrBuffer, output);
-                this.logger.error({ stderr: output.trim() }, "OpenCode server stderr");
-            });
-            serverProcess.on("error", (error) => {
-                clearTimeout(timeout);
-                const headline = error instanceof Error ? error.message : String(error);
-                reject(new Error(buildStartupErrorMessage(headline)));
-            });
-            serverProcess.on("exit", (code) => {
-                if (!started) {
-                    clearTimeout(timeout);
-                    reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
-                }
-                if (this.currentServer?.process === serverProcess) {
-                    this.currentServer = null;
-                }
-                for (const retired of Array.from(this.retiredServers)) {
-                    if (retired.process === serverProcess) {
-                        this.retiredServers.delete(retired);
-                    }
-                }
-            });
-        });
+    createClient(options) {
+        return createSdkOpenCodeClient(options);
     }
     async shutdown() {
-        const servers = [
-            ...(this.currentServer ? [this.currentServer] : []),
-            ...Array.from(this.retiredServers),
-        ];
-        await Promise.all(servers.map((server) => this.killServer(server)));
-        this.currentServer = null;
-        this.retiredServers.clear();
-    }
-    cleanupRetiredServers() {
-        for (const server of Array.from(this.retiredServers)) {
-            if (server.refCount === 0) {
-                this.retiredServers.delete(server);
-                void this.killServer(server);
-            }
-        }
-    }
-    async killServer(server) {
-        if (server.process.killed) {
-            return;
-        }
-        const result = await terminateWithTreeKill(server.process, {
-            gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
-            forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
-            onForceSignal: () => {
-                this.logger.warn({ timeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not exit after SIGTERM; sending SIGKILL");
-            },
-        });
-        if (result === "kill-timeout") {
-            this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
-        }
+        await this.serverManager.shutdown();
     }
 }
-OpenCodeServerManager.instance = null;
-OpenCodeServerManager.exitHandlerRegistered = false;
 export class OpenCodeAgentClient {
-    constructor(logger, runtimeSettings, storageRoot) {
+    constructor(logger, runtimeSettings, storageRoot, deps = {}) {
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
         this.modelContextWindows = new Map();
         this.logger = logger.child({ module: "agent", provider: "opencode" });
         this.runtimeSettings = runtimeSettings;
         this.storageRoot = storageRoot ?? resolveOpenCodeStorageRoot();
-        this.serverManager = OpenCodeServerManager.getInstance(this.logger, runtimeSettings);
+        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) {
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.serverManager.acquire({ force: false });
+        const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
@@ -921,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();
@@ -939,15 +747,15 @@ export class OpenCodeAgentClient {
             ...overrides,
         };
         const openCodeConfig = this.assertConfig(config);
-        const acquisition = await this.serverManager.acquire({ force: false });
+        const acquisition = await this.runtime.acquireServer({ force: false });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: openCodeConfig.cwd,
         });
         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();
@@ -955,9 +763,9 @@ export class OpenCodeAgentClient {
         }
     }
     async listModels(options) {
-        const acquisition = await this.serverManager.acquire({ force: options.force });
+        const acquisition = await this.runtime.acquireServer({ force: options.force });
         const { url } = acquisition.server;
-        const client = createOpencodeClient({
+        const client = this.runtime.createClient({
             baseUrl: url,
             directory: options.cwd,
         });
@@ -1001,10 +809,10 @@ export class OpenCodeAgentClient {
         }
     }
     async listModes(options) {
-        const acquisition = await this.serverManager.acquire({ force: options.force });
+        const acquisition = await this.runtime.acquireServer({ force: options.force });
         const { url } = acquisition.server;
         const directory = options.cwd;
-        const client = createOpencodeClient({ baseUrl: url, directory });
+        const client = this.runtime.createClient({ baseUrl: url, directory });
         try {
             const response = await withTimeout(client.app.agents({ directory }), 10000, "OpenCode app.agents timed out after 10s");
             if (response.error || !response.data) {
@@ -1041,7 +849,7 @@ export class OpenCodeAgentClient {
             let modelsValue = "Not checked";
             let status = formatDiagnosticStatus(available);
             try {
-                const { url } = await this.serverManager.ensureRunning();
+                const { url } = await this.runtime.ensureServerRunning();
                 serverStatus = `Running (${url})`;
             }
             catch (error) {
@@ -1784,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;
@@ -1811,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() {
@@ -1856,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();
@@ -1980,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,
@@ -1998,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",
@@ -2007,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",
@@ -2024,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") {
@@ -2041,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",
@@ -2056,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({
@@ -2078,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;
         }
@@ -2088,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();
@@ -2126,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 {