@getpaseo/server 0.1.76 → 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";
@@ -25,7 +24,7 @@ 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 DEFAULT_MODES = [
     {
@@ -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 = [
@@ -505,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,
@@ -548,84 +504,13 @@ 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);
-}
-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 readOpenCodeTextFromParts(parts) {
-    return parts
-        .filter((part) => part.type === "text" && typeof part.text === "string")
-        .map((part) => part.text?.trim() ?? "")
-        .filter(Boolean)
-        .join("\n\n");
-}
-async function findJsonFiles(root) {
-    let entries;
-    try {
-        entries = await readdir(root, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    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")));
-    }
-    catch {
-        return null;
-    }
-}
 function normalizeOpenCodeSessionTitle(title) {
     const normalized = title?.trim();
     return normalized ? normalized : null;
@@ -633,12 +518,6 @@ function normalizeOpenCodeSessionTitle(title) {
 function getOpenCodeSessionTimestamp(session) {
     return session.time?.updated ?? session.time?.created ?? 0;
 }
-function getOpenCodeMessageTimestamp(message) {
-    return message.time?.created ?? message.time?.completed ?? 0;
-}
-function getOpenCodePartTimestamp(part) {
-    return part.time?.start ?? part.time?.end ?? 0;
-}
 function resolveOpenCodeReplayTimestamp(params) {
     const timedPart = params.part;
     const partTimestamp = timedPart?.time?.start ??
@@ -688,6 +567,82 @@ function buildOpenCodeReplayPartTimelineEvent(params) {
         part,
     });
 }
+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 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 readOpenCodeMessageAgent(message) {
+    const agent = message.info.agent;
+    return typeof agent === "string" && agent.trim() ? agent : undefined;
+}
+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,
     buildOpenCodeModelContextWindowLookup,
@@ -723,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));
@@ -752,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();
@@ -760,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 });
@@ -778,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();
@@ -858,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;
@@ -978,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
@@ -1634,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;
@@ -1661,6 +1661,9 @@ 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.config = config;
         this.client = client;
@@ -1671,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;
@@ -1767,22 +1771,17 @@ 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) {
@@ -1815,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,
@@ -1844,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) => {
@@ -1929,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,
@@ -2020,16 +2018,15 @@ 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;
         }
         const translated = await this.translateEvent(event);
         this.traceOpenCode("provider.opencode.parsed_event", {
@@ -2042,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);
@@ -2054,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", {
@@ -2078,8 +2074,6 @@ class OpenCodeAgentSession {
             this.runningToolCalls.clear();
         }
         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);
     }
@@ -2114,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", {
@@ -2149,39 +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 buildOpenCodeReplayTimelineEvent({
-                        item: { type: "user_message", text },
-                        message: info,
-                    });
-                }
-            }
-            else {
-                let emittedAssistantText = false;
-                for (const part of parts) {
-                    if (part.type === "text" && part.text) {
-                        emittedAssistantText = true;
-                    }
-                    const event = buildOpenCodeReplayPartTimelineEvent({ part, message: info });
-                    if (event) {
-                        yield event;
-                    }
-                }
-                if (!emittedAssistantText) {
-                    const text = stringifyStructuredAssistantMessage(info.structured);
-                    if (text) {
-                        yield buildOpenCodeReplayTimelineEvent({
-                            item: { type: "assistant_message", text },
-                            message: info,
-                        });
-                    }
-                }
+        for (const message of response.data) {
+            for (const event of buildOpenCodeReplayTimelineEvents(message)) {
+                yield event;
             }
         }
     }
@@ -2207,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);
@@ -2280,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,
@@ -2293,7 +2257,6 @@ class OpenCodeAgentSession {
                 logger: this.logger,
             });
             await this.deleteProviderSessionIfEphemeral();
-            this.subscribers.clear();
             this.activeForegroundTurnId = null;
         }
         finally {