@getpaseo/server 0.1.63 → 0.1.65

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

@@ -4,10 +4,13 @@ import net from "node:net";
 import { z } from "zod";
 import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../provider-launch-config.js";
 import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
+import { 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",
@@ -268,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) => {
@@ -457,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;
 }
@@ -484,6 +516,10 @@ export const __openCodeInternals = {
     reconcileOpenCodeSessionClose,
     resolveOpenCodeModelLookupKeyFromAssistantMessage,
     resolveOpenCodeSelectedModelContextWindow,
+    isSelectableOpenCodeAgent,
+    get OpenCodeAgentSession() {
+        return OpenCodeAgentSession;
+    },
 };
 export class OpenCodeServerManager {
     constructor(logger, runtimeSettings) {
@@ -600,6 +636,7 @@ 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"],
                 ...createProviderEnvSpec({ runtimeSettings: this.runtimeSettings }),
             });
@@ -693,25 +730,16 @@ export class OpenCodeServerManager {
         if (server.process.killed) {
             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");
-                settle();
-            }, 5000);
-            server.process.on("exit", () => {
-                clearTimeout(timeout);
-                settle();
-            });
-            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;
@@ -832,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();
@@ -936,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;
@@ -1132,6 +1160,191 @@ 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;
+        }
+        else {
+            delete action.summary;
+        }
+        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({
@@ -1139,6 +1352,12 @@ function appendOpenCodeSessionCreatedOrUpdated(event, state, events) {
             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) {
@@ -1174,6 +1393,9 @@ function appendOpenCodeMessageUpdated(event, state, events) {
 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);
@@ -1189,7 +1411,7 @@ function appendOpenCodeMessagePartUpdated(event, state, events) {
     if (part.type === "tool") {
         const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
         if (parsedToolPart.success && parsedToolPart.data) {
-            events.push({ type: "timeline", provider: "opencode", item: parsedToolPart.data });
+            appendOpenCodeToolCallTimelineItem(parsedToolPart.data, state, events);
         }
         return;
     }
@@ -1380,6 +1602,15 @@ function appendOpenCodeSessionStatus(event, state, events) {
     }
     // "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) {
         this.provider = "opencode";
@@ -1403,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;
@@ -1435,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;
@@ -1522,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();
@@ -1531,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.
@@ -1584,41 +1801,44 @@ class OpenCodeAgentSession {
             });
         }
         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: toDiagnosticErrorMessage(promptResponse.error),
+                        error: toDiagnosticErrorMessage(error),
                     }, turnId);
                 }
-                return;
-            })
-                .catch((error) => {
-                this.finishForegroundTurn({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    error: toDiagnosticErrorMessage(error),
-                }, turnId);
-            });
+            })();
         }
         return { turnId };
     }
@@ -1628,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;
@@ -1660,6 +1881,7 @@ class OpenCodeAgentSession {
             }
         }
         catch (error) {
+            subscriptionReady.reject(error);
             if (!turnAbortController.signal.aborted && this.activeForegroundTurnId === turnId) {
                 this.finishForegroundTurn({
                     type: "turn_failed",
@@ -1706,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);
         }
@@ -1807,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() {
@@ -1829,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);
@@ -2002,14 +2233,18 @@ class OpenCodeAgentSession {
         }
         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;
@@ -2018,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") {
@@ -2030,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;