@getpaseo/server 0.1.62 → 0.1.63

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

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
 import net from "node:net";
 import { z } from "zod";
-import { applyProviderEnv, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
+import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { spawnProcess } from "../../../utils/spawn.js";
@@ -140,20 +140,18 @@ function toOpenCodeMcpConfig(config) {
         enabled: true,
     };
 }
-function stringifyUnknownError(error) {
-    if (typeof error === "string") {
-        return error;
-    }
-    try {
-        return JSON.stringify(error);
+function toTerminalTurnEvent(event) {
+    if (event.type === "turn_failed") {
+        return {
+            type: "turn_failed",
+            provider: "opencode",
+            error: toDiagnosticErrorMessage(event.error),
+        };
     }
-    catch {
-        return String(error);
+    if (event.type === "turn_completed" || event.type === "turn_canceled") {
+        return event;
     }
-}
-function normalizeTurnFailureError(error) {
-    const normalized = stringifyUnknownError(error).trim();
-    return normalized.length > 0 ? normalized : "Unknown error";
+    return null;
 }
 function isOpenCodeNotFoundError(error) {
     return (typeof error === "object" &&
@@ -171,14 +169,14 @@ async function reconcileOpenCodeSessionClose(params) {
         if (response.error && !isOpenCodeNotFoundError(response.error)) {
             logger.warn({
                 sessionId,
-                error: normalizeTurnFailureError(response.error),
+                error: toDiagnosticErrorMessage(response.error),
             }, "Failed to abort OpenCode session during close");
         }
     }
     catch (error) {
         logger.warn({
             sessionId,
-            error: normalizeTurnFailureError(error),
+            error: toDiagnosticErrorMessage(error),
         }, "Failed to abort OpenCode session during close");
     }
     try {
@@ -190,14 +188,14 @@ async function reconcileOpenCodeSessionClose(params) {
         if (response.error && !isOpenCodeNotFoundError(response.error)) {
             logger.warn({
                 sessionId,
-                error: normalizeTurnFailureError(response.error),
+                error: toDiagnosticErrorMessage(response.error),
             }, "Failed to archive OpenCode session during close");
         }
     }
     catch (error) {
         logger.warn({
             sessionId,
-            error: normalizeTurnFailureError(error),
+            error: toDiagnosticErrorMessage(error),
         }, "Failed to archive OpenCode session during close");
     }
 }
@@ -216,18 +214,19 @@ function isOpenCodeHeadersTimeoutFailure(error) {
         if (!current) {
             continue;
         }
-        const normalized = stringifyUnknownError(current).trim().toLowerCase();
+        const normalized = toDiagnosticErrorMessage(current).trim().toLowerCase();
         if (normalized) {
             diagnostics.add(normalized);
         }
         if (typeof current === "object") {
             const record = current;
             for (const value of [record.message, record.code, record.name]) {
-                if (typeof value === "string") {
-                    const diagnostic = value.trim().toLowerCase();
-                    if (diagnostic) {
-                        diagnostics.add(diagnostic);
-                    }
+                if (typeof value !== "string") {
+                    continue;
+                }
+                const diagnostic = value.trim().toLowerCase();
+                if (diagnostic) {
+                    diagnostics.add(diagnostic);
                 }
             }
             if (record.cause) {
@@ -238,7 +237,7 @@ function isOpenCodeHeadersTimeoutFailure(error) {
     return [...diagnostics].some((diagnostic) => OPENCODE_HEADERS_TIMEOUT_TOKENS.some((token) => diagnostic.includes(token)));
 }
 function isAlreadyPresentMcpError(error) {
-    const normalized = stringifyUnknownError(error).toLowerCase();
+    const normalized = toDiagnosticErrorMessage(error).toLowerCase();
     return MCP_ALREADY_PRESENT_ERROR_TOKENS.some((token) => normalized.includes(token));
 }
 async function findAvailablePort() {
@@ -602,16 +601,39 @@ export class OpenCodeServerManager {
         return new Promise((resolve, reject) => {
             const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
                 stdio: ["ignore", "pipe", "pipe"],
-                env: applyProviderEnv(process.env, this.runtimeSettings),
+                ...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("OpenCode server startup timeout"));
+                    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);
@@ -625,16 +647,19 @@ export class OpenCodeServerManager {
                 }
             });
             serverProcess.stderr?.on("data", (data) => {
-                this.logger.error({ stderr: data.toString().trim() }, "OpenCode server stderr");
+                const output = data.toString();
+                stderrBuffer = appendCapped(stderrBuffer, output);
+                this.logger.error({ stderr: output.trim() }, "OpenCode server stderr");
             });
             serverProcess.on("error", (error) => {
                 clearTimeout(timeout);
-                reject(error);
+                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(`OpenCode server exited with code ${code}`));
+                    reject(new Error(buildStartupErrorMessage(`OpenCode server exited with code ${code}`)));
                 }
                 if (this.currentServer?.process === serverProcess) {
                     this.currentServer = null;
@@ -652,9 +677,7 @@ export class OpenCodeServerManager {
             ...(this.currentServer ? [this.currentServer] : []),
             ...Array.from(this.retiredServers),
         ];
-        for (const server of servers) {
-            await this.killServer(server);
-        }
+        await Promise.all(servers.map((server) => this.killServer(server)));
         this.currentServer = null;
         this.retiredServers.clear();
     }
@@ -671,13 +694,21 @@ export class OpenCodeServerManager {
             return;
         }
         await new Promise((resolve) => {
+            let pendingResolve = resolve;
+            const settle = () => {
+                if (!pendingResolve)
+                    return;
+                const fn = pendingResolve;
+                pendingResolve = null;
+                fn();
+            };
             const timeout = setTimeout(() => {
                 server.process.kill("SIGKILL");
-                resolve();
+                settle();
             }, 5000);
             server.process.on("exit", () => {
                 clearTimeout(timeout);
-                resolve();
+                settle();
             });
             server.process.kill("SIGTERM");
         });
@@ -839,7 +870,7 @@ export class OpenCodeAgentClient {
                 serverStatus = `Running (${url})`;
             }
             catch (error) {
-                serverStatus = `Unavailable (${normalizeTurnFailureError(error)})`;
+                serverStatus = `Unavailable (${toDiagnosticErrorMessage(error)})`;
             }
             if (available) {
                 try {
@@ -1039,310 +1070,316 @@ export function translateOpenCodeEvent(event, state) {
     const events = [];
     switch (event.type) {
         case "session.created":
-        case "session.updated": {
-            if (event.properties.info.id === state.sessionId) {
-                events.push({
-                    type: "thread_started",
-                    sessionId: state.sessionId,
-                    provider: "opencode",
-                });
-            }
-            break;
-        }
-        case "message.updated": {
-            const info = event.properties.info;
-            if (info.sessionID !== state.sessionId) {
-                break;
-            }
-            state.messageRoles.set(info.id, info.role);
-            if (info.role === "assistant") {
-                const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessage(info);
-                if (modelLookupKey) {
-                    const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
-                    if (contextWindowMaxTokens !== undefined) {
-                        state.onAssistantModelContextWindowResolved?.(contextWindowMaxTokens);
-                    }
-                }
-                if (!state.emittedStructuredMessageIds.has(info.id) && info.time?.completed !== undefined) {
-                    const text = stringifyStructuredAssistantMessage(info.structured);
-                    if (text) {
-                        state.emittedStructuredMessageIds.add(info.id);
-                        events.push({
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "assistant_message", text },
-                        });
-                    }
-                }
-            }
-            break;
-        }
-        case "message.part.updated": {
-            const part = event.properties.part;
-            if (part.sessionID !== state.sessionId) {
-                break;
-            }
-            const messageRole = state.messageRoles.get(part.messageID);
-            state.partTypes.set(part.id, part.type);
-            if (part.type === "text") {
-                const partKey = resolvePartDedupeKey(part, "text");
-                if (messageRole === "user") {
-                    break;
-                }
-                if (part.time?.end) {
-                    if (partKey && state.streamedPartKeys.delete(partKey)) {
-                        break;
-                    }
-                    if (part.text) {
-                        events.push({
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "assistant_message", text: part.text },
-                        });
-                    }
-                }
-            }
-            else if (part.type === "reasoning") {
-                const partKey = resolvePartDedupeKey(part, "reasoning");
-                if (part.time.end) {
-                    if (partKey && state.streamedPartKeys.delete(partKey)) {
-                        break;
-                    }
-                    if (part.text) {
-                        events.push({
-                            type: "timeline",
-                            provider: "opencode",
-                            item: { type: "reasoning", text: part.text },
-                        });
-                    }
-                }
-            }
-            else if (part.type === "tool") {
-                const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
-                if (parsedToolPart.success && parsedToolPart.data) {
-                    events.push({
-                        type: "timeline",
-                        provider: "opencode",
-                        item: parsedToolPart.data,
-                    });
-                }
-            }
-            else if (part.type === "compaction") {
-                events.push({
-                    type: "timeline",
-                    provider: "opencode",
-                    item: createCompactionTimelineItem("loading", part.auto ? "auto" : "manual"),
-                });
-            }
-            else if (part.type === "step-finish") {
-                mergeOpenCodeStepFinishUsage(state.accumulatedUsage, part);
-                if (hasNormalizedOpenCodeUsage(state.accumulatedUsage)) {
-                    events.push({
-                        type: "usage_updated",
-                        provider: "opencode",
-                        usage: { ...state.accumulatedUsage },
-                    });
-                }
-            }
+        case "session.updated":
+            appendOpenCodeSessionCreatedOrUpdated(event, state, events);
             break;
-        }
-        case "message.part.delta": {
-            const { sessionID, messageID, partID, field, delta } = event.properties;
-            if (sessionID !== state.sessionId) {
-                break;
-            }
-            if (!delta || !field) {
-                break;
-            }
-            const messageRole = messageID ? state.messageRoles.get(messageID) : undefined;
-            const knownPartType = partID ? state.partTypes.get(partID) : undefined;
-            const isReasoning = knownPartType === "reasoning" || field === "reasoning";
-            if (isReasoning) {
-                if (partID) {
-                    state.streamedPartKeys.add(`reasoning:${partID}`);
-                }
-                events.push({
-                    type: "timeline",
-                    provider: "opencode",
-                    item: { type: "reasoning", text: delta },
-                });
-            }
-            else if (field === "text") {
-                if (messageRole === "user") {
-                    break;
-                }
-                if (partID) {
-                    state.streamedPartKeys.add(`text:${partID}`);
-                }
-                events.push({
-                    type: "timeline",
-                    provider: "opencode",
-                    item: { type: "assistant_message", text: delta },
-                });
-            }
+        case "message.updated":
+            appendOpenCodeMessageUpdated(event, state, events);
             break;
-        }
-        case "permission.asked": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            const metadata = readOpenCodeRecord(event.properties.metadata);
-            const tool = readOpenCodeRecord(event.properties.tool);
-            const patterns = Array.isArray(event.properties.patterns)
-                ? event.properties.patterns.filter((value) => typeof value === "string")
-                : [];
-            const command = readPermissionField(metadata, PERMISSION_COMMAND_KEYS);
-            const cwd = readPermissionField(metadata, PERMISSION_CWD_KEYS);
-            const reason = readPermissionField(metadata, PERMISSION_REASON_KEYS);
-            const input = buildOpenCodePermissionInput({
-                patterns,
-                metadata,
-                tool,
-                command,
-            });
-            const detail = buildOpenCodePermissionDetail({
-                permission: event.properties.permission,
-                input,
-                command,
-                cwd,
-            });
-            const description = buildOpenCodePermissionDescription({
-                reason,
-                patterns,
-            });
-            events.push({
-                type: "permission_requested",
-                provider: "opencode",
-                request: {
-                    id: event.properties.id,
-                    provider: "opencode",
-                    name: event.properties.permission,
-                    kind: "tool",
-                    title: toHumanReadablePermissionTitle(event.properties.permission),
-                    ...(description ? { description } : {}),
-                    input,
-                    detail,
-                },
-            });
+        case "message.part.updated":
+            appendOpenCodeMessagePartUpdated(event, state, events);
             break;
-        }
-        case "question.asked": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            const questions = event.properties.questions.flatMap((q) => {
-                if (!q.question || !q.header) {
-                    return [];
-                }
-                const options = q.options?.map((o) => ({
-                    label: o.label,
-                    ...(o.description ? { description: o.description } : {}),
-                })) ?? [];
-                return [
-                    {
-                        question: q.question,
-                        header: q.header,
-                        options,
-                        ...(q.multiple === true ? { multiSelect: true } : {}),
-                    },
-                ];
-            });
-            if (questions.length === 0) {
-                break;
-            }
-            events.push({
-                type: "permission_requested",
-                provider: "opencode",
-                request: {
-                    id: event.properties.id,
-                    provider: "opencode",
-                    name: "question",
-                    kind: "question",
-                    title: "Question",
-                    input: { questions },
-                    metadata: {
-                        source: "opencode_question",
-                        ...(event.properties.tool ?? {}),
-                    },
-                },
-            });
+        case "message.part.delta":
+            appendOpenCodeMessagePartDelta(event, state, events);
             break;
-        }
-        case "todo.updated": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            events.push({
-                type: "timeline",
-                provider: "opencode",
-                item: mapOpenCodeTodosToTimelineItems(event.properties.todos),
-            });
+        case "permission.asked":
+            appendOpenCodePermissionAsked(event, state, events);
             break;
-        }
-        case "session.compacted": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            events.push({
-                type: "timeline",
-                provider: "opencode",
-                item: createCompactionTimelineItem("completed"),
-            });
+        case "question.asked":
+            appendOpenCodeQuestionAsked(event, state, events);
             break;
-        }
-        case "session.idle": {
+        case "todo.updated":
             if (event.properties.sessionID === state.sessionId) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
                 events.push({
-                    type: "turn_completed",
+                    type: "timeline",
                     provider: "opencode",
-                    usage: undefined,
+                    item: mapOpenCodeTodosToTimelineItems(event.properties.todos),
                 });
             }
             break;
-        }
-        case "session.error": {
+        case "session.compacted":
             if (event.properties.sessionID === state.sessionId) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
                 events.push({
-                    type: "turn_failed",
+                    type: "timeline",
                     provider: "opencode",
-                    error: normalizeTurnFailureError(event.properties.error),
+                    item: createCompactionTimelineItem("completed"),
                 });
             }
             break;
-        }
-        case "session.status": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            const { status } = event.properties;
-            if (status.type === "idle") {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
-                events.push({
-                    type: "turn_completed",
-                    provider: "opencode",
-                    usage: undefined,
-                });
+        case "session.idle":
+            if (event.properties.sessionID === state.sessionId) {
+                resetOpenCodeTurnTrackingState(state);
+                events.push({ type: "turn_completed", provider: "opencode", usage: undefined });
             }
-            else if (status.type === "retry" && isFatalOpenCodeRetryMessage(status.message)) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
+            break;
+        case "session.error":
+            if (event.properties.sessionID === state.sessionId) {
+                resetOpenCodeTurnTrackingState(state);
                 events.push({
                     type: "turn_failed",
                     provider: "opencode",
-                    error: normalizeTurnFailureError(status.message),
+                    error: toDiagnosticErrorMessage(event.properties.error),
                 });
             }
-            // "retry" and "busy" are transient — no terminal event.
             break;
-        }
+        case "session.status":
+            appendOpenCodeSessionStatus(event, state, events);
+            break;
     }
     return events;
 }
+function resetOpenCodeTurnTrackingState(state) {
+    state.streamedPartKeys.clear();
+    state.partTypes.clear();
+}
+function appendOpenCodeSessionCreatedOrUpdated(event, state, events) {
+    if (event.properties.info.id === state.sessionId) {
+        events.push({
+            type: "thread_started",
+            sessionId: state.sessionId,
+            provider: "opencode",
+        });
+    }
+}
+function appendOpenCodeMessageUpdated(event, state, events) {
+    const info = event.properties.info;
+    if (info.sessionID !== state.sessionId) {
+        return;
+    }
+    state.messageRoles.set(info.id, info.role);
+    if (info.role !== "assistant") {
+        return;
+    }
+    const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessage(info);
+    if (modelLookupKey) {
+        const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
+        if (contextWindowMaxTokens !== undefined) {
+            state.onAssistantModelContextWindowResolved?.(contextWindowMaxTokens);
+        }
+    }
+    if (state.emittedStructuredMessageIds.has(info.id) || info.time?.completed === undefined) {
+        return;
+    }
+    const text = stringifyStructuredAssistantMessage(info.structured);
+    if (!text) {
+        return;
+    }
+    state.emittedStructuredMessageIds.add(info.id);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: { type: "assistant_message", text },
+    });
+}
+function appendOpenCodeMessagePartUpdated(event, state, events) {
+    const part = event.properties.part;
+    if (part.sessionID !== state.sessionId) {
+        return;
+    }
+    const messageRole = state.messageRoles.get(part.messageID);
+    state.partTypes.set(part.id, part.type);
+    if (part.type === "text") {
+        appendOpenCodeTextPart(part, messageRole, state, events);
+        return;
+    }
+    if (part.type === "reasoning") {
+        appendOpenCodeReasoningPart(part, state, events);
+        return;
+    }
+    if (part.type === "tool") {
+        const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
+        if (parsedToolPart.success && parsedToolPart.data) {
+            events.push({ type: "timeline", provider: "opencode", item: parsedToolPart.data });
+        }
+        return;
+    }
+    if (part.type === "compaction") {
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: createCompactionTimelineItem("loading", part.auto ? "auto" : "manual"),
+        });
+        return;
+    }
+    if (part.type === "step-finish") {
+        mergeOpenCodeStepFinishUsage(state.accumulatedUsage, part);
+        if (hasNormalizedOpenCodeUsage(state.accumulatedUsage)) {
+            events.push({
+                type: "usage_updated",
+                provider: "opencode",
+                usage: { ...state.accumulatedUsage },
+            });
+        }
+    }
+}
+function appendOpenCodeTextPart(part, messageRole, state, events) {
+    if (messageRole === "user") {
+        return;
+    }
+    if (!part.time?.end) {
+        return;
+    }
+    const partKey = resolvePartDedupeKey(part, "text");
+    if (partKey && state.streamedPartKeys.delete(partKey)) {
+        return;
+    }
+    if (part.text) {
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "assistant_message", text: part.text },
+        });
+    }
+}
+function appendOpenCodeReasoningPart(part, state, events) {
+    if (!part.time.end) {
+        return;
+    }
+    const partKey = resolvePartDedupeKey(part, "reasoning");
+    if (partKey && state.streamedPartKeys.delete(partKey)) {
+        return;
+    }
+    if (part.text) {
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "reasoning", text: part.text },
+        });
+    }
+}
+function appendOpenCodeMessagePartDelta(event, state, events) {
+    const { sessionID, messageID, partID, field, delta } = event.properties;
+    if (sessionID !== state.sessionId) {
+        return;
+    }
+    if (!delta || !field) {
+        return;
+    }
+    const messageRole = messageID ? state.messageRoles.get(messageID) : undefined;
+    const knownPartType = partID ? state.partTypes.get(partID) : undefined;
+    const isReasoning = knownPartType === "reasoning" || field === "reasoning";
+    if (isReasoning) {
+        if (partID) {
+            state.streamedPartKeys.add(`reasoning:${partID}`);
+        }
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "reasoning", text: delta },
+        });
+        return;
+    }
+    if (field !== "text") {
+        return;
+    }
+    if (messageRole === "user") {
+        return;
+    }
+    if (partID) {
+        state.streamedPartKeys.add(`text:${partID}`);
+    }
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: { type: "assistant_message", text: delta },
+    });
+}
+function appendOpenCodePermissionAsked(event, state, events) {
+    if (event.properties.sessionID !== state.sessionId) {
+        return;
+    }
+    const metadata = readOpenCodeRecord(event.properties.metadata);
+    const tool = readOpenCodeRecord(event.properties.tool);
+    const patterns = Array.isArray(event.properties.patterns)
+        ? event.properties.patterns.filter((value) => typeof value === "string")
+        : [];
+    const command = readPermissionField(metadata, PERMISSION_COMMAND_KEYS);
+    const cwd = readPermissionField(metadata, PERMISSION_CWD_KEYS);
+    const reason = readPermissionField(metadata, PERMISSION_REASON_KEYS);
+    const input = buildOpenCodePermissionInput({ patterns, metadata, tool, command });
+    const detail = buildOpenCodePermissionDetail({
+        permission: event.properties.permission,
+        input,
+        command,
+        cwd,
+    });
+    const description = buildOpenCodePermissionDescription({ reason, patterns });
+    events.push({
+        type: "permission_requested",
+        provider: "opencode",
+        request: {
+            id: event.properties.id,
+            provider: "opencode",
+            name: event.properties.permission,
+            kind: "tool",
+            title: toHumanReadablePermissionTitle(event.properties.permission),
+            ...(description ? { description } : {}),
+            input,
+            detail,
+        },
+    });
+}
+function appendOpenCodeQuestionAsked(event, state, events) {
+    if (event.properties.sessionID !== state.sessionId) {
+        return;
+    }
+    const questions = event.properties.questions.flatMap((q) => {
+        if (!q.question || !q.header) {
+            return [];
+        }
+        const options = q.options?.map((o) => ({
+            label: o.label,
+            ...(o.description ? { description: o.description } : {}),
+        })) ?? [];
+        return [
+            {
+                question: q.question,
+                header: q.header,
+                options,
+                ...(q.multiple === true ? { multiSelect: true } : {}),
+            },
+        ];
+    });
+    if (questions.length === 0) {
+        return;
+    }
+    events.push({
+        type: "permission_requested",
+        provider: "opencode",
+        request: {
+            id: event.properties.id,
+            provider: "opencode",
+            name: "question",
+            kind: "question",
+            title: "Question",
+            input: { questions },
+            metadata: {
+                source: "opencode_question",
+                ...event.properties.tool,
+            },
+        },
+    });
+}
+function appendOpenCodeSessionStatus(event, state, events) {
+    if (event.properties.sessionID !== state.sessionId) {
+        return;
+    }
+    const { status } = event.properties;
+    if (status.type === "idle") {
+        resetOpenCodeTurnTrackingState(state);
+        events.push({ type: "turn_completed", provider: "opencode", usage: undefined });
+        return;
+    }
+    if (status.type === "retry" && isFatalOpenCodeRetryMessage(status.message)) {
+        resetOpenCodeTurnTrackingState(state);
+        events.push({
+            type: "turn_failed",
+            provider: "opencode",
+            error: toDiagnosticErrorMessage(status.message),
+        });
+    }
+    // "retry" and "busy" are transient — no terminal event.
+}
 class OpenCodeAgentSession {
     constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), releaseServer) {
         this.provider = "opencode";
@@ -1526,12 +1563,13 @@ class OpenCodeAgentSession {
                         }, "OpenCode slash command hit a header timeout; waiting for SSE terminal event");
                         return;
                     }
