@getpaseo/server 0.1.62 → 0.1.65

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

@@ -2,12 +2,15 @@ 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 { terminateProcessTree } from "../../../utils/process-tree.js";
 import { withTimeout } from "../../../utils/promise-timeout.js";
 import { spawnProcess } from "../../../utils/spawn.js";
+import { buildToolCallDisplayModel } from "../../../shared/tool-call-display.js";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, resolveBinaryVersion, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 const OPENCODE_CAPABILITIES = {
     supportsStreaming: true,
@@ -17,9 +20,11 @@ const OPENCODE_CAPABILITIES = {
     supportsReasoningStream: true,
     supportsToolInvocations: true,
 };
+const OPENCODE_BUILD_MODE_ID = "build";
+const OPENCODE_FULL_ACCESS_MODE_ID = "full-access";
 const DEFAULT_MODES = [
     {
-        id: "build",
+        id: OPENCODE_BUILD_MODE_ID,
         label: "Build",
         description: "Allows edits and tool execution for implementation work",
     },
@@ -28,9 +33,20 @@ const DEFAULT_MODES = [
         label: "Plan",
         description: "Read-only planning mode that avoids file edits",
     },
+    {
+        id: OPENCODE_FULL_ACCESS_MODE_ID,
+        label: "Full Access",
+        description: "Automatically approves all tool permission prompts for the session",
+    },
 ];
 const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
 const OPENCODE_PROVIDER_LIST_TIMEOUT_MS = 30000;
+const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
+const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
+const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
+    { name: "compact", description: "Compact the current session", argumentHint: "" },
+    { name: "summarize", description: "Compact the current session", argumentHint: "" },
+];
 const OPENCODE_FATAL_RETRY_MESSAGE_TOKENS = [
     "insufficient balance",
     "no resource package",
@@ -140,20 +156,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 +185,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 +204,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 +230,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 +253,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() {
@@ -269,10 +284,26 @@ function resolvePartDedupeKey(part, partType) {
 function normalizeOpenCodeModeId(modeId) {
     const trimmed = typeof modeId === "string" ? modeId.trim() : "";
     if (!trimmed || trimmed === "default") {
-        return "build";
+        return OPENCODE_BUILD_MODE_ID;
     }
     return trimmed;
 }
+function resolveOpenCodeRuntimeAgentId(modeId) {
+    const normalizedModeId = normalizeOpenCodeModeId(modeId);
+    return normalizedModeId === OPENCODE_FULL_ACCESS_MODE_ID
+        ? OPENCODE_BUILD_MODE_ID
+        : normalizedModeId;
+}
+function isSelectableOpenCodeAgent(agent) {
+    return (agent.mode === "primary" || agent.mode === "all") && agent.hidden !== true;
+}
+function mergeOpenCodeModes(discoveredModes) {
+    const modesById = new Map(DEFAULT_MODES.map((mode) => [mode.id, mode]));
+    for (const mode of discoveredModes) {
+        modesById.set(mode.id, mode);
+    }
+    return sortOpenCodeModes(Array.from(modesById.values()));
+}
 function sortOpenCodeModes(modes) {
     const order = new Map(DEFAULT_MODES.map((mode, index) => [mode.id, index]));
     return [...modes].sort((left, right) => {
@@ -458,18 +489,18 @@ function buildOpenCodePromptParts(prompt) {
             output.push({ type: "text", text: part.text });
             continue;
         }
-        if (part.type === "github_pr" || part.type === "github_issue") {
-            output.push({ type: "text", text: renderPromptAttachmentAsText(part) });
+        if (part.type === "image") {
+            attachmentOrdinal += 1;
+            const normalized = toOpenCodeDataUrl(part.mimeType, part.data);
+            output.push({
+                type: "file",
+                mime: normalized.mimeType,
+                filename: `attachment-${attachmentOrdinal}.${getOpenCodeAttachmentExtension(normalized.mimeType)}`,
+                url: normalized.url,
+            });
             continue;
         }
-        attachmentOrdinal += 1;
-        const normalized = toOpenCodeDataUrl(part.mimeType, part.data);
-        output.push({
-            type: "file",
-            mime: normalized.mimeType,
-            filename: `attachment-${attachmentOrdinal}.${getOpenCodeAttachmentExtension(normalized.mimeType)}`,
-            url: normalized.url,
-        });
+        output.push({ type: "text", text: renderPromptAttachmentAsText(part) });
     }
     return output;
 }
@@ -485,6 +516,10 @@ export const __openCodeInternals = {
     reconcileOpenCodeSessionClose,
     resolveOpenCodeModelLookupKeyFromAssistantMessage,
     resolveOpenCodeSelectedModelContextWindow,
+    isSelectableOpenCodeAgent,
+    get OpenCodeAgentSession() {
+        return OpenCodeAgentSession;
+    },
 };
 export class OpenCodeServerManager {
     constructor(logger, runtimeSettings) {
@@ -601,17 +636,41 @@ export class OpenCodeServerManager {
         const launchPrefix = await resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary);
         return new Promise((resolve, reject) => {
             const serverProcess = spawnProcess(launchPrefix.command, [...launchPrefix.args, "serve", "--port", String(port)], {
+                detached: process.platform !== "win32",
                 stdio: ["ignore", "pipe", "pipe"],
-                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 +684,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 +714,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();
     }
@@ -670,17 +730,16 @@ export class OpenCodeServerManager {
         if (server.process.killed) {
             return;
         }
-        await new Promise((resolve) => {
-            const timeout = setTimeout(() => {
-                server.process.kill("SIGKILL");
-                resolve();
-            }, 5000);
-            server.process.on("exit", () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            server.process.kill("SIGTERM");
+        const result = await terminateProcessTree(server.process, {
+            gracefulTimeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS,
+            forceTimeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS,
+            onForceSignal: () => {
+                this.logger.warn({ timeoutMs: OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not exit after SIGTERM; sending SIGKILL");
+            },
         });
+        if (result === "kill-timeout") {
+            this.logger.warn({ timeoutMs: OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS }, "OpenCode server did not report exit after SIGKILL");
+        }
     }
 }
 OpenCodeServerManager.instance = null;
@@ -801,16 +860,14 @@ export class OpenCodeAgentClient {
             if (response.error || !response.data) {
                 return DEFAULT_MODES;
             }
-            const discovered = response.data
-                .filter((agent) => agent.mode === "primary" && agent.hidden !== true)
-                .map((agent) => ({
+            const discovered = response.data.filter(isSelectableOpenCodeAgent).map((agent) => ({
                 id: agent.name,
                 label: agent.name.charAt(0).toUpperCase() + agent.name.slice(1),
                 description: typeof agent.description === "string" && agent.description.trim().length > 0
                     ? agent.description.trim()
                     : DEFAULT_MODES.find((mode) => mode.id === agent.name)?.description,
             }));
-            return discovered.length > 0 ? sortOpenCodeModes(discovered) : DEFAULT_MODES;
+            return mergeOpenCodeModes(discovered);
         }
         finally {
             acquisition.release();
@@ -839,7 +896,7 @@ export class OpenCodeAgentClient {
                 serverStatus = `Running (${url})`;
             }
             catch (error) {
-                serverStatus = `Unavailable (${normalizeTurnFailureError(error)})`;
+                serverStatus = `Unavailable (${toDiagnosticErrorMessage(error)})`;
             }
             if (available) {
                 try {
@@ -905,6 +962,8 @@ export class OpenCodeAgentClient {
         }
     }
 }
+const MAX_OPENCODE_SUB_AGENT_ACTIONS = 200;
+const MAX_OPENCODE_PENDING_CHILD_TOOL_PARTS = 200;
 function stringifyStructuredAssistantMessage(value) {
     if (value === undefined) {
         return null;
@@ -1039,309 +1098,518 @@ 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",
-                });
-            }
+        case "session.updated":
+            appendOpenCodeSessionCreatedOrUpdated(event, state, events);
             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 },
-                        });
-                    }
-                }
-            }
+        case "message.updated":
+            appendOpenCodeMessageUpdated(event, state, events);
             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") {
+        case "message.part.updated":
+            appendOpenCodeMessagePartUpdated(event, state, events);
+            break;
+        case "message.part.delta":
+            appendOpenCodeMessagePartDelta(event, state, events);
+            break;
+        case "permission.asked":
+            appendOpenCodePermissionAsked(event, state, events);
+            break;
+        case "question.asked":
+            appendOpenCodeQuestionAsked(event, state, events);
+            break;
+        case "todo.updated":
+            if (event.properties.sessionID === state.sessionId) {
                 events.push({
                     type: "timeline",
                     provider: "opencode",
-                    item: createCompactionTimelineItem("loading", part.auto ? "auto" : "manual"),
+                    item: mapOpenCodeTodosToTimelineItems(event.properties.todos),
                 });
             }
-            else if (part.type === "step-finish") {
-                mergeOpenCodeStepFinishUsage(state.accumulatedUsage, part);
-                if (hasNormalizedOpenCodeUsage(state.accumulatedUsage)) {
-                    events.push({
-                        type: "usage_updated",
-                        provider: "opencode",
-                        usage: { ...state.accumulatedUsage },
-                    });
-                }
-            }
             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}`);
-                }
+        case "session.compacted":
+            if (event.properties.sessionID === state.sessionId) {
                 events.push({
                     type: "timeline",
                     provider: "opencode",
-                    item: { type: "reasoning", text: delta },
+                    item: createCompactionTimelineItem("completed"),
                 });
             }
-            else if (field === "text") {
-                if (messageRole === "user") {
-                    break;
-                }
-                if (partID) {
-                    state.streamedPartKeys.add(`text:${partID}`);
-                }
+            break;
+        case "session.idle":
+            if (event.properties.sessionID === state.sessionId) {
+                resetOpenCodeTurnTrackingState(state);
+                events.push({ type: "turn_completed", provider: "opencode", usage: undefined });
+            }
+            break;
+        case "session.error":
+            if (event.properties.sessionID === state.sessionId) {
+                resetOpenCodeTurnTrackingState(state);
                 events.push({
-                    type: "timeline",
+                    type: "turn_failed",
                     provider: "opencode",
-                    item: { type: "assistant_message", text: delta },
+                    error: toDiagnosticErrorMessage(event.properties.error),
                 });
             }
             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 "session.status":
+            appendOpenCodeSessionStatus(event, state, events);
             break;
+    }
+    return events;
+}
+function resetOpenCodeTurnTrackingState(state) {
+    state.streamedPartKeys.clear();
+    state.partTypes.clear();
+}
+function getOpenCodeSubAgentMaps(state) {
+    state.subAgentsByCallId ?? (state.subAgentsByCallId = new Map());
+    state.subAgentCallIdByChildSessionId ?? (state.subAgentCallIdByChildSessionId = new Map());
+    state.pendingChildToolPartsBySessionId ?? (state.pendingChildToolPartsBySessionId = new Map());
+    return {
+        byCallId: state.subAgentsByCallId,
+        callIdByChildSessionId: state.subAgentCallIdByChildSessionId,
+        pendingChildToolPartsBySessionId: state.pendingChildToolPartsBySessionId,
+    };
+}
+function getOpenCodeSubAgentState(callId, state, toolCall) {
+    const maps = getOpenCodeSubAgentMaps(state);
+    const existing = maps.byCallId.get(callId);
+    if (existing) {
+        existing.toolCall = toolCall;
+        return existing;
+    }
+    const created = {
+        toolCall,
+        actions: [],
+        actionIndexByKey: new Map(),
+        nextActionIndex: 1,
+    };
+    maps.byCallId.set(callId, created);
+    return created;
+}
+function linkOpenCodeSubAgentChildSession(activity, childSessionId, state) {
+    activity.childSessionId = childSessionId;
+    const maps = getOpenCodeSubAgentMaps(state);
+    maps.callIdByChildSessionId.set(childSessionId, activity.toolCall.callId);
+}
+function buildOpenCodeSubAgentLog(detail, activity) {
+    const actionLog = activity.actions
+        .map((action) => action.summary ? `[${action.toolName}] ${action.summary}` : `[${action.toolName}]`)
+        .join("\n");
+    const parts = [actionLog, detail.log].filter((part) => part.trim().length > 0);
+    return parts.join("\n\n");
+}
+function buildOpenCodeSubAgentTimelineItem(activity) {
+    const toolCall = activity.toolCall;
+    if (toolCall.detail.type !== "sub_agent") {
+        return toolCall;
+    }
+    const childSessionId = activity.childSessionId ?? toolCall.detail.childSessionId;
+    return {
+        ...toolCall,
+        detail: {
+            ...toolCall.detail,
+            ...(childSessionId ? { childSessionId } : {}),
+            log: buildOpenCodeSubAgentLog(toolCall.detail, activity),
+        },
+    };
+}
+function registerOpenCodeSubAgentToolCall(item, state) {
+    if (item.detail.type !== "sub_agent") {
+        return item;
+    }
+    const activity = getOpenCodeSubAgentState(item.callId, state, item);
+    if (item.detail.childSessionId) {
+        linkOpenCodeSubAgentChildSession(activity, item.detail.childSessionId, state);
+    }
+    return buildOpenCodeSubAgentTimelineItem(activity);
+}
+function bufferOpenCodeSubAgentChildToolPart(part, state) {
+    const maps = getOpenCodeSubAgentMaps(state);
+    if (maps.byCallId.size === 0) {
+        return;
+    }
+    const totalPending = [...maps.pendingChildToolPartsBySessionId.values()].reduce((total, parts) => total + parts.length, 0);
+    if (totalPending >= MAX_OPENCODE_PENDING_CHILD_TOOL_PARTS) {
+        return;
+    }
+    const pending = maps.pendingChildToolPartsBySessionId.get(part.sessionID) ?? [];
+    pending.push(part);
+    maps.pendingChildToolPartsBySessionId.set(part.sessionID, pending);
+}
+function flushOpenCodeSubAgentChildToolParts(childSessionId, state, events) {
+    const maps = getOpenCodeSubAgentMaps(state);
+    const pending = maps.pendingChildToolPartsBySessionId.get(childSessionId);
+    if (!pending || pending.length === 0) {
+        return;
+    }
+    maps.pendingChildToolPartsBySessionId.delete(childSessionId);
+    for (const part of pending) {
+        appendOpenCodeSubAgentChildToolPart(part, state, events);
+    }
+}
+function findOnlyOpenCodeSubAgentWaitingForChild(state) {
+    const maps = getOpenCodeSubAgentMaps(state);
+    const candidates = [...maps.byCallId.values()].filter((activity) => activity.toolCall.status === "running" &&
+        activity.toolCall.detail.type === "sub_agent" &&
+        !activity.childSessionId);
+    return candidates.length === 1 ? (candidates[0] ?? null) : null;
+}
+function summarizeOpenCodeSubAgentAction(item, cwd) {
+    const display = buildToolCallDisplayModel({
+        name: item.name,
+        status: item.status,
+        error: item.error,
+        metadata: item.metadata,
+        detail: item.detail,
+        cwd,
+    });
+    return display.summary ?? display.errorText;
+}
+function appendOpenCodeSubAgentAction(activity, item, cwd) {
+    const key = item.callId || `${item.name}:${activity.actions.length}`;
+    const existingIndex = activity.actionIndexByKey.get(key);
+    const summary = summarizeOpenCodeSubAgentAction(item, cwd);
+    if (existingIndex !== undefined) {
+        const action = activity.actions[existingIndex];
+        if (!action) {
+            return false;
+        }
+        const changed = action.toolName !== item.name || action.summary !== summary;
+        action.toolName = item.name;
+        if (summary) {
+            action.summary = summary;
         }
-        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 ?? {}),
-                    },
-                },
-            });
-            break;
+        else {
+            delete action.summary;
         }
-        case "todo.updated": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
-            events.push({
-                type: "timeline",
-                provider: "opencode",
-                item: mapOpenCodeTodosToTimelineItems(event.properties.todos),
-            });
-            break;
+        return changed;
+    }
+    if (activity.actions.length >= MAX_OPENCODE_SUB_AGENT_ACTIONS) {
+        return false;
+    }
+    activity.actionIndexByKey.set(key, activity.actions.length);
+    activity.actions.push({
+        index: activity.nextActionIndex,
+        key,
+        toolName: item.name,
+        ...(summary ? { summary } : {}),
+    });
+    activity.nextActionIndex += 1;
+    return true;
+}
+function appendOpenCodeToolCallTimelineItem(item, state, events) {
+    const timelineItem = registerOpenCodeSubAgentToolCall(item, state);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: timelineItem,
+    });
+    if (timelineItem.detail.type === "sub_agent" && timelineItem.detail.childSessionId) {
+        flushOpenCodeSubAgentChildToolParts(timelineItem.detail.childSessionId, state, events);
+    }
+}
+function appendOpenCodeSubAgentChildSessionLinked(childSessionId, state, events) {
+    const activity = findOnlyOpenCodeSubAgentWaitingForChild(state);
+    if (!activity) {
+        return;
+    }
+    linkOpenCodeSubAgentChildSession(activity, childSessionId, state);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: buildOpenCodeSubAgentTimelineItem(activity),
+    });
+    flushOpenCodeSubAgentChildToolParts(childSessionId, state, events);
+}
+function appendOpenCodeSubAgentChildToolPart(part, state, events) {
+    const maps = getOpenCodeSubAgentMaps(state);
+    const parentCallId = maps.callIdByChildSessionId.get(part.sessionID);
+    if (!parentCallId) {
+        bufferOpenCodeSubAgentChildToolPart(part, state);
+        return;
+    }
+    const activity = maps.byCallId.get(parentCallId);
+    if (!activity) {
+        return;
+    }
+    const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
+    if (!parsedToolPart.success || !parsedToolPart.data) {
+        return;
+    }
+    if (!appendOpenCodeSubAgentAction(activity, parsedToolPart.data, state.cwd)) {
+        return;
+    }
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: buildOpenCodeSubAgentTimelineItem(activity),
+    });
+}
+function appendOpenCodeSessionCreatedOrUpdated(event, state, events) {
+    if (event.properties.info.id === state.sessionId) {
+        events.push({
+            type: "thread_started",
+            sessionId: state.sessionId,
+            provider: "opencode",
+        });
+        return;
+    }
+    const info = readOpenCodeRecord(event.properties.info);
+    const parentSessionId = readNonEmptyString(info?.parentID) ?? readNonEmptyString(info?.parentId);
+    if (parentSessionId === state.sessionId) {
+        appendOpenCodeSubAgentChildSessionLinked(event.properties.info.id, state, events);
+    }
+}
+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);
         }
-        case "session.compacted": {
-            if (event.properties.sessionID !== state.sessionId) {
-                break;
-            }
+    }
+    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) {
+        if (part.type === "tool") {
+            appendOpenCodeSubAgentChildToolPart(part, state, events);
+        }
+        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) {
+            appendOpenCodeToolCallTimelineItem(parsedToolPart.data, state, events);
+        }
+        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: "timeline",
+                type: "usage_updated",
                 provider: "opencode",
-                item: createCompactionTimelineItem("completed"),
+                usage: { ...state.accumulatedUsage },
             });
-            break;
-        }
-        case "session.idle": {
-            if (event.properties.sessionID === state.sessionId) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
-                events.push({
-                    type: "turn_completed",
-                    provider: "opencode",
-                    usage: undefined,
-                });
-            }
-            break;
-        }
-        case "session.error": {
-            if (event.properties.sessionID === state.sessionId) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
-                events.push({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: normalizeTurnFailureError(event.properties.error),
-                });
-            }
-            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,
-                });
-            }
-            else if (status.type === "retry" && isFatalOpenCodeRetryMessage(status.message)) {
-                state.streamedPartKeys.clear();
-                state.partTypes.clear();
-                events.push({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: normalizeTurnFailureError(status.message),
-                });
-            }
-            // "retry" and "busy" are transient — no terminal event.
-            break;
+    }
+}
+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;
     }
-    return events;
+    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.
+}
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
 }
 class OpenCodeAgentSession {
     constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), releaseServer) {
@@ -1366,6 +1634,9 @@ class OpenCodeAgentSession {
         this.nextTurnOrdinal = 0;
         this.activeForegroundTurnId = null;
         this.runningToolCalls = new Map();
+        this.subAgentsByCallId = new Map();
+        this.subAgentCallIdByChildSessionId = new Map();
+        this.pendingChildToolPartsBySessionId = new Map();
         this.config = config;
         this.client = client;
         this.sessionId = sessionId;
@@ -1398,75 +1669,13 @@ class OpenCodeAgentSession {
         this.config.thinkingOptionId = normalizedThinkingOptionId ?? undefined;
     }
     async run(prompt, options) {
-        const timeline = [];
-        let finalText = "";
-        let usage;
-        let turnId = null;
-        const bufferedEvents = [];
-        let settled = false;
-        let resolveCompletion;
-        let rejectCompletion;
-        const processEvent = (event) => {
-            if (settled) {
-                return;
-            }
-            const eventTurnId = event.turnId;
-            if (turnId && eventTurnId && eventTurnId !== turnId) {
-                return;
-            }
-            if (event.type === "timeline") {
-                timeline.push(event.item);
-                if (event.item.type === "assistant_message") {
-                    finalText = event.item.text;
-                }
-                return;
-            }
-            if (event.type === "turn_completed") {
-                usage = event.usage;
-                settled = true;
-                resolveCompletion();
-                return;
-            }
-            if (event.type === "turn_failed") {
-                settled = true;
-                rejectCompletion(new Error(event.error));
-                return;
-            }
-            if (event.type === "turn_canceled") {
-                settled = true;
-                resolveCompletion();
-            }
-        };
-        const completion = new Promise((resolve, reject) => {
-            resolveCompletion = resolve;
-            rejectCompletion = reject;
-        });
-        const unsubscribe = this.subscribe((event) => {
-            if (!turnId) {
-                bufferedEvents.push(event);
-                return;
-            }
-            processEvent(event);
+        return runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.sessionId,
         });
-        try {
-            const result = await this.startTurn(prompt, options);
-            turnId = result.turnId;
-            for (const event of bufferedEvents) {
-                processEvent(event);
-            }
-            if (!settled) {
-                await completion;
-            }
-        }
-        finally {
-            unsubscribe();
-        }
-        return {
-            sessionId: this.sessionId,
-            finalText,
-            usage,
-            timeline,
-        };
     }
     async interrupt() {
         const turnId = this.activeForegroundTurnId;
@@ -1485,6 +1694,9 @@ class OpenCodeAgentSession {
             throw new Error("A foreground turn is already active");
         }
         this.runningToolCalls.clear();
+        this.subAgentsByCallId.clear();
+        this.subAgentCallIdByChildSessionId.clear();
+        this.pendingChildToolPartsBySessionId.clear();
         const turnAbortController = new AbortController();
         this.abortController = turnAbortController;
         await this.ensureMcpServersConfigured();
@@ -1494,12 +1706,54 @@ class OpenCodeAgentSession {
         const model = this.parseModel(this.config.model);
         const thinkingOptionId = this.config.thinkingOptionId;
         const effectiveVariant = thinkingOptionId ?? undefined;
-        const effectiveMode = normalizeOpenCodeModeId(this.currentMode);
+        const effectiveMode = resolveOpenCodeRuntimeAgentId(this.currentMode);
         const turnId = this.createTurnId();
         this.activeForegroundTurnId = turnId;
-        void this.consumeEventStream(turnId, turnAbortController);
+        // 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;
+        }
+        catch {
+            // consumeEventStream already finished the turn with the subscription error.
+            return { turnId };
+        }
         const slashCommand = await this.resolveSlashCommandInvocation(prompt);
         if (slashCommand) {
+            if (slashCommand.commandName === "compact" || slashCommand.commandName === "summarize") {
+                void this.client.session
+                    .summarize({
+                    sessionID: this.sessionId,
+                    directory: this.config.cwd,
+                    ...(model ? { providerID: model.providerID, modelID: model.modelID } : {}),
+                })
+                    .then((response) => {
+                    if (response.error) {
+                        this.finishForegroundTurn({
+                            type: "turn_failed",
+                            provider: "opencode",
+                            error: toDiagnosticErrorMessage(response.error),
+                        }, turnId);
+                    }
+                    else {
+                        this.finishForegroundTurn({ type: "turn_completed", provider: "opencode", usage: undefined }, turnId);
+                    }
+                    return;
+                })
+                    .catch((error) => {
+                    this.finishForegroundTurn({
+                        type: "turn_failed",
+                        provider: "opencode",
+                        error: toDiagnosticErrorMessage(error),
+                    }, turnId);
+                });
+                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.
@@ -1526,12 +1780,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,44 +1797,48 @@ 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 {
-            void this.client.session
-                .promptAsync({
-                sessionID: this.sessionId,
-                directory: this.config.cwd,
-                parts,
-                ...(options?.outputSchema
-                    ? {
-                        format: {
-                            type: "json_schema",
-                            schema: options.outputSchema,
-                        },
+            // Wrap in an async IIFE so a synchronous throw from promptAsync (e.g.
+            // SDK input validation) is caught alongside async rejections. A plain
+            // `.then().catch()` chain would let a sync throw escape unhandled.
+            void (async () => {
+                try {
+                    const promptResponse = await this.client.session.promptAsync({
+                        sessionID: this.sessionId,
+                        directory: this.config.cwd,
+                        parts,
+                        ...(options?.outputSchema
+                            ? {
+                                format: {
+                                    type: "json_schema",
+                                    schema: options.outputSchema,
+                                },
+                            }
+                            : {}),
+                        ...(this.config.systemPrompt ? { system: this.config.systemPrompt } : {}),
+                        ...(model ? { model } : {}),
+                        ...(effectiveMode ? { agent: effectiveMode } : {}),
+                        ...(effectiveVariant ? { variant: effectiveVariant } : {}),
+                    });
+                    if (promptResponse.error) {
+                        this.finishForegroundTurn({
+                            type: "turn_failed",
+                            provider: "opencode",
+                            error: toDiagnosticErrorMessage(promptResponse.error),
+                        }, turnId);
                     }
-                    : {}),
-                ...(this.config.systemPrompt ? { system: this.config.systemPrompt } : {}),
-                ...(model ? { model } : {}),
-                ...(effectiveMode ? { agent: effectiveMode } : {}),
-                ...(effectiveVariant ? { variant: effectiveVariant } : {}),
-            })
-                .then((promptResponse) => {
-                if (promptResponse.error) {
+                }
+                catch (error) {
                     this.finishForegroundTurn({
                         type: "turn_failed",
                         provider: "opencode",
-                        error: normalizeTurnFailureError(promptResponse.error),
+                        error: toDiagnosticErrorMessage(error),
                     }, turnId);
                 }
-            })
-                .catch((error) => {
-                this.finishForegroundTurn({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: normalizeTurnFailureError(error),
-                }, turnId);
-            });
+            })();
         }
         return { turnId };
     }
@@ -1589,14 +1848,15 @@ class OpenCodeAgentSession {
             this.subscribers.delete(callback);
         };
     }
-    async consumeEventStream(turnId, turnAbortController) {
+    async consumeEventStream(turnId, turnAbortController, subscriptionReady) {
         try {
             const result = await this.client.event.subscribe({ directory: this.config.cwd }, { signal: turnAbortController.signal, sseMaxRetryAttempts: 0 });
+            subscriptionReady.resolve();
             for await (const event of result.stream) {
                 if (turnAbortController.signal.aborted || this.activeForegroundTurnId !== turnId) {
                     break;
                 }
-                const translated = this.translateEvent(event);
+                const translated = await this.translateEvent(event);
                 for (const e of translated) {
                     if (this.activeForegroundTurnId !== turnId) {
                         return;
@@ -1604,19 +1864,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);
@@ -1631,11 +1881,12 @@ class OpenCodeAgentSession {
             }
         }
         catch (error) {
+            subscriptionReady.reject(error);
             if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
                 this.finishForegroundTurn({
                     type: "turn_failed",
                     provider: "opencode",
-                    error: normalizeTurnFailureError(error),
+                    error: toDiagnosticErrorMessage(error),
                 }, turnId);
             }
         }
@@ -1677,13 +1928,22 @@ class OpenCodeAgentSession {
     }
     synthesizeInterruptedToolCalls(turnId) {
         for (const item of this.runningToolCalls.values()) {
+            const error = { message: "Tool execution aborted" };
             this.notifySubscribers({
                 type: "timeline",
                 provider: "opencode",
                 item: {
                     ...item,
                     status: "failed",
-                    error: { message: "Tool execution aborted" },
+                    error,
+                    detail: item.detail.type === "sub_agent"
+                        ? {
+                            ...item.detail,
+                            log: [item.detail.log, error.message]
+                                .filter((entry) => entry.trim().length > 0)
+                                .join("\n"),
+                        }
+                        : item.detail,
                 },
             }, turnId);
         }
@@ -1729,34 +1989,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;
                     }
-                    else if (part.type === "reasoning") {
-                        if (part.text) {
-                            yield {
-                                type: "timeline",
-                                provider: "opencode",
-                                item: { type: "reasoning", text: part.text },
-                            };
-                        }
+                    if (part.type === "reasoning" && part.text) {
+                        yield {
+                            type: "timeline",
+                            provider: "opencode",
+                            item: { type: "reasoning", text: part.text },
+                        };
+                        continue;
                     }
-                    else if (part.type === "tool") {
-                        const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
-                        if (parsedToolPart.success && parsedToolPart.data) {
-                            yield {
-                                type: "timeline",
-                                provider: "opencode",
-                                item: parsedToolPart.data,
-                            };
-                        }
+                    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) {
@@ -1779,19 +2038,15 @@ class OpenCodeAgentSession {
         const response = await this.client.app.agents({
             directory: this.config.cwd,
         });
-        const discoveredModes = response.error || !response.data
-            ? []
-            : response.data
-                .filter((agent) => agent.mode === "primary" && agent.hidden !== true)
-                .map((agent) => ({
-                id: agent.name,
-                label: agent.name.charAt(0).toUpperCase() + agent.name.slice(1),
-                description: typeof agent.description === "string" && agent.description.trim().length > 0
-                    ? agent.description.trim()
-                    : DEFAULT_MODES.find((mode) => mode.id === agent.name)?.description,
-            }));
-        this.availableModesCache =
-            discoveredModes.length > 0 ? sortOpenCodeModes(discoveredModes) : DEFAULT_MODES;
+        const agents = response.error || !response.data ? [] : response.data;
+        const discoveredModes = agents.filter(isSelectableOpenCodeAgent).map((agent) => ({
+            id: agent.name,
+            label: agent.name.charAt(0).toUpperCase() + agent.name.slice(1),
+            description: typeof agent.description === "string" && agent.description.trim().length > 0
+                ? agent.description.trim()
+                : DEFAULT_MODES.find((mode) => mode.id === agent.name)?.description,
+        }));
+        this.availableModesCache = mergeOpenCodeModes(discoveredModes);
         return this.availableModesCache;
     }
     async getCurrentMode() {
@@ -1801,14 +2056,18 @@ class OpenCodeAgentSession {
         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 [];
+            return Array.from(commandsByName.values());
         }
-        return result.data.map((cmd) => ({
-            name: cmd.name,
-            description: cmd.description ?? "",
-            argumentHint: cmd.hints?.length ? cmd.hints.join(" ") : "",
-        }));
+        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());
     }
     async setMode(modeId) {
         this.currentMode = normalizeOpenCodeModeId(modeId);
@@ -1950,10 +2209,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,16 +2231,20 @@ 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) {
+    async translateEvent(event) {
         const translated = translateOpenCodeEvent(event, {
             sessionId: this.sessionId,
+            cwd: this.config.cwd,
             messageRoles: this.messageRoles,
             accumulatedUsage: this.accumulatedUsage,
             streamedPartKeys: this.streamedPartKeys,
             emittedStructuredMessageIds: this.emittedStructuredMessageIds,
             partTypes: this.partTypes,
+            subAgentsByCallId: this.subAgentsByCallId,
+            subAgentCallIdByChildSessionId: this.subAgentCallIdByChildSessionId,
+            pendingChildToolPartsBySessionId: this.pendingChildToolPartsBySessionId,
             modelContextWindowsByModelKey: this.modelContextWindowsByModelKey,
             onAssistantModelContextWindowResolved: (contextWindowMaxTokens) => {
                 this.accumulatedUsage.contextWindowMaxTokens = contextWindowMaxTokens;
@@ -1993,8 +2253,13 @@ class OpenCodeAgentSession {
                 }
             },
         });
+        const events = [];
         for (const translatedEvent of translated) {
             if (translatedEvent.type === "permission_requested") {
+                const autoApproved = await this.tryAutoApproveToolPermission(translatedEvent.request);
+                if (autoApproved) {
+                    continue;
+                }
                 this.pendingPermissions.set(translatedEvent.request.id, translatedEvent.request);
             }
             if (translatedEvent.type === "turn_completed") {
@@ -2005,8 +2270,26 @@ class OpenCodeAgentSession {
                 this.accumulatedUsage =
                     contextWindowMaxTokens !== undefined ? { contextWindowMaxTokens } : {};
             }
+            events.push(translatedEvent);
+        }
+        return events;
+    }
+    async tryAutoApproveToolPermission(request) {
+        if (this.currentMode !== OPENCODE_FULL_ACCESS_MODE_ID || request.kind !== "tool") {
+            return false;
+        }
+        try {
+            await this.client.permission.reply({
+                requestID: request.id,
+                directory: this.config.cwd,
+                reply: "once",
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.warn({ err: error, requestId: request.id }, "Failed to auto-approve OpenCode tool permission");
+            return false;
         }
-        return translated;
     }
     resolveSelectedModelContextWindowMaxTokens() {
         return this.selectedModelContextWindowMaxTokens;