@getpaseo/server 0.1.75 → 0.1.77

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

@@ -1,7 +1,6 @@
-import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import path from "node:path";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
+import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
 import { createProviderEnvSpec } from "../provider-launch-config.js";
@@ -14,6 +13,7 @@ import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnos
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { createSdkOpenCodeClient, } from "./opencode/runtime.js";
+import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
 const OPENCODE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -24,9 +24,8 @@ const OPENCODE_CAPABILITIES = {
 };
 const OPENCODE_BUILD_MODE_ID = "build";
 const OPENCODE_FULL_ACCESS_MODE_ID = "full-access";
-const OPENCODE_STORAGE_SESSION_LIMIT = 200;
+const OPENCODE_PERSISTED_SESSION_LIMIT = 200;
 const OPENCODE_PENDING_ABORT_START_TIMEOUT_MS = 10000;
-const OPENCODE_RETRY_STATUS_FAILURE_MS = 10000;
 const DEFAULT_MODES = [
     {
         id: OPENCODE_BUILD_MODE_ID,
@@ -44,44 +43,6 @@ const DEFAULT_MODES = [
         description: "Automatically approves all tool permission prompts for the session",
     },
 ];
-const OpenCodeStoredSessionSchema = z
-    .object({
-    id: z.string().min(1),
-    directory: z.string().min(1),
-    title: z.string().nullable().optional(),
-    time: z
-        .object({
-        created: z.number().optional(),
-        updated: z.number().optional(),
-    })
-        .optional(),
-})
-    .passthrough();
-const OpenCodeStoredMessageSchema = z
-    .object({
-    id: z.string().min(1),
-    sessionID: z.string().min(1),
-    role: z.string().optional(),
-    time: z
-        .object({
-        created: z.number().optional(),
-        completed: z.number().optional(),
-    })
-        .optional(),
-})
-    .passthrough();
-const OpenCodeStoredPartSchema = z
-    .object({
-    type: z.string().optional(),
-    text: z.string().optional(),
-    time: z
-        .object({
-        start: z.number().optional(),
-        end: z.number().optional(),
-    })
-        .optional(),
-})
-    .passthrough();
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
 const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
@@ -389,7 +350,9 @@ function buildOpenCodeModelContextWindowLookup(providers) {
     }
     const connectedProviderIds = new Set(providers.connected ?? []);
     for (const provider of providers.all ?? []) {
-        if (!connectedProviderIds.has(provider.id)) {
+        // Providers with source "api" are managed by the OpenCode console/subscription and are
+        // usable even though they don't appear in `connected` (which only lists env/config providers).
+        if (!connectedProviderIds.has(provider.id) && provider.source !== "api") {
             continue;
         }
         for (const [modelId, modelDefinition] of Object.entries(provider.models ?? {})) {
@@ -503,35 +466,30 @@ function buildOpenCodePromptParts(prompt) {
     }
     return output;
 }
-function resolveOpenCodeStorageRoot() {
-    const xdgDataHome = process.env.XDG_DATA_HOME;
-    const dataHome = typeof xdgDataHome === "string" && xdgDataHome.trim().length > 0
-        ? xdgDataHome
-        : path.join(homedir(), ".local", "share");
-    return path.join(dataHome, "opencode", "storage");
-}
-async function collectOpenCodePersistedAgentsFromStorage(storageRoot, options) {
-    const sessions = await readOpenCodeStoredSessions(path.join(storageRoot, "session"));
-    const limit = options?.limit ?? OPENCODE_STORAGE_SESSION_LIMIT;
+async function collectOpenCodePersistedAgentsFromSdk(client, options) {
+    const limit = options?.limit ?? OPENCODE_PERSISTED_SESSION_LIMIT;
+    const sessionListLimit = options?.cwd ? Math.max(limit, OPENCODE_PERSISTED_SESSION_LIMIT) : limit;
+    const response = await client.experimental.session.list({
+        archived: true,
+        roots: true,
+        limit: sessionListLimit,
+    });
+    if (response.error) {
+        throw new Error(`Failed to list OpenCode sessions: ${JSON.stringify(response.error)}`);
+    }
+    const sessions = response.data ?? [];
+    const matchesCwd = options?.cwd ? createPathEquivalenceMatcher(options.cwd) : null;
     const candidates = sessions
-        .filter((session) => !options?.cwd || session.directory === options.cwd)
+        .filter((session) => !matchesCwd || matchesCwd(session.directory))
         .sort((left, right) => getOpenCodeSessionTimestamp(right) - getOpenCodeSessionTimestamp(left))
         .slice(0, limit);
-    return await Promise.all(candidates.map((session) => buildOpenCodePersistedAgentDescriptor(storageRoot, session)));
+    return await Promise.all(candidates.map((session) => buildOpenCodePersistedAgentDescriptor(client, session)));
 }
-async function readOpenCodeStoredSessions(sessionRoot) {
-    const files = await findJsonFiles(sessionRoot);
-    const sessions = [];
-    for (const file of files) {
-        const parsed = await readJsonFile(file, OpenCodeStoredSessionSchema);
-        if (parsed) {
-            sessions.push(parsed);
-        }
-    }
-    return sessions;
-}
-async function buildOpenCodePersistedAgentDescriptor(storageRoot, session) {
-    const timeline = await readOpenCodeSessionTimeline(storageRoot, session.id);
+async function buildOpenCodePersistedAgentDescriptor(client, session) {
+    const messages = await readOpenCodeSessionMessagesFromSdk(client, session);
+    const timeline = buildOpenCodeSessionTimeline(messages);
+    const modeId = resolveOpenCodePersistedSessionModeId(session, messages);
+    const model = resolveOpenCodePersistedSessionModel(session, messages);
     return {
         provider: "opencode",
         sessionId: session.id,
@@ -546,96 +504,144 @@ async function buildOpenCodePersistedAgentDescriptor(storageRoot, session) {
                 provider: "opencode",
                 cwd: session.directory,
                 title: normalizeOpenCodeSessionTitle(session.title),
+                ...(modeId ? { modeId } : {}),
+                ...(model ? { model } : {}),
             },
         },
         timeline,
     };
 }
-async function readOpenCodeSessionTimeline(storageRoot, sessionId) {
-    const messageRoot = path.join(storageRoot, "message", sessionId);
-    const messageFiles = await findJsonFiles(messageRoot);
-    const messages = [];
-    for (const file of messageFiles) {
-        const parsed = await readJsonFile(file, OpenCodeStoredMessageSchema);
-        if (parsed?.sessionID === sessionId) {
-            messages.push(parsed);
-        }
-    }
-    const timeline = [];
-    for (const message of messages.sort((left, right) => getOpenCodeMessageTimestamp(left) - getOpenCodeMessageTimestamp(right))) {
-        const text = await readOpenCodeMessageText(storageRoot, message.id);
-        if (!text) {
-            continue;
-        }
-        if (message.role === "user") {
-            timeline.push({ type: "user_message", text, messageId: message.id });
-        }
-        else if (message.role === "assistant") {
-            timeline.push({ type: "assistant_message", text });
-        }
-    }
-    return timeline;
-}
-async function readOpenCodeMessageText(storageRoot, messageId) {
-    const parts = await readOpenCodeStoredParts(storageRoot, messageId);
-    return readOpenCodeTextFromParts(parts);
+function normalizeOpenCodeSessionTitle(title) {
+    const normalized = title?.trim();
+    return normalized ? normalized : null;
 }
-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) {
-            parts.push(parsed);
-        }
-    }
-    return parts.sort((left, right) => getOpenCodePartTimestamp(left) - getOpenCodePartTimestamp(right));
+function getOpenCodeSessionTimestamp(session) {
+    return session.time?.updated ?? session.time?.created ?? 0;
 }
-function readOpenCodeTextFromParts(parts) {
-    return parts
-        .filter((part) => part.type === "text" && typeof part.text === "string")
-        .map((part) => part.text?.trim() ?? "")
-        .filter(Boolean)
-        .join("\n\n");
+function resolveOpenCodeReplayTimestamp(params) {
+    const timedPart = params.part;
+    const partTimestamp = timedPart?.time?.start ??
+        timedPart?.time?.end ??
+        params.message.time?.created ??
+        params.message.time?.completed;
+    return normalizeProviderReplayTimestamp(partTimestamp);
+}
+function buildOpenCodeReplayTimelineEvent(params) {
+    const timestamp = resolveOpenCodeReplayTimestamp({
+        message: params.message,
+        part: params.part,
+    });
+    return {
+        type: "timeline",
+        provider: "opencode",
+        item: params.item,
+        ...(timestamp ? { timestamp } : {}),
+    };
 }
-async function findJsonFiles(root) {
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
+function buildOpenCodeReplayPartTimelineEvent(params) {
+    const { part, message } = params;
+    if (part.type === "text" && part.text) {
+        return buildOpenCodeReplayTimelineEvent({
+            item: { type: "assistant_message", text: part.text },
+            message,
+            part,
+        });
     }
-    catch {
-        return [];
+    if (part.type === "reasoning" && part.text) {
+        return buildOpenCodeReplayTimelineEvent({
+            item: { type: "reasoning", text: part.text },
+            message,
+            part,
+        });
     }
-    const files = await Promise.all(entries.map(async (entry) => {
-        const entryPath = path.join(root, entry.name);
-        if (entry.isDirectory()) {
-            return findJsonFiles(entryPath);
-        }
-        return entry.isFile() && entry.name.endsWith(".json") ? [entryPath] : [];
-    }));
-    return files.flat();
-}
-async function readJsonFile(file, schema) {
-    try {
-        return schema.parse(JSON.parse(await readFile(file, "utf8")));
+    if (part.type !== "tool") {
+        return null;
     }
-    catch {
+    const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
+    if (!parsedToolPart.success || !parsedToolPart.data) {
         return null;
     }
+    return buildOpenCodeReplayTimelineEvent({
+        item: parsedToolPart.data,
+        message,
+        part,
+    });
 }
-function normalizeOpenCodeSessionTitle(title) {
-    const normalized = title?.trim();
-    return normalized ? normalized : null;
+async function readOpenCodeSessionMessagesFromSdk(client, session) {
+    const response = await client.session.messages({
+        sessionID: session.id,
+        directory: session.directory,
+    });
+    if (response.error || !response.data) {
+        return [];
+    }
+    return response.data;
 }
-function getOpenCodeSessionTimestamp(session) {
-    return session.time?.updated ?? session.time?.created ?? 0;
+function buildOpenCodeSessionTimeline(messages) {
+    return messages.flatMap((message) => buildOpenCodeReplayTimelineEvents(message).map((event) => event.item));
+}
+function resolveOpenCodePersistedSessionModeId(session, messages) {
+    const agent = session.agent ?? messages.map(readOpenCodeMessageAgent).find(Boolean);
+    return agent ? normalizeOpenCodeModeId(agent) : undefined;
 }
-function getOpenCodeMessageTimestamp(message) {
-    return message.time?.created ?? message.time?.completed ?? 0;
+function readOpenCodeMessageAgent(message) {
+    const agent = message.info.agent;
+    return typeof agent === "string" && agent.trim() ? agent : undefined;
 }
-function getOpenCodePartTimestamp(part) {
-    return part.time?.start ?? part.time?.end ?? 0;
+function resolveOpenCodePersistedSessionModel(session, messages) {
+    if (session.model) {
+        return buildOpenCodeModelLookupKey(session.model.providerID, session.model.id);
+    }
+    const model = messages.map(readOpenCodeMessageModel).find(Boolean);
+    return model ? buildOpenCodeModelLookupKey(model.providerID, model.modelID) : undefined;
+}
+function readOpenCodeMessageModel(message) {
+    const { info } = message;
+    if (info.role === "user") {
+        return info.model;
+    }
+    return {
+        providerID: info.providerID,
+        modelID: info.modelID,
+    };
+}
+function buildOpenCodeReplayTimelineEvents(message) {
+    const { info, parts } = message;
+    if (info.role === "user") {
+        const text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+        return text
+            ? [
+                buildOpenCodeReplayTimelineEvent({
+                    item: { type: "user_message", text, messageId: info.id },
+                    message: info,
+                }),
+            ]
+            : [];
+    }
+    const events = [];
+    let emittedAssistantText = false;
+    for (const part of parts) {
+        if (part.type === "text" && part.text) {
+            emittedAssistantText = true;
+        }
+        const event = buildOpenCodeReplayPartTimelineEvent({ part, message: info });
+        if (event) {
+            events.push(event);
+        }
+    }
+    if (!emittedAssistantText) {
+        const text = stringifyStructuredAssistantMessage(info.structured);
+        if (text) {
+            events.push(buildOpenCodeReplayTimelineEvent({
+                item: { type: "assistant_message", text },
+                message: info,
+            }));
+        }
+    }
+    return events;
 }
 export const __openCodeInternals = {
     buildOpenCodePromptParts,
@@ -672,13 +678,12 @@ class ProductionOpenCodeRuntime {
     }
 }
 export class OpenCodeAgentClient {
-    constructor(logger, runtimeSettings, storageRoot, deps = {}) {
+    constructor(logger, runtimeSettings, 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.runtime =
             deps.runtime ??
                 new ProductionOpenCodeRuntime(OpenCodeServerManager.getInstance(this.logger, runtimeSettings));
@@ -701,7 +706,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, this.storageRoot, new Map(this.modelContextWindows), acquisition.release, options?.persistSession, launchContext?.agentId);
+            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, new Map(this.modelContextWindows), acquisition.release, options?.persistSession, launchContext?.agentId);
         }
         catch (error) {
             acquisition.release();
@@ -709,14 +714,16 @@ export class OpenCodeAgentClient {
         }
     }
     async resumeSession(handle, overrides, launchContext) {
-        const cwd = overrides?.cwd ?? handle.metadata?.cwd;
+        const metadata = (handle.metadata ?? {});
+        const cwd = overrides?.cwd ?? metadata.cwd;
         if (!cwd) {
             throw new Error("OpenCode resume requires the original working directory");
         }
         const config = {
+            ...metadata,
+            ...overrides,
             provider: "opencode",
             cwd,
-            ...overrides,
         };
         const openCodeConfig = this.assertConfig(config);
         const acquisition = await this.runtime.acquireServer({ force: false });
@@ -727,7 +734,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, launchContext?.agentId);
+            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, new Map(this.modelContextWindows), acquisition.release, undefined, launchContext?.agentId);
         }
         catch (error) {
             acquisition.release();
@@ -752,17 +759,21 @@ export class OpenCodeAgentClient {
             if (!providers) {
                 return [];
             }
-            // Only include models from connected providers (ones that are actually available)
             const connectedProviderIds = new Set(providers.connected);
-            // Fail fast if no providers are connected
-            if (connectedProviderIds.size === 0) {
-                throw new Error("OpenCode has no connected providers. Please authenticate with at least one provider (e.g., openai, anthropic) or set appropriate environment variables (e.g., OPENAI_API_KEY).");
+            // Providers with source "api" are managed by the OpenCode console/subscription (e.g. Pi
+            // coding agent). They do not appear in `connected` (which only lists env/config providers)
+            // but are fully usable — OpenCode authenticates them internally via the console session.
+            const isAccessible = (provider) => connectedProviderIds.has(provider.id) || provider.source === "api";
+            // Fail fast if no providers are accessible at all
+            if (!providers.all.some(isAccessible)) {
+                throw new Error("OpenCode has no connected providers. Please authenticate with at least one provider " +
+                    "(e.g., openai, anthropic), set appropriate environment variables (e.g., OPENAI_API_KEY), " +
+                    "or log in to OpenCode Go via the console.");
             }
             const models = [];
             this.modelContextWindows.clear();
             for (const provider of providers.all) {
-                // Skip providers that aren't connected/configured
-                if (!connectedProviderIds.has(provider.id)) {
+                if (!isAccessible(provider)) {
                     continue;
                 }
                 for (const [modelId, model] of Object.entries(provider.models)) {
@@ -803,8 +814,37 @@ export class OpenCodeAgentClient {
             acquisition.release();
         }
     }
+    async listCommands(config) {
+        const openCodeConfig = this.assertConfig(config);
+        const acquisition = await this.runtime.acquireServer({ force: false });
+        const { url } = acquisition.server;
+        const client = this.runtime.createClient({
+            baseUrl: url,
+            directory: openCodeConfig.cwd,
+        });
+        try {
+            return await listOpenCodeCommandsFromSdk(client, openCodeConfig.cwd);
+        }
+        finally {
+            acquisition.release();
+        }
+    }
+    async listFeatures(_config) {
+        return [];
+    }
     async listPersistedAgents(options) {
-        return collectOpenCodePersistedAgentsFromStorage(this.storageRoot, options);
+        const acquisition = await this.runtime.acquireServer({ force: false });
+        const { url } = acquisition.server;
+        const client = this.runtime.createClient({
+            baseUrl: url,
+            directory: options?.cwd ?? "",
+        });
+        try {
+            return await collectOpenCodePersistedAgentsFromSdk(client, options);
+        }
+        finally {
+            acquisition.release();
+        }
     }
     async isAvailable() {
         const command = this.runtimeSettings?.command;
@@ -923,6 +963,21 @@ function stringifyStructuredAssistantMessage(value) {
         return null;
     }
 }
+async function listOpenCodeCommandsFromSdk(client, directory) {
+    const result = await client.command.list({ directory });
+    const commandsByName = new Map(OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, command]));
+    if (result.error || !result.data) {
+        return Array.from(commandsByName.values());
+    }
+    for (const cmd of result.data) {
+        commandsByName.set(cmd.name, {
+            name: cmd.name,
+            description: cmd.description ?? "",
+            argumentHint: cmd.hints?.length ? cmd.hints.join(" ") : "",
+        });
+    }
+    return Array.from(commandsByName.values());
+}
 function readOpenCodeRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -1579,7 +1634,7 @@ function unwrapOpenCodeGlobalEvent(event) {
     return null;
 }
 class OpenCodeAgentSession {
-    constructor(config, client, sessionId, logger, _storageRoot, modelContextWindowsByModelKey = new Map(), releaseServer, persistSession = true, agentId) {
+    constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), releaseServer, persistSession = true, agentId) {
         this.agentId = agentId;
         this.provider = "opencode";
         this.capabilities = OPENCODE_CAPABILITIES;
@@ -1606,8 +1661,10 @@ class OpenCodeAgentSession {
         this.subAgentsByCallId = new Map();
         this.subAgentCallIdByChildSessionId = new Map();
         this.pendingChildToolPartsBySessionId = new Map();
+        this.eventStreamAbortController = null;
+        this.eventStreamReady = null;
+        this.closed = false;
         this.deletedFromProvider = false;
-        this.retryFailureTimer = null;
         this.config = config;
         this.client = client;
         this.sessionId = sessionId;
@@ -1617,6 +1674,7 @@ class OpenCodeAgentSession {
         this.releaseServer = releaseServer ?? null;
         this.persistSession = persistSession;
         this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(config.model);
+        this.startEventStream();
     }
     get id() {
         return this.sessionId;
@@ -1703,7 +1761,6 @@ class OpenCodeAgentSession {
         this.subAgentsByCallId.clear();
         this.subAgentCallIdByChildSessionId.clear();
         this.pendingChildToolPartsBySessionId.clear();
-        this.clearRetryFailureTimer();
         const turnAbortController = new AbortController();
         this.abortController = turnAbortController;
         await this.ensureMcpServersConfigured();
@@ -1714,22 +1771,18 @@ class OpenCodeAgentSession {
         const thinkingOptionId = this.config.thinkingOptionId;
         const effectiveVariant = thinkingOptionId ?? undefined;
         const effectiveMode = resolveOpenCodeRuntimeAgentId(this.currentMode);
-        const turnId = this.createTurnId();
-        this.activeForegroundTurnId = turnId;
-        // OpenCode's /event SSE endpoint does NOT replay past events. If we send
-        // the prompt before our reader is connected, terminal events fired early
-        // by the server (e.g. session.error / session.idle for invalid model or
-        // mode) are missed and the turn hangs forever. Wait for the subscription
-        // to be established before sending anything.
-        const subscriptionReady = createDeferred();
-        void this.consumeEventStream(turnId, turnAbortController, subscriptionReady);
         try {
-            await subscriptionReady.promise;
+            await this.ensureEventStreamReady();
         }
-        catch {
-            // consumeEventStream already finished the turn with the subscription error.
-            return { turnId };
+        catch (error) {
+            if (this.abortController === turnAbortController) {
+                this.abortController = null;
+            }
+            throw error;
         }
+        const turnId = this.createTurnId();
+        this.activeForegroundTurnId = turnId;
+        this.notifySubscribers({ type: "turn_started", provider: "opencode" }, turnId);
         const slashCommand = await this.resolveSlashCommandInvocation(prompt);
         if (slashCommand) {
             if (slashCommand.commandName === "compact" || slashCommand.commandName === "summarize") {
@@ -1761,12 +1814,8 @@ class OpenCodeAgentSession {
                 });
                 return { turnId };
             }
-            // command() blocks until the server finishes processing. OpenCode's SSE
-            // endpoint does NOT replay past events, so if the command completes before
-            // our SSE reader connects, we miss `session.idle` and the turn hangs.
-            // Handle both success and error in the response handler as a fallback —
-            // finishForegroundTurn's guard prevents duplicate terminal events if the
-            // SSE stream already delivered the event.
+            // command() is only dispatch acknowledgement. OpenCode session events are
+            // the source of truth for when the command turn becomes idle or fails.
             void this.client.session
                 .command({
                 sessionID: this.sessionId,
@@ -1790,9 +1839,6 @@ class OpenCodeAgentSession {
                     const errorMsg = toDiagnosticErrorMessage(response.error);
                     this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: errorMsg }, turnId);
                 }
-                else {
-                    this.finishForegroundTurn({ type: "turn_completed", provider: "opencode", usage: undefined }, turnId);
-                }
                 return;
             })
                 .catch((err) => {
@@ -1875,89 +1921,95 @@ class OpenCodeAgentSession {
             this.subscribers.delete(callback);
         };
     }
-    async consumeEventStream(turnId, turnAbortController, subscriptionReady) {
+    startEventStream() {
+        void this.ensureEventStreamReady().catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId }, "OpenCode event stream failed");
+        });
+    }
+    ensureEventStreamReady() {
+        if (this.eventStreamReady) {
+            return this.eventStreamReady.promise;
+        }
+        const eventStreamAbortController = new AbortController();
+        const eventStreamReady = createDeferred();
+        this.eventStreamAbortController = eventStreamAbortController;
+        this.eventStreamReady = eventStreamReady;
+        void this.consumeEventStream(eventStreamAbortController, eventStreamReady).finally(() => {
+            if (this.eventStreamAbortController === eventStreamAbortController) {
+                this.eventStreamAbortController = null;
+                this.eventStreamReady = null;
+            }
+        });
+        return eventStreamReady.promise;
+    }
+    async consumeEventStream(eventStreamAbortController, eventStreamReady) {
         this.traceOpenCode("provider.opencode.subscribe.start", {
-            turnId,
             sessionId: this.sessionId,
             cwd: this.config.cwd,
         });
+        let eventStreamReadyResolved = false;
         try {
             const result = await this.client.global.event({
-                signal: turnAbortController.signal,
+                signal: eventStreamAbortController.signal,
                 sseMaxRetryAttempts: 0,
             });
+            eventStreamReadyResolved = true;
+            this.traceOpenCode("provider.opencode.subscribe.ready", {
+                sessionId: this.sessionId,
+            });
+            eventStreamReady.resolve();
             let eventCount = 0;
-            let subscriptionReadyResolved = false;
             for await (const rawEvent of result.stream) {
                 eventCount += 1;
-                if (!subscriptionReadyResolved) {
-                    subscriptionReadyResolved = true;
-                    this.traceOpenCode("provider.opencode.subscribe.ready", {
-                        turnId,
-                        sessionId: this.sessionId,
-                    });
-                    subscriptionReady.resolve();
-                }
-                const shouldContinue = await this.consumeOpenCodeStreamEvent({
-                    rawEvent,
-                    eventCount,
-                    turnId,
-                    turnAbortController,
-                });
-                if (!shouldContinue) {
-                    return;
-                }
+                await this.consumeOpenCodeStreamEvent({ rawEvent, eventCount });
             }
             this.traceOpenCode("provider.opencode.stream.eof", {
-                turnId,
                 eventCount,
-                aborted: turnAbortController.signal.aborted,
-                stillActive: this.activeForegroundTurnId === turnId,
+                aborted: eventStreamAbortController.signal.aborted,
+                activeTurnId: this.activeForegroundTurnId,
             });
-            if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
-                this.traceOpenCode("provider.opencode.turn.fail_eof", { turnId, eventCount });
-                if (!subscriptionReadyResolved) {
-                    subscriptionReady.reject(new Error("OpenCode event stream ended before it became ready"));
+            if (!eventStreamAbortController.signal.aborted) {
+                if (!eventStreamReadyResolved) {
+                    eventStreamReady.reject(new Error("OpenCode event stream ended before it became ready"));
+                }
+                const activeTurnId = this.activeForegroundTurnId;
+                if (activeTurnId) {
+                    this.traceOpenCode("provider.opencode.turn.fail_eof", {
+                        turnId: activeTurnId,
+                        eventCount,
+                    });
+                    this.finishForegroundTurn({
+                        type: "turn_failed",
+                        provider: "opencode",
+                        error: "OpenCode event stream ended before the turn reached a terminal state",
+                    }, activeTurnId);
                 }
-                this.finishForegroundTurn({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: "OpenCode event stream ended before the turn reached a terminal state",
-                }, turnId);
             }
         }
         catch (error) {
             this.traceOpenCode("provider.opencode.subscribe.error", {
-                turnId,
+                turnId: this.activeForegroundTurnId ?? undefined,
                 error: error instanceof Error ? { name: error.name, message: error.message } : String(error),
             });
-            subscriptionReady.reject(error);
-            if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
+            if (!eventStreamReadyResolved) {
+                eventStreamReady.reject(error);
+            }
+            const activeTurnId = this.activeForegroundTurnId;
+            if (!eventStreamAbortController.signal.aborted && activeTurnId) {
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
                     error: toDiagnosticErrorMessage(error),
-                }, turnId);
-            }
-        }
-        finally {
-            if (turnAbortController.signal.aborted) {
-                this.finishForegroundTurn({
-                    type: "turn_canceled",
-                    provider: "opencode",
-                    reason: "interrupted",
-                }, turnId);
-            }
-            if (this.abortController === turnAbortController && this.activeForegroundTurnId !== turnId) {
-                this.abortController = null;
+                }, activeTurnId);
             }
         }
     }
     async consumeOpenCodeStreamEvent(params) {
-        const { rawEvent, eventCount, turnId, turnAbortController } = params;
+        const { rawEvent, eventCount } = params;
+        const turnId = this.activeForegroundTurnId;
         const event = unwrapOpenCodeGlobalEvent(rawEvent);
         this.traceOpenCode("provider.opencode.raw_event", {
-            turnId,
+            turnId: turnId ?? undefined,
             n: eventCount,
             type: event?.type,
             rawType: readOpenCodeRecord(rawEvent)?.type,
@@ -1966,18 +2018,16 @@ class OpenCodeAgentSession {
             properties: event?.properties,
         });
         if (!event) {
-            return true;
+            return;
         }
-        if (turnAbortController.signal.aborted || this.activeForegroundTurnId !== turnId) {
+        if (!turnId) {
             this.traceOpenCode("provider.opencode.event.skip", {
-                turnId,
                 n: eventCount,
-                aborted: turnAbortController.signal.aborted,
-                activeTurnId: this.activeForegroundTurnId,
+                reason: "no_active_turn",
+                type: event.type,
             });
-            return false;
+            return;
         }
-        this.armRetryFailureTimerForStatus(event, turnId);
         const translated = await this.translateEvent(event);
         this.traceOpenCode("provider.opencode.parsed_event", {
             turnId,
@@ -1989,7 +2039,7 @@ class OpenCodeAgentSession {
         for (const e of translated) {
             if (this.activeForegroundTurnId !== turnId) {
                 this.traceOpenCode("provider.opencode.parsed_event.skip_active", { turnId, type: e.type });
-                return false;
+                return;
             }
             if (e.type === "timeline" && e.item.type === "tool_call") {
                 this.trackToolCall(e.item);
@@ -2001,11 +2051,10 @@ class OpenCodeAgentSession {
                     type: terminalEvent.type,
                 });
                 this.finishForegroundTurn(terminalEvent, turnId);
-                return false;
+                return;
             }
             this.notifySubscribers(e, turnId);
         }
-        return true;
     }
     finishForegroundTurn(event, turnId) {
         this.traceOpenCode("provider.opencode.finish_foreground_turn", {
@@ -2024,10 +2073,7 @@ class OpenCodeAgentSession {
         else {
             this.runningToolCalls.clear();
         }
-        this.clearRetryFailureTimer();
         this.activeForegroundTurnId = null;
-        // Abort the SSE connection so the SDK tears down the underlying fetch.
-        this.abortController?.abort();
         this.abortController = null;
         this.notifySubscribers(event, turnId);
     }
@@ -2038,37 +2084,6 @@ 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" };
@@ -2093,6 +2108,9 @@ class OpenCodeAgentSession {
         this.runningToolCalls.clear();
     }
     notifySubscribers(event, turnIdOverride) {
+        if (this.closed) {
+            return;
+        }
         const turnId = turnIdOverride ?? this.activeForegroundTurnId;
         const tagged = turnId ? { ...event, turnId } : event;
         this.traceOpenCode("provider.opencode.event_emit", {
@@ -2128,62 +2146,9 @@ class OpenCodeAgentSession {
         if (response.error || !response.data) {
             return;
         }
-        for (const { info, parts } of response.data) {
-            if (info.role === "user") {
-                const text = parts
-                    .filter((p) => p.type === "text")
-                    .map((p) => p.text)
-                    .join("");
-                if (text) {
-                    yield {
-                        type: "timeline",
-                        provider: "opencode",
-                        item: { type: "user_message", text },
-                    };
-                }
-            }
-            else {
-                let emittedAssistantText = false;
-                for (const part of parts) {
-                    if (part.type === "text" && part.text) {
-                        emittedAssistantText = true;
-                        yield {
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "assistant_message", text: part.text },
-                        };
-                        continue;
-                    }
-                    if (part.type === "reasoning" && part.text) {
-                        yield {
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "reasoning", text: part.text },
-                        };
-                        continue;
-                    }
-                    if (part.type !== "tool") {
-                        continue;
-                    }
-                    const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
-                    if (parsedToolPart.success && parsedToolPart.data) {
-                        yield {
-                            type: "timeline",
-                            provider: "opencode",
-                            item: parsedToolPart.data,
-                        };
-                    }
-                }
-                if (!emittedAssistantText) {
-                    const text = stringifyStructuredAssistantMessage(info.structured);
-                    if (text) {
-                        yield {
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "assistant_message", text },
-                        };
-                    }
-                }
+        for (const message of response.data) {
+            for (const event of buildOpenCodeReplayTimelineEvents(message)) {
+                yield event;
             }
         }
     }
@@ -2209,21 +2174,7 @@ class OpenCodeAgentSession {
         return this.currentMode;
     }
     async listCommands() {
-        const result = await this.client.command.list({
-            directory: this.config.cwd,
-        });
-        const commandsByName = new Map(OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, command]));
-        if (result.error || !result.data) {
-            return Array.from(commandsByName.values());
-        }
-        for (const cmd of result.data) {
-            commandsByName.set(cmd.name, {
-                name: cmd.name,
-                description: cmd.description ?? "",
-                argumentHint: cmd.hints?.length ? cmd.hints.join(" ") : "",
-            });
-        }
-        return Array.from(commandsByName.values());
+        return await listOpenCodeCommandsFromSdk(this.client, this.config.cwd);
     }
     async setMode(modeId) {
         this.currentMode = normalizeOpenCodeModeId(modeId);
@@ -2282,12 +2233,23 @@ class OpenCodeAgentSession {
             nativeHandle: this.sessionId,
             metadata: {
                 cwd: this.config.cwd,
+                ...(this.config.modeId ? { modeId: this.config.modeId } : {}),
+                ...(this.config.model ? { model: this.config.model } : {}),
             },
         };
     }
     async close() {
         try {
+            // Flip closed before clearing subscribers so any event the SDK delivers
+            // after the abort (between here and subscribers.clear) is swallowed by
+            // notifySubscribers instead of bubbling through provider-runner as an
+            // unhandled rejection in whichever test the daemon hops to next.
+            this.closed = true;
             this.abortController?.abort();
+            this.eventStreamAbortController?.abort();
+            this.eventStreamAbortController = null;
+            this.eventStreamReady = null;
+            this.subscribers.clear();
             await reconcileOpenCodeSessionClose({
                 client: this.client,
                 sessionId: this.sessionId,
@@ -2295,7 +2257,6 @@ class OpenCodeAgentSession {
                 logger: this.logger,
             });
             await this.deleteProviderSessionIfEphemeral();
-            this.subscribers.clear();
             this.activeForegroundTurnId = null;
         }
         finally {