-                    const errorMsg = normalizeTurnFailureError(response.error);
+                    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) => {
                 if (isOpenCodeHeadersTimeoutFailure(err)) {
@@ -1542,7 +1580,7 @@ class OpenCodeAgentSession {
                     }, "OpenCode slash command hit a header timeout; waiting for SSE terminal event");
                     return;
                 }
-                this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: normalizeTurnFailureError(err) }, turnId);
+                this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: toDiagnosticErrorMessage(err) }, turnId);
             });
         }
         else {
@@ -1569,15 +1607,16 @@ class OpenCodeAgentSession {
                     this.finishForegroundTurn({
                         type: "turn_failed",
                         provider: "opencode",
-                        error: normalizeTurnFailureError(promptResponse.error),
+                        error: toDiagnosticErrorMessage(promptResponse.error),
                     }, turnId);
                 }
+                return;
             })
                 .catch((error) => {
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
-                    error: normalizeTurnFailureError(error),
+                    error: toDiagnosticErrorMessage(error),
                 }, turnId);
             });
         }
@@ -1604,19 +1643,9 @@ class OpenCodeAgentSession {
                     if (e.type === "timeline" && e.item.type === "tool_call") {
                         this.trackToolCall(e.item);
                     }
-                    if (e.type === "turn_completed" ||
-                        e.type === "turn_failed" ||
-                        e.type === "turn_canceled") {
-                        if (e.type === "turn_failed") {
-                            this.finishForegroundTurn({
-                                type: "turn_failed",
-                                provider: "opencode",
-                                error: normalizeTurnFailureError(e.error),
-                            }, turnId);
-                        }
-                        else {
-                            this.finishForegroundTurn(e, turnId);
-                        }
+                    const terminalEvent = toTerminalTurnEvent(e);
+                    if (terminalEvent) {
+                        this.finishForegroundTurn(terminalEvent, turnId);
                         return;
                     }
                     this.notifySubscribers(e, turnId);
@@ -1635,7 +1664,7 @@ class OpenCodeAgentSession {
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
-                    error: normalizeTurnFailureError(error),
+                    error: toDiagnosticErrorMessage(error),
                 }, turnId);
             }
         }
@@ -1729,34 +1758,33 @@ class OpenCodeAgentSession {
             else {
                 let emittedAssistantText = false;
                 for (const part of parts) {
-                    if (part.type === "text") {
-                        if (part.text) {
-                            emittedAssistantText = true;
-                            yield {
-                                type: "timeline",
-                                provider: "opencode",
-                                item: { type: "assistant_message", text: part.text },
-                            };
-                        }
+                    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;
                     }
-                    else if (part.type === "reasoning") {
-                        if (part.text) {
-                            yield {
-                                type: "timeline",
-                                provider: "opencode",
-                                item: { type: "reasoning", text: part.text },
-                            };
-                        }
+                    if (part.type !== "tool") {
+                        continue;
                     }
-                    else if (part.type === "tool") {
-                        const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
-                        if (parsedToolPart.success && parsedToolPart.data) {
-                            yield {
-                                type: "timeline",
-                                provider: "opencode",
-                                item: parsedToolPart.data,
-                            };
-                        }
+                    const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
+                    if (parsedToolPart.success && parsedToolPart.data) {
+                        yield {
+                            type: "timeline",
+                            provider: "opencode",
+                            item: parsedToolPart.data,
+                        };
                     }
                 }
                 if (!emittedAssistantText) {
@@ -1950,10 +1978,7 @@ class OpenCodeAgentSession {
         }
     }
     async configureMcpServers(mcpServers) {
-        for (const [name, serverConfig] of Object.entries(mcpServers)) {
-            const mappedConfig = toOpenCodeMcpConfig(serverConfig);
-            await this.registerMcpServer(name, mappedConfig);
-        }
+        await Promise.all(Object.entries(mcpServers).map(([name, serverConfig]) => this.registerMcpServer(name, toOpenCodeMcpConfig(serverConfig))));
     }
     async registerMcpServer(name, config) {
         await this.runMcpOperation("add", name, () => this.client.mcp.add({
@@ -1975,7 +2000,7 @@ class OpenCodeAgentSession {
         if (isAlreadyPresentMcpError(error)) {
             return;
         }
-        throw new Error(`Failed to ${operation} OpenCode MCP server '${name}': ${stringifyUnknownError(error)}`);
+        throw new Error(`Failed to ${operation} OpenCode MCP server '${name}': ${toDiagnosticErrorMessage(error)}`);
     }
     translateEvent(event) {
         const translated = translateOpenCodeEvent(event, {