@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,4106 @@
+import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
+import fs from "node:fs/promises";
+import { randomBytes } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { createPathEquivalenceMatcher } from "../../../utils/path.js";
+import pLimit from "p-limit";
+import { z } from "zod";
+import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
+import { importSessionFromPersistence } from "../provider-session-import.js";
+import { raceProviderRefreshAbort, runProviderRefreshActivity, } from "../provider-refresh-deadline.js";
+import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "../create-agent-mode.js";
+import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
+import { withTimeout } from "../../../utils/promise-timeout.js";
+import { execCommand } from "../../../utils/spawn.js";
+import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
+import { OPENCODE_EVENT_STREAM_READY_TIMEOUT_MS, OpenCodeServerManager, OPENCODE_SERVER_STARTUP_TIMEOUT_MS, } from "./opencode/server-manager.js";
+import { OpenCodeEventConsumer, } from "./opencode/event-consumer.js";
+import { resolveOpenCodeHomeDir } from "./opencode/paths.js";
+import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
+import { runProviderTurn } from "./provider-runner.js";
+import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
+import { composeSystemPromptParts } from "../system-prompt.js";
+import { normalizeProviderReplayTimestamp } from "../provider-history-timestamps.js";
+import { revertOpenCodeConversationAndFiles } from "./opencode/rewind.js";
+import { askOpenCodeSideQuestion } from "./opencode/side-question.js";
+import { claimOpenCodeSubagentFallbackTitle, foldOpenCodeSubagentPresentation, } from "./opencode/subagent-presentation.js";
+import { buildOpenCodePermissionRules, OpenCodeProviderOptionsSchema, } from "./opencode/options.js";
+function formatOpenCodeEventStreamDiagnostics(diagnostics) {
+    return [
+        "opencode-stream",
+        `attempt=${diagnostics.attempt}`,
+        `phase=${diagnostics.phase}`,
+        `elapsedMs=${diagnostics.elapsedMs}`,
+        ...(diagnostics.lastOutcome ? [`lastOutcome=${diagnostics.lastOutcome}`] : []),
+        ...(diagnostics.lastError ? [`lastError=${JSON.stringify(diagnostics.lastError)}`] : []),
+    ].join(" ");
+}
+const OPENCODE_CAPABILITIES = {
+    supportsStreaming: true,
+    supportsSessionPersistence: true,
+    supportsSessionListing: true,
+    supportsDynamicModes: true,
+    supportsMcpServers: true,
+    supportsReasoningStream: true,
+    supportsToolInvocations: true,
+    supportsRewindConversation: false,
+    supportsRewindFiles: false,
+    supportsRewindBoth: true,
+};
+const OPENCODE_BUILD_MODE_ID = "build";
+const OPENCODE_LEGACY_FULL_ACCESS_MODE_ID = "full-access";
+const OPENCODE_DEFAULT_VARIANT_ID = "default";
+const EMPTY_OPENCODE_EVENT_SOURCE = {
+    ready: async () => undefined,
+    subscribe: () => () => undefined,
+};
+const OPENCODE_ID_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+let lastOpenCodeMessageTimestamp = -1;
+let openCodeMessageCounter = 0;
+function createOpenCodeMessageId(now = Date.now(), random = (length) => Array.from(randomBytes(length), (value) => OPENCODE_ID_ALPHABET[value % 62]).join("")) {
+    if (now !== lastOpenCodeMessageTimestamp)
+        openCodeMessageCounter = 0;
+    lastOpenCodeMessageTimestamp = now;
+    openCodeMessageCounter += 1;
+    const ascending = (BigInt(now) * 0x1000n + BigInt(openCodeMessageCounter))
+        .toString(16)
+        .padStart(12, "0")
+        .slice(-12);
+    return `msg_${ascending}${random(14)}`;
+}
+const OPENCODE_AUTO_ACCEPT_FEATURE_ID = "auto_accept";
+const OPENCODE_PERSISTED_SESSION_LIMIT = 200;
+const OPENCODE_PENDING_ABORT_START_TIMEOUT_MS = 10000;
+const OPENCODE_CHILD_SESSION_HYDRATION_LIMIT = 100;
+const OPENCODE_STOP_STATUS_MAX_DELAY_MS = 1000;
+function waitForOpenCodeStopProbe(delayMs, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, delayMs).unref();
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function recoverChildStatus(snapshot, type, assistant) {
+    if (type === "busy" || type === "retry")
+        return "running";
+    if (assistant && "error" in assistant.info && assistant.info.error)
+        return "failed";
+    const time = assistant?.info.time;
+    if (snapshot || (time && "completed" in time && time.completed !== undefined))
+        return "completed";
+}
+const OPENCODE_CHILD_SESSION_SERVER_REGISTRY_LIMIT = 500;
+const OPENCODE_PERMISSION_ACTION_ALLOW_ONCE = "allow_once";
+const OPENCODE_PERMISSION_ACTION_ALLOW_ALWAYS = "allow_always";
+// OpenCode child sessions run on the server process that spawned them. Adoption
+// resumes must attach to that same helper server to receive live global events.
+const openCodeChildSessionServerUrls = new Map();
+function registerOpenCodeChildSessionServerUrl(sessionId, serverUrl) {
+    openCodeChildSessionServerUrls.delete(sessionId);
+    openCodeChildSessionServerUrls.set(sessionId, serverUrl);
+    if (openCodeChildSessionServerUrls.size <= OPENCODE_CHILD_SESSION_SERVER_REGISTRY_LIMIT) {
+        return;
+    }
+    const oldestSessionId = openCodeChildSessionServerUrls.keys().next().value;
+    if (typeof oldestSessionId === "string") {
+        openCodeChildSessionServerUrls.delete(oldestSessionId);
+    }
+}
+function unregisterOpenCodeChildSessionServerUrl(sessionId) {
+    openCodeChildSessionServerUrls.delete(sessionId);
+}
+function getOpenCodeChildSessionServerUrl(sessionId) {
+    return openCodeChildSessionServerUrls.get(sessionId);
+}
+const DEFAULT_MODES = [
+    {
+        id: OPENCODE_BUILD_MODE_ID,
+        label: "Build",
+        description: "Allows edits and tool execution for implementation work",
+    },
+    {
+        id: "plan",
+        label: "Plan",
+        description: "Read-only planning mode that avoids file edits",
+    },
+];
+function isOpenCodeAutoAcceptEnabled(config) {
+    return config.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === true;
+}
+function withOpenCodeAutoAcceptFeature(featureValues, enabled) {
+    return {
+        ...featureValues,
+        [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: enabled,
+    };
+}
+function resolveOpenCodeCreateConfig(input) {
+    const legacyFullAccess = input.requestedMode === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID;
+    const parent = input.parent;
+    const isUnattendedCreate = input.unattended || parent?.isUnattended === true;
+    const inheritsUnattended = input.requestedMode === undefined && isUnattendedCreate;
+    const inheritedOpenCodeMode = inheritsUnattended && parent?.provider === input.provider
+        ? (parent.modeId ?? undefined)
+        : undefined;
+    const requestedMode = legacyFullAccess
+        ? OPENCODE_BUILD_MODE_ID
+        : (input.requestedMode ?? inheritedOpenCodeMode);
+    const featureValues = legacyFullAccess ||
+        (isUnattendedCreate && input.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === undefined)
+        ? withOpenCodeAutoAcceptFeature(input.featureValues, true)
+        : input.featureValues;
+    if (inheritsUnattended && requestedMode === undefined) {
+        // Unattendedness for OpenCode is carried by auto_accept (set above), not
+        // by any particular agent. Leave the mode unset so OpenCode uses its own
+        // default agent — `build` may not exist in the user's OpenCode config.
+        return { modeId: undefined, featureValues };
+    }
+    const resolved = resolveDefaultAgentCreateConfig({
+        ...input,
+        requestedMode,
+        featureValues,
+    });
+    return { ...resolved, featureValues };
+}
+function isOpenCodeCreateConfigUnattended(input) {
+    return (isDefaultAgentCreateConfigUnattended(input) ||
+        input.config.featureValues?.[OPENCODE_AUTO_ACCEPT_FEATURE_ID] === true ||
+        input.features?.some((feature) => feature.id === OPENCODE_AUTO_ACCEPT_FEATURE_ID &&
+            (feature.value === true || feature.value === "true")) === true);
+}
+function buildOpenCodeAutoAcceptFeature(config) {
+    return {
+        type: "toggle",
+        id: OPENCODE_AUTO_ACCEPT_FEATURE_ID,
+        label: "Auto Accept",
+        description: "Automatically approves OpenCode tool permission prompts.",
+        tooltip: "Auto accept permission prompts",
+        icon: "shield-check",
+        value: isOpenCodeAutoAcceptEnabled(config),
+    };
+}
+function buildOpenCodePermissionActions() {
+    return [
+        {
+            id: "deny",
+            label: "Deny",
+            behavior: "deny",
+            variant: "danger",
+            intent: "dismiss",
+        },
+        {
+            id: OPENCODE_PERMISSION_ACTION_ALLOW_ALWAYS,
+            label: "Allow always",
+            behavior: "allow",
+            variant: "secondary",
+        },
+        {
+            id: OPENCODE_PERMISSION_ACTION_ALLOW_ONCE,
+            label: "Allow once",
+            behavior: "allow",
+            variant: "primary",
+        },
+    ];
+}
+function resolveOpenCodePermissionReply(response) {
+    if (response.behavior === "deny") {
+        return "reject";
+    }
+    if (response.selectedActionId === OPENCODE_PERMISSION_ACTION_ALLOW_ALWAYS) {
+        return "always";
+    }
+    return "once";
+}
+const OPENCODE_SESSION_ENV_KEYS = new Set(["PASEO_AGENT_ID", "PASEO_AGENT_CWD"]);
+function requiresDedicatedOpenCodeServer(config, launchContext) {
+    if (config.mcpServers && Object.keys(config.mcpServers).length > 0)
+        return true;
+    return Object.keys(launchContext?.env ?? {}).some((key) => !OPENCODE_SESSION_ENV_KEYS.has(key));
+}
+const MCP_ALREADY_PRESENT_ERROR_TOKENS = ["already", "exists", "connected"];
+const OPENCODE_METADATA_CONCURRENCY = 4;
+const openCodeMetadataLimit = pLimit(OPENCODE_METADATA_CONCURRENCY);
+const OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS = [
+    {
+        name: "compact",
+        description: "Compact the current session",
+        argumentHint: "",
+        kind: "command",
+    },
+    {
+        name: "summarize",
+        description: "Compact the current session",
+        argumentHint: "",
+        kind: "command",
+    },
+];
+const OPENCODE_HEADERS_TIMEOUT_TOKENS = [
+    "headers timeout",
+    "headers timeout error",
+    "headers_timeout",
+    "und_err_headers_timeout",
+];
+const OpencodeToolStateSchema = z
+    .object({
+    status: z.string().optional(),
+    input: z.unknown().optional(),
+    output: z.unknown().optional(),
+    error: z.unknown().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+const OpencodeToolPartBaseSchema = z
+    .object({
+    tool: z.string().trim().min(1),
+    state: OpencodeToolStateSchema.optional(),
+})
+    .passthrough();
+const OpencodeToolPartWithCallIdSchema = OpencodeToolPartBaseSchema.extend({
+    callID: z.string().trim().min(1),
+    id: z.string().optional(),
+}).transform((part) => ({
+    toolName: part.tool,
+    callId: part.callID,
+    status: part.state?.status,
+    input: part.state?.input,
+    output: part.state?.output,
+    error: part.state?.error,
+    metadata: part.state?.metadata,
+}));
+const OpencodeToolPartWithIdSchema = OpencodeToolPartBaseSchema.extend({
+    id: z.string().trim().min(1),
+    callID: z.string().optional(),
+}).transform((part) => ({
+    toolName: part.tool,
+    callId: part.id,
+    status: part.state?.status,
+    input: part.state?.input,
+    output: part.state?.output,
+    error: part.state?.error,
+    metadata: part.state?.metadata,
+}));
+const OpencodeToolPartWithoutIdSchema = OpencodeToolPartBaseSchema.extend({
+    id: z.string().optional(),
+    callID: z.string().optional(),
+}).transform((part) => ({
+    toolName: part.tool,
+    callId: undefined,
+    status: part.state?.status,
+    input: part.state?.input,
+    output: part.state?.output,
+    error: part.state?.error,
+    metadata: part.state?.metadata,
+}));
+const OpencodeToolPartSchema = z.union([
+    OpencodeToolPartWithCallIdSchema,
+    OpencodeToolPartWithIdSchema,
+    OpencodeToolPartWithoutIdSchema,
+]);
+const OpencodeToolPartTimelineEnvelopeSchema = OpencodeToolPartSchema.transform((part) => ({
+    toolName: part.toolName,
+    callId: part.callId,
+    status: part.status,
+    input: part.input,
+    output: part.output,
+    error: part.error,
+    metadata: part.metadata,
+}));
+const OpencodeToolPartToTimelineItemSchema = OpencodeToolPartTimelineEnvelopeSchema.transform((part) => mapOpencodeToolCall({
+    toolName: part.toolName,
+    callId: part.callId,
+    status: part.status,
+    input: part.input,
+    output: part.output,
+    error: part.error,
+    metadata: part.metadata,
+}));
+function toOpenCodeMcpConfig(config) {
+    if (config.type === "stdio") {
+        return {
+            type: "local",
+            command: [config.command, ...(config.args ?? [])],
+            ...(config.env ? { environment: config.env } : {}),
+            enabled: true,
+        };
+    }
+    return {
+        type: "remote",
+        url: config.url,
+        ...(config.headers ? { headers: config.headers } : {}),
+        enabled: true,
+    };
+}
+function toTerminalTurnEvent(event) {
+    if (event.type === "turn_failed") {
+        return {
+            type: "turn_failed",
+            provider: "opencode",
+            error: toDiagnosticErrorMessage(event.error),
+        };
+    }
+    if (event.type === "turn_completed" || event.type === "turn_canceled") {
+        return event;
+    }
+    return null;
+}
+function isOpenCodeNotFoundError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "NotFoundError");
+}
+async function abortOpenCodeSession(params) {
+    const { client, sessionId, directory, logger } = params;
+    try {
+        const response = await client.session.abort({
+            sessionID: sessionId,
+            directory,
+        });
+        if (response.error && !isOpenCodeNotFoundError(response.error)) {
+            logger.warn({
+                sessionId,
+                error: toDiagnosticErrorMessage(response.error),
+            }, "Failed to abort OpenCode session during close");
+        }
+    }
+    catch (error) {
+        logger.warn({
+            sessionId,
+            error: toDiagnosticErrorMessage(error),
+        }, "Failed to abort OpenCode session during close");
+    }
+}
+function isOpenCodeHeadersTimeoutFailure(error) {
+    const diagnostics = new Set();
+    const queue = [error];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        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") {
+                    continue;
+                }
+                const diagnostic = value.trim().toLowerCase();
+                if (diagnostic) {
+                    diagnostics.add(diagnostic);
+                }
+            }
+            if (record.cause) {
+                queue.push(record.cause);
+            }
+        }
+    }
+    return [...diagnostics].some((diagnostic) => OPENCODE_HEADERS_TIMEOUT_TOKENS.some((token) => diagnostic.includes(token)));
+}
+function isAlreadyPresentMcpError(error) {
+    const normalized = toDiagnosticErrorMessage(error).toLowerCase();
+    return MCP_ALREADY_PRESENT_ERROR_TOKENS.some((token) => normalized.includes(token));
+}
+function readOpenCodeMcpOperationError(data, name) {
+    const root = readOpenCodeRecord(data);
+    const entry = readOpenCodeRecord(root?.[name]);
+    if (!entry || entry.status !== "failed") {
+        return undefined;
+    }
+    return entry.error ?? `OpenCode reported MCP server '${name}' failed`;
+}
+function matchesHydratedFingerprint(fingerprints, id, value) {
+    const hydratedFingerprint = fingerprints?.get(id);
+    if (!hydratedFingerprint) {
+        return false;
+    }
+    fingerprints?.delete(id);
+    return hydratedFingerprint === JSON.stringify(value);
+}
+// `null` = no explicit mode. The `agent` field is then omitted from OpenCode
+// prompt/command calls so OpenCode falls back to its own configured default
+// agent — never assume any particular agent (even `build`) exists, since
+// OpenCode users can define or delete agents at will.
+function normalizeOpenCodeModeId(modeId) {
+    const trimmed = typeof modeId === "string" ? modeId.trim() : "";
+    if (!trimmed || trimmed === "default") {
+        return null;
+    }
+    return trimmed;
+}
+function normalizeOpenCodeVariantId(variantId) {
+    const trimmed = typeof variantId === "string" ? variantId.trim() : "";
+    if (!trimmed || trimmed === OPENCODE_DEFAULT_VARIANT_ID) {
+        return null;
+    }
+    return trimmed;
+}
+function resolveOpenCodeRuntimeAgentId(modeId) {
+    const normalizedModeId = normalizeOpenCodeModeId(modeId);
+    if (normalizedModeId === null) {
+        return undefined;
+    }
+    return normalizedModeId === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID
+        ? OPENCODE_BUILD_MODE_ID
+        : normalizedModeId;
+}
+function normalizeOpenCodeConfig(config) {
+    const normalized = {
+        ...config,
+        thinkingOptionId: normalizeOpenCodeVariantId(config.thinkingOptionId) ?? undefined,
+    };
+    if (normalizeOpenCodeModeId(normalized.modeId) !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
+        return normalized;
+    }
+    return {
+        ...normalized,
+        modeId: OPENCODE_BUILD_MODE_ID,
+        featureValues: {
+            ...normalized.featureValues,
+            [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: true,
+        },
+    };
+}
+function isSelectableOpenCodeAgent(agent) {
+    return (agent.mode === "primary" || agent.mode === "all") && agent.hidden !== true;
+}
+const OPENCODE_AGENT_HEX_COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+function readOpenCodeAgentHexColor(agent) {
+    return typeof agent.color === "string" && OPENCODE_AGENT_HEX_COLOR_PATTERN.test(agent.color)
+        ? agent.color
+        : undefined;
+}
+function mapOpenCodeAgentToMode(agent) {
+    const colorTier = readOpenCodeAgentHexColor(agent);
+    return {
+        id: agent.name,
+        label: agent.name.charAt(0).toUpperCase() + agent.name.slice(1),
+        icon: "Bot",
+        description: typeof agent.description === "string" && agent.description.trim().length > 0
+            ? agent.description.trim()
+            : DEFAULT_MODES.find((mode) => mode.id === agent.name)?.description,
+        ...(colorTier ? { colorTier } : {}),
+    };
+}
+function mergeOpenCodeModes(discoveredModes) {
+    const filtered = discoveredModes.filter((mode) => mode.id !== OPENCODE_LEGACY_FULL_ACCESS_MODE_ID);
+    // When discovery returns results, trust them exactly — don't inject hardcoded
+    // defaults that the user may have intentionally disabled in their OpenCode config.
+    // When discovery produced nothing, return empty rather than fabricating modes:
+    // OpenCode users can rename or delete any agent, so a hardcoded fallback can
+    // validate a mode that does not actually exist (failing later at prompt time).
+    return sortOpenCodeModes(filtered);
+}
+function sortOpenCodeModes(modes) {
+    const order = new Map(DEFAULT_MODES.map((mode, index) => [mode.id, index]));
+    return [...modes].sort((left, right) => {
+        const leftOrder = order.get(left.id) ?? Number.MAX_SAFE_INTEGER;
+        const rightOrder = order.get(right.id) ?? Number.MAX_SAFE_INTEGER;
+        if (leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+        return left.label.localeCompare(right.label);
+    });
+}
+function readPositiveFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+function maxFiniteNumber(left, right) {
+    return left === undefined ? right : Math.max(left, right);
+}
+function assignUsageNumber(usage, key, value) {
+    if (value !== undefined) {
+        usage[key] = value;
+    }
+}
+function buildOpenCodeModelLookupKey(providerId, modelId) {
+    return `${providerId}/${modelId}`;
+}
+function parseOpenCodeModelLookupKey(modelId) {
+    if (typeof modelId !== "string" || modelId.trim().length === 0) {
+        return undefined;
+    }
+    const slashIndex = modelId.indexOf("/");
+    if (slashIndex <= 0 || slashIndex === modelId.length - 1) {
+        return undefined;
+    }
+    const providerId = modelId.slice(0, slashIndex).trim();
+    const providerModelId = modelId.slice(slashIndex + 1).trim();
+    if (!providerId || !providerModelId) {
+        return undefined;
+    }
+    return buildOpenCodeModelLookupKey(providerId, providerModelId);
+}
+function extractOpenCodeModelContextWindow(model) {
+    if (!model || typeof model !== "object") {
+        return undefined;
+    }
+    const limit = model.limit;
+    return readPositiveFiniteNumber(limit?.context);
+}
+function buildOpenCodeModelDefinition(provider, modelId, model) {
+    const rawVariants = model.variants ? Object.keys(model.variants) : [];
+    // OpenCode lists only overrides; its base model behavior is selected by omitting `variant`.
+    const thinkingOptions = rawVariants.length
+        ? [
+            { id: OPENCODE_DEFAULT_VARIANT_ID, label: "Default", isDefault: true },
+            ...rawVariants.map((id) => ({ id, label: id })),
+        ]
+        : [];
+    return {
+        provider: "opencode",
+        id: `${provider.id}/${modelId}`,
+        label: model.name,
+        description: `${provider.name} - ${model.family ?? ""}`.trim(),
+        thinkingOptions: thinkingOptions.length > 0 ? thinkingOptions : undefined,
+        defaultThinkingOptionId: thinkingOptions[0]?.id,
+        metadata: {
+            providerId: provider.id,
+            providerName: provider.name,
+            modelId,
+            family: model.family,
+            releaseDate: model.release_date,
+            supportsAttachments: model.attachment,
+            supportsReasoning: model.reasoning,
+            supportsToolCall: model.tool_call,
+            cost: model.cost,
+            contextWindowMaxTokens: extractOpenCodeModelContextWindow(model),
+            ...(model.limit ? { limit: model.limit } : {}),
+        },
+    };
+}
+function resolveOpenCodeSelectedModelContextWindow(providers, modelId) {
+    if (!providers) {
+        return undefined;
+    }
+    const modelLookupKey = parseOpenCodeModelLookupKey(modelId);
+    if (!modelLookupKey) {
+        return undefined;
+    }
+    const lookup = buildOpenCodeModelContextWindowLookup(providers);
+    return lookup.get(modelLookupKey);
+}
+function buildOpenCodeModelContextWindowLookup(providers) {
+    const lookup = new Map();
+    if (!providers) {
+        return lookup;
+    }
+    const connectedProviderIds = new Set(providers.connected ?? []);
+    for (const provider of providers.all ?? []) {
+        // Providers with source "api" are managed by the OpenCode console/subscription and are
+        // usable even though they don't appear in `connected` (which only lists env/config providers).
+        if (!connectedProviderIds.has(provider.id) && provider.source !== "api") {
+            continue;
+        }
+        for (const [modelId, modelDefinition] of Object.entries(provider.models ?? {})) {
+            const contextWindow = extractOpenCodeModelContextWindow(modelDefinition);
+            if (contextWindow === undefined) {
+                continue;
+            }
+            lookup.set(buildOpenCodeModelLookupKey(provider.id, modelId), contextWindow);
+        }
+    }
+    return lookup;
+}
+function resolveOpenCodeModelLookupKeyFromAssistantMessage(info) {
+    const providerId = info.providerID;
+    const modelId = info.modelID;
+    if (!providerId || !modelId) {
+        return undefined;
+    }
+    return buildOpenCodeModelLookupKey(providerId, modelId);
+}
+function mergeOpenCodeStepFinishUsage(usage, part, options = {}) {
+    const inputTokens = readPositiveFiniteNumber(part.tokens?.input);
+    const outputTokens = readPositiveFiniteNumber(part.tokens?.output);
+    const reasoningTokens = readPositiveFiniteNumber(part.tokens?.reasoning);
+    const cacheReadTokens = readPositiveFiniteNumber(part.tokens?.cache?.read);
+    const cacheWriteTokens = readPositiveFiniteNumber(part.tokens?.cache?.write);
+    const totalTokens = (inputTokens ?? 0) +
+        (outputTokens ?? 0) +
+        (reasoningTokens ?? 0) +
+        (cacheReadTokens ?? 0) +
+        (cacheWriteTokens ?? 0);
+    const cost = readPositiveFiniteNumber(part.cost);
+    assignUsageNumber(usage, "inputTokens", inputTokens);
+    assignUsageNumber(usage, "cachedInputTokens", cacheReadTokens);
+    assignUsageNumber(usage, "outputTokens", outputTokens);
+    if (totalTokens > 0) {
+        usage.contextWindowUsedTokens = totalTokens;
+    }
+    if (cost !== undefined) {
+        usage.totalCostUsd = options.totalCostUsd ?? (usage.totalCostUsd ?? 0) + cost;
+    }
+}
+function hasNormalizedOpenCodeUsage(usage) {
+    return [
+        usage.inputTokens,
+        usage.cachedInputTokens,
+        usage.outputTokens,
+        usage.totalCostUsd,
+        usage.contextWindowMaxTokens,
+        usage.contextWindowUsedTokens,
+    ].some((value) => typeof value === "number" && Number.isFinite(value));
+}
+function getOpenCodeAttachmentExtension(mimeType) {
+    switch (mimeType) {
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+            return "jpg";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        default:
+            return "bin";
+    }
+}
+function toOpenCodeDataUrl(mimeType, data) {
+    const match = data.match(/^data:([^;,]+);base64,(.+)$/);
+    if (match) {
+        return {
+            mimeType: match[1] ?? mimeType,
+            url: data,
+        };
+    }
+    return {
+        mimeType,
+        url: `data:${mimeType};base64,${data}`,
+    };
+}
+function buildOpenCodePromptParts(prompt) {
+    if (typeof prompt === "string") {
+        return [{ type: "text", text: prompt }];
+    }
+    let attachmentOrdinal = 0;
+    const output = [];
+    for (const part of prompt) {
+        if (part.type === "text") {
+            output.push({ type: "text", text: part.text });
+            continue;
+        }
+        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;
+        }
+        output.push({ type: "text", text: renderPromptAttachmentAsText(part) });
+    }
+    return output;
+}
+function buildOpenCodeUserTimelineText(prompt) {
+    if (typeof prompt === "string") {
+        return prompt;
+    }
+    return prompt
+        .map((part) => {
+        if (part.type === "text") {
+            return part.text;
+        }
+        if (part.type === "image") {
+            return "[Image]";
+        }
+        return renderPromptAttachmentAsText(part);
+    })
+        .filter((text) => text.trim().length > 0)
+        .join("\n");
+}
+function isOpenCodeDefinitiveSteerRejection(error, status) {
+    if (status === 404)
+        return true;
+    const message = toDiagnosticErrorMessage(error).toLowerCase();
+    return /session\s+(?:is\s+)?(?:not found|inactive|not active|not running)/.test(message);
+}
+async function collectOpenCodeImportableSessionsFromSdk(client, options) {
+    const limit = options?.limit ?? OPENCODE_PERSISTED_SESSION_LIMIT;
+    const scanLimit = Math.min(options?.scanLimit ?? limit, 500);
+    const sessionListLimit = Math.min(options?.cwd ? Math.max(scanLimit, OPENCODE_PERSISTED_SESSION_LIMIT) : scanLimit, 500);
+    const response = await client.experimental.session.list({
+        archived: true,
+        roots: true,
+        limit: sessionListLimit,
+        ...(options?.cwd ? { directory: options.cwd } : {}),
+    });
+    if (response.error) {
+        throw new Error(`Failed to list OpenCode sessions: ${JSON.stringify(response.error)}`);
+    }
+    return selectOpenCodeSessionsForWorkspace(response.data ?? [], options?.cwd)
+        .sort((left, right) => getOpenCodeSessionTimestamp(right) - getOpenCodeSessionTimestamp(left))
+        .slice(0, limit)
+        .map((session) => ({
+        providerHandleId: session.id,
+        cwd: session.directory,
+        title: normalizeOpenCodeSessionTitle(session.title),
+        firstPromptPreview: null,
+        lastPromptPreview: null,
+        lastActivityAt: new Date(getOpenCodeSessionTimestamp(session)),
+    }));
+}
+function selectOpenCodeSessionsForWorkspace(sessions, cwd) {
+    if (!cwd)
+        return sessions;
+    const belongsToWorkspace = createPathEquivalenceMatcher(cwd);
+    return sessions.filter((session) => belongsToWorkspace(session.directory));
+}
+function openCodeCatalogDirectory(options, resolveHomeDir) {
+    if (options.scope === "workspace") {
+        return { directory: options.cwd, needsDirectory: false };
+    }
+    return { directory: resolveHomeDir(), needsDirectory: true };
+}
+function normalizeOpenCodeSessionTitle(title) {
+    const normalized = title?.trim();
+    return normalized ? normalized : null;
+}
+function getOpenCodeSessionTimestamp(session) {
+    return session.time?.updated ?? session.time?.created ?? 0;
+}
+function resolveOpenCodeReplayTimestamp(params) {
+    const timedPart = params.part;
+    const partTimestamp = timedPart?.time?.start ??
+        timedPart?.time?.end ??
+        params.message.time?.created ??
+        params.message.time?.completed;
+    return normalizeProviderReplayTimestamp(partTimestamp);
+}
+function buildOpenCodeReplayTimelineEvent(params) {
+    const timestamp = resolveOpenCodeReplayTimestamp({
+        message: params.message,
+        part: params.part,
+    });
+    return {
+        type: "timeline",
+        provider: "opencode",
+        item: params.item,
+        ...(timestamp ? { timestamp } : {}),
+    };
+}
+function buildOpenCodeReplayPartTimelineEvent(params) {
+    const { part, message } = params;
+    if (part.type === "text" && part.text) {
+        return buildOpenCodeReplayTimelineEvent({
+            item: { type: "assistant_message", text: part.text, messageId: message.id },
+            message,
+            part,
+        });
+    }
+    if (part.type === "reasoning" && part.text) {
+        return buildOpenCodeReplayTimelineEvent({
+            item: { type: "reasoning", text: part.text },
+            message,
+            part,
+        });
+    }
+    if (part.type !== "tool") {
+        return null;
+    }
+    if (isOpenCodeTodoWriteToolPart(part)) {
+        const todos = readOpenCodeTodoItemsFromToolPart(part);
+        if (!todos) {
+            return null;
+        }
+        return buildOpenCodeReplayTimelineEvent({
+            item: mapOpenCodeTodosToTimelineItems(todos),
+            message,
+            part,
+        });
+    }
+    const parsedToolPart = OpencodeToolPartToTimelineItemSchema.safeParse(part);
+    if (!parsedToolPart.success || !parsedToolPart.data) {
+        return null;
+    }
+    return buildOpenCodeReplayTimelineEvent({
+        item: parsedToolPart.data,
+        message,
+        part,
+    });
+}
+function isOpenCodeCompactionSummaryMessage(message) {
+    return (message.role === "assistant" &&
+        (message.summary === true || message.agent === "compaction" || message.mode === "compaction"));
+}
+function findOpenCodeCompactionPart(message) {
+    return message.parts.find((part) => part.type === "compaction");
+}
+async function readOpenCodeSessionMessagesFromSdk(client, session, signal) {
+    const response = await client.session.messages({
+        sessionID: session.id,
+        directory: session.directory,
+    }, signal ? { signal } : undefined);
+    if (response.error || !response.data) {
+        return [];
+    }
+    return filterOpenCodeRevertedMessages(response.data, session.revert);
+}
+function buildOpenCodeSessionTimeline(messages) {
+    const timeline = [];
+    let hideNextAssistantAfterCompaction = false;
+    for (const message of messages) {
+        const compactionPart = findOpenCodeCompactionPart(message);
+        if (message.info.role === "assistant" && hideNextAssistantAfterCompaction) {
+            hideNextAssistantAfterCompaction = false;
+            continue;
+        }
+        if (message.info.role === "user" && !compactionPart) {
+            hideNextAssistantAfterCompaction = false;
+        }
+        timeline.push(...buildOpenCodeReplayTimelineEvents(message).map((event) => event.item));
+        if (message.info.role === "user" && compactionPart) {
+            timeline.push(createCompactionTimelineItem("completed", compactionPart.auto ? "auto" : "manual"));
+            hideNextAssistantAfterCompaction = true;
+        }
+    }
+    return timeline;
+}
+function filterOpenCodeRevertedMessages(messages, revert) {
+    if (!revert?.messageID || revert.partID) {
+        return [...messages];
+    }
+    const revertIndex = messages.findIndex((message) => message.info.id === revert.messageID);
+    if (revertIndex < 0) {
+        return [...messages];
+    }
+    return messages.slice(0, revertIndex);
+}
+function resolveOpenCodePersistedSessionModeId(session, messages) {
+    const agent = session.agent ?? messages.map(readOpenCodeMessageAgent).find(Boolean);
+    return agent ? (normalizeOpenCodeModeId(agent) ?? undefined) : undefined;
+}
+function readOpenCodeMessageAgent(message) {
+    const agent = message.info.agent;
+    return typeof agent === "string" && agent.trim() ? agent : undefined;
+}
+function resolveOpenCodePersistedSessionModel(session, messages) {
+    if (session.model) {
+        return buildOpenCodeModelLookupKey(session.model.providerID, session.model.id);
+    }
+    const model = messages.map(readOpenCodeMessageModel).find(Boolean);
+    return model ? buildOpenCodeModelLookupKey(model.providerID, model.modelID) : undefined;
+}
+function readOpenCodeMessageModel(message) {
+    const { info } = message;
+    if (info.role === "user") {
+        return info.model;
+    }
+    return {
+        providerID: info.providerID,
+        modelID: info.modelID,
+    };
+}
+function buildOpenCodeReplayTimelineEvents(message) {
+    const { info, parts } = message;
+    if (isOpenCodeCompactionSummaryMessage(info)) {
+        return [];
+    }
+    if (info.role === "user") {
+        const text = parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+        return text
+            ? [
+                buildOpenCodeReplayTimelineEvent({
+                    item: { type: "user_message", text, messageId: info.id },
+                    message: info,
+                }),
+            ]
+            : [];
+    }
+    const events = [];
+    let emittedAssistantText = false;
+    for (const part of parts) {
+        if (part.type === "text" && part.text) {
+            emittedAssistantText = true;
+        }
+        const event = buildOpenCodeReplayPartTimelineEvent({ part, message: info });
+        if (event) {
+            events.push(event);
+        }
+    }
+    if (!emittedAssistantText) {
+        const text = stringifyStructuredAssistantMessage(info.structured);
+        if (text) {
+            events.push(buildOpenCodeReplayTimelineEvent({
+                item: { type: "assistant_message", text, messageId: info.id },
+                message: info,
+            }));
+        }
+    }
+    return events;
+}
+export const __openCodeInternals = {
+    buildOpenCodePromptParts,
+    buildOpenCodeSessionTimeline,
+    buildOpenCodeModelContextWindowLookup,
+    buildOpenCodeModelDefinition,
+    buildOpenCodeModelLookupKey,
+    extractOpenCodeModelContextWindow,
+    hasNormalizedOpenCodeUsage,
+    mergeOpenCodeStepFinishUsage,
+    parseOpenCodeModelLookupKey,
+    resolveOpenCodeModelLookupKeyFromAssistantMessage,
+    resolveOpenCodeSelectedModelContextWindow,
+    isSelectableOpenCodeAgent,
+    mapOpenCodeAgentToMode,
+    resolveOpenCodeHomeDir,
+    get OpenCodeAgentSession() {
+        return OpenCodeAgentSession;
+    },
+};
+function createSdkOpenCodeClient(options) {
+    return createOpencodeClient(options);
+}
+export class OpenCodeAgentClient {
+    constructor(logger, runtimeSettings, deps = {}) {
+        this.provider = "opencode";
+        this.resolveCreateConfig = resolveOpenCodeCreateConfig;
+        this.isCreateConfigUnattended = isOpenCodeCreateConfigUnattended;
+        this.modelContextWindows = new Map();
+        this.logger = logger.child({ module: "agent", provider: "opencode" });
+        this.bridge = deps.bridge;
+        this.capabilities = {
+            ...OPENCODE_CAPABILITIES,
+            ...(this.bridge ? { supportsNativePaseoTools: true } : {}),
+        };
+        this.runtimeSettings = runtimeSettings;
+        this.createOpenCodeClient = deps.createClient ?? createSdkOpenCodeClient;
+        this.serverManager =
+            deps.serverManager ??
+                OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
+                    managedProcesses: deps.managedProcesses,
+                    resolveHomeDir: deps.resolveHomeDir,
+                    createEventSource: ({ serverUrl, processExit, logger: eventLogger }) => new OpenCodeEventConsumer({
+                        serverUrl,
+                        processExit,
+                        logger: eventLogger,
+                        createClient: (baseUrl) => this.createOpenCodeClient({ baseUrl, directory: "" }),
+                    }),
+                    decorateServerEnv: this.bridge
+                        ? (env) => this.bridge?.decorateServerEnv(env) ?? env
+                        : undefined,
+                });
+        this.resolveHomeDir = deps.resolveHomeDir ?? resolveOpenCodeHomeDir;
+    }
+    async createSession(config, launchContext, options) {
+        const openCodeConfig = this.assertConfig(config);
+        const acquisition = await this.acquireServer(openCodeConfig, launchContext);
+        const { url } = acquisition.server;
+        const client = this.createOpenCodeClient({
+            baseUrl: url,
+            directory: openCodeConfig.cwd,
+        });
+        try {
+            // Creating the first session for a directory is part of OpenCode coming up, so it
+            // shares the server startup budget instead of a shorter one that fails agent
+            // creation on contended cold starts.
+            const response = await withTimeout(client.session.create({ directory: openCodeConfig.cwd }), OPENCODE_SERVER_STARTUP_TIMEOUT_MS, `OpenCode session.create timed out after ${Math.round(OPENCODE_SERVER_STARTUP_TIMEOUT_MS / 1000)}s`);
+            if (response.error) {
+                throw new Error(`Failed to create OpenCode session: ${JSON.stringify(response.error)}`);
+            }
+            const session = response.data;
+            if (!session) {
+                throw new Error("OpenCode session creation returned no data");
+            }
+            await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
+            const unbindBridge = this.bindBridgeSession(session.id, launchContext);
+            return new OpenCodeAgentSession(openCodeConfig, client, session.id, this.logger, new Map(this.modelContextWindows), acquisition.events, acquisition.release, options?.persistSession, launchContext?.agentId, url, false, unbindBridge);
+        }
+        catch (error) {
+            await acquisition.release();
+            throw error;
+        }
+    }
+    async resumeSession(handle, overrides, launchContext) {
+        const metadata = (handle.metadata ?? {});
+        const cwd = overrides?.cwd ?? metadata.cwd;
+        if (!cwd) {
+            throw new Error("OpenCode resume requires the original working directory");
+        }
+        const config = {
+            ...metadata,
+            ...overrides,
+            provider: "opencode",
+            cwd,
+        };
+        const openCodeConfig = this.assertConfig(config);
+        const registeredServerUrl = getOpenCodeChildSessionServerUrl(handle.sessionId);
+        const registeredAcquisition = registeredServerUrl
+            ? this.serverManager.acquireExisting(registeredServerUrl)
+            : null;
+        const acquisition = registeredAcquisition ?? (await this.acquireServer(openCodeConfig, launchContext));
+        const { url } = acquisition.server;
+        const client = this.createOpenCodeClient({
+            baseUrl: url,
+            directory: openCodeConfig.cwd,
+        });
+        try {
+            await this.populateModelContextWindowCache(client, openCodeConfig.cwd);
+            const unbindBridge = this.bindBridgeSession(handle.sessionId, launchContext);
+            return new OpenCodeAgentSession(openCodeConfig, client, handle.sessionId, this.logger, new Map(this.modelContextWindows), acquisition.events, acquisition.release, undefined, launchContext?.agentId, url, registeredAcquisition !== null, unbindBridge);
+        }
+        catch (error) {
+            await acquisition.release();
+            throw error;
+        }
+    }
+    acquireServer(config, launchContext) {
+        if (!this.bridge || requiresDedicatedOpenCodeServer(config, launchContext)) {
+            return launchContext?.env
+                ? this.serverManager.acquireDedicated(launchContext.env)
+                : this.serverManager.acquireCurrent();
+        }
+        return this.serverManager.acquireCurrent();
+    }
+    bindBridgeSession(sessionId, launchContext) {
+        if (!this.bridge || !launchContext)
+            return undefined;
+        return this.bridge.bindSession({
+            sessionId,
+            env: launchContext.env ?? {},
+            tools: launchContext.paseoTools,
+        });
+    }
+    async fetchCatalog(options, context) {
+        let acquisition;
+        try {
+            await runProviderRefreshActivity(context, "server.acquire", async () => {
+                acquisition = options.force
+                    ? await this.serverManager.acquireNew(context?.signal)
+                    : await this.serverManager.acquireCurrent(context?.signal);
+            });
+            if (!acquisition)
+                throw new Error("OpenCode server acquisition did not complete");
+            context?.signal.throwIfAborted();
+            const { url } = acquisition.server;
+            const catalogDirectory = openCodeCatalogDirectory(options, this.resolveHomeDir);
+            const { directory } = catalogDirectory;
+            if (catalogDirectory.needsDirectory) {
+                await fs.mkdir(directory, { recursive: true });
+                this.logger.debug({ directory }, "opencode catalog refresh: using opencode-home for global provider catalog");
+            }
+            const client = this.createOpenCodeClient({ baseUrl: url, directory });
+            const [models, modes] = await Promise.all([
+                this.fetchModelsFromClient(client, directory, context),
+                this.fetchModesFromClient(client, directory, context),
+            ]);
+            return { models, modes };
+        }
+        finally {
+            await acquisition?.release();
+        }
+    }
+    async listCommands(config) {
+        const openCodeConfig = this.assertConfig(config);
+        const acquisition = await this.serverManager.acquireCurrent();
+        const { url } = acquisition.server;
+        const client = this.createOpenCodeClient({
+            baseUrl: url,
+            directory: openCodeConfig.cwd,
+        });
+        try {
+            return await listOpenCodeCommandsFromSdk(client, openCodeConfig.cwd);
+        }
+        finally {
+            await acquisition.release();
+        }
+    }
+    async listFeatures(config) {
+        return [buildOpenCodeAutoAcceptFeature(this.assertConfig(config))];
+    }
+    async listImportableSessions(options) {
+        const acquisition = await this.serverManager.acquireCurrent();
+        const { url } = acquisition.server;
+        const client = this.createOpenCodeClient({
+            baseUrl: url,
+            directory: options?.cwd ?? "",
+        });
+        try {
+            return await collectOpenCodeImportableSessionsFromSdk(client, options);
+        }
+        finally {
+            await acquisition.release();
+        }
+    }
+    async importSession(input, context) {
+        const acquisition = await this.serverManager.acquireCurrent();
+        const { url } = acquisition.server;
+        const client = this.createOpenCodeClient({
+            baseUrl: url,
+            directory: input.cwd,
+        });
+        try {
+            const sessionResponse = await client.session.get({
+                sessionID: input.providerHandleId,
+                directory: input.cwd,
+            });
+            if (sessionResponse.error || !sessionResponse.data) {
+                throw new Error(`Failed to load OpenCode session ${input.providerHandleId}`);
+            }
+            const session = sessionResponse.data;
+            const messages = await readOpenCodeSessionMessagesFromSdk(client, session);
+            const modeId = resolveOpenCodePersistedSessionModeId(session, messages);
+            const model = resolveOpenCodePersistedSessionModel(session, messages);
+            return await importSessionFromPersistence({
+                provider: "opencode",
+                request: input,
+                context,
+                resumeSession: this.resumeSession.bind(this),
+                config: {
+                    title: normalizeOpenCodeSessionTitle(session.title) ?? undefined,
+                    ...(modeId ? { modeId } : {}),
+                    ...(model ? { model } : {}),
+                },
+            });
+        }
+        finally {
+            await acquisition.release();
+        }
+    }
+    async archiveNativeSession(handle) {
+        await this.setNativeSessionArchived(handle, Date.now());
+    }
+    async unarchiveNativeSession(handle) {
+        // OpenCode's numeric archive field uses zero as the active-session sentinel.
+        await this.setNativeSessionArchived(handle, 0);
+    }
+    async setNativeSessionArchived(handle, archivedAt) {
+        const metadata = (handle.metadata ?? {});
+        if (!metadata.cwd) {
+            throw new Error("OpenCode native archive update requires the original working directory");
+        }
+        const registeredServerUrl = getOpenCodeChildSessionServerUrl(handle.sessionId);
+        const acquisition = (registeredServerUrl ? this.serverManager.acquireExisting(registeredServerUrl) : null) ??
+            (await this.serverManager.acquireCurrent());
+        const client = this.createOpenCodeClient({
+            baseUrl: acquisition.server.url,
+            directory: metadata.cwd,
+        });
+        try {
+            const response = readOpenCodeRecord(await client.session.update({
+                sessionID: handle.sessionId,
+                directory: metadata.cwd,
+                time: { archived: archivedAt },
+            }));
+            if (response?.error) {
+                throw new Error(`Failed to ${archivedAt === 0 ? "unarchive" : "archive"} OpenCode session: ${toDiagnosticErrorMessage(response.error)}`);
+            }
+        }
+        finally {
+            await acquisition.release();
+        }
+    }
+    async isAvailable() {
+        const launch = await resolveProviderLaunch({
+            commandConfig: this.runtimeSettings?.command,
+            defaultBinary: "opencode",
+        });
+        const availability = await checkProviderLaunchAvailable(launch);
+        return availability.available;
+    }
+    async shutdown() {
+        await this.serverManager.shutdown();
+    }
+    async getDiagnostic() {
+        try {
+            const launch = await resolveProviderLaunch({
+                commandConfig: this.runtimeSettings?.command,
+                defaultBinary: "opencode",
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            let authValue = "Not checked";
+            const authCommand = availability.available
+                ? (availability.resolvedPath ?? launch.command)
+                : null;
+            if (authCommand) {
+                try {
+                    const { stdout, stderr } = await execCommand(authCommand, [...launch.args, "auth", "list"], {
+                        ...createProviderEnvSpec(),
+                        timeout: 5000,
+                    });
+                    const text = (stdout.trim() || stderr.trim()).trim();
+                    authValue = text ? `\n    ${text.replace(/\n/g, "\n    ")}` : "(empty)";
+                }
+                catch (error) {
+                    authValue = `Error - ${toDiagnosticErrorMessage(error)}`;
+                }
+            }
+            return {
+                diagnostic: formatProviderDiagnostic("OpenCode", [
+                    ...(await buildCommandResolutionDiagnosticRows(launch, {
+                        knownBinaryNames: ["opencode"],
+                    })),
+                    ...(await buildBinaryDiagnosticRows(launch, availability)),
+                    { label: "Auth", value: authValue },
+                ]),
+            };
+        }
+        catch (error) {
+            return {
+                diagnostic: formatProviderDiagnosticError("OpenCode", error),
+            };
+        }
+    }
+    async fetchModelsFromClient(client, directory, context) {
+        const response = await runProviderRefreshActivity(context, "provider.list", () => raceProviderRefreshAbort(context?.signal, openCodeMetadataLimit(() => {
+            context?.signal.throwIfAborted();
+            return client.provider.list({ directory }, context ? { signal: context.signal } : undefined);
+        })));
+        if (response.error) {
+            throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
+        }
+        const providers = response.data;
+        if (!providers) {
+            return [];
+        }
+        const connectedProviderIds = new Set(providers.connected);
+        const isAccessible = (provider) => connectedProviderIds.has(provider.id) || provider.source === "api";
+        if (!providers.all.some(isAccessible)) {
+            throw new Error("OpenCode has no connected providers. Please authenticate with at least one provider " +
+                "(e.g., openai, anthropic), set appropriate environment variables (e.g., OPENAI_API_KEY), " +
+                "or log in to OpenCode Go via the console.");
+        }
+        const models = [];
+        const contextWindows = new Map();
+        for (const provider of providers.all) {
+            if (!isAccessible(provider)) {
+                continue;
+            }
+            for (const [modelId, model] of Object.entries(provider.models)) {
+                const definition = buildOpenCodeModelDefinition(provider, modelId, model);
+                const contextWindowMaxTokens = extractOpenCodeModelContextWindow(model);
+                if (contextWindowMaxTokens !== undefined) {
+                    contextWindows.set(buildOpenCodeModelLookupKey(provider.id, modelId), contextWindowMaxTokens);
+                }
+                models.push(definition);
+            }
+        }
+        context?.signal.throwIfAborted();
+        this.modelContextWindows.clear();
+        for (const [key, value] of contextWindows)
+            this.modelContextWindows.set(key, value);
+        return models;
+    }
+    async fetchModesFromClient(client, directory, context) {
+        const response = await runProviderRefreshActivity(context, "app.agents", () => raceProviderRefreshAbort(context?.signal, openCodeMetadataLimit(() => {
+            context?.signal.throwIfAborted();
+            return client.app.agents({ directory }, context ? { signal: context.signal } : undefined);
+        })));
+        if (response.error || !response.data) {
+            // Discovery failed — return an empty list rather than fabricating
+            // modes. OpenCode users can rename or delete any agent (including
+            // "build"/"plan"), so a hardcoded fallback can validate a mode that
+            // does not actually exist, which then fails at prompt time.
+            return [];
+        }
+        const discovered = response.data.filter(isSelectableOpenCodeAgent).map(mapOpenCodeAgentToMode);
+        return mergeOpenCodeModes(discovered);
+    }
+    assertConfig(config) {
+        if (config.provider !== "opencode") {
+            throw new Error(`OpenCodeAgentClient received config for provider '${config.provider}'`);
+        }
+        const providerOptions = OpenCodeProviderOptionsSchema.parse(config.providerOptions ?? {});
+        return normalizeOpenCodeConfig({ ...config, provider: "opencode", providerOptions });
+    }
+    async populateModelContextWindowCache(client, cwd) {
+        const response = await openCodeMetadataLimit(() => client.provider.list({ directory: cwd }));
+        if (response.error || !response.data) {
+            return;
+        }
+        const lookup = buildOpenCodeModelContextWindowLookup(response.data);
+        this.modelContextWindows.clear();
+        for (const [modelLookupKey, contextWindowMaxTokens] of lookup.entries()) {
+            this.modelContextWindows.set(modelLookupKey, contextWindowMaxTokens);
+        }
+    }
+}
+function stringifyStructuredAssistantMessage(value) {
+    if (value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+async function listOpenCodeCommandsFromSdk(client, directory) {
+    const result = await client.command.list({ directory });
+    const commandsByName = new Map(OPENCODE_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, command]));
+    if (result.error || !result.data) {
+        return Array.from(commandsByName.values());
+    }
+    for (const cmd of result.data) {
+        commandsByName.set(cmd.name, {
+            name: cmd.name,
+            description: cmd.description ?? "",
+            argumentHint: cmd.hints?.length ? cmd.hints.join(" ") : "",
+            kind: cmd.source === "skill" ? "skill" : "command",
+        });
+    }
+    return Array.from(commandsByName.values());
+}
+function readOpenCodeRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function isOpenCodeTodoWriteToolPart(part) {
+    return part.type === "tool" && part.tool.trim().toLowerCase() === "todowrite";
+}
+function readOpenCodeTodoItems(value) {
+    if (typeof value === "string") {
+        try {
+            return readOpenCodeTodoItems(JSON.parse(value));
+        }
+        catch {
+            return null;
+        }
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((entry) => {
+            const record = readOpenCodeRecord(entry);
+            if (!record) {
+                return [];
+            }
+            const content = readNonEmptyString(record.content);
+            if (!content) {
+                return [];
+            }
+            return [
+                {
+                    content,
+                    status: readNonEmptyString(record.status),
+                },
+            ];
+        });
+    }
+    const record = readOpenCodeRecord(value);
+    if (!record) {
+        return null;
+    }
+    return readOpenCodeTodoItems(record.todos);
+}
+function readOpenCodeTodoItemsFromToolPart(part) {
+    const state = readOpenCodeRecord(part.state);
+    return (readOpenCodeTodoItems(state?.input) ??
+        readOpenCodeTodoItems(state?.output) ??
+        readOpenCodeTodoItems(state?.metadata));
+}
+function mapOpenCodeTodosToTimelineItems(todos) {
+    return {
+        type: "todo",
+        items: todos.flatMap((todo) => {
+            const text = readNonEmptyString(todo.content);
+            if (!text) {
+                return [];
+            }
+            return [
+                {
+                    text,
+                    status: normalizeOpenCodeTodoStatus(todo.status),
+                    completed: todo.status === "completed",
+                },
+            ];
+        }),
+    };
+}
+function normalizeOpenCodeTodoStatus(status) {
+    if (status === "completed")
+        return "completed";
+    if (status === "in_progress" || status === "inProgress")
+        return "in_progress";
+    return "pending";
+}
+function createCompactionTimelineItem(status, trigger) {
+    return {
+        type: "compaction",
+        status,
+        ...(trigger ? { trigger } : {}),
+    };
+}
+const PERMISSION_COMMAND_KEYS = ["command", "cmd", "shellCommand"];
+const PERMISSION_CWD_KEYS = ["cwd", "directory", "path", "workdir"];
+const PERMISSION_REASON_KEYS = ["reason", "purpose", "description", "message"];
+const PERMISSION_TITLE_BY_NAME = {
+    external_directory: "Access external directory",
+    bash: "Run shell command",
+    read: "Read files",
+    read_file: "Read files",
+    write: "Write files",
+    write_file: "Write files",
+    create_file: "Write files",
+    edit: "Edit files",
+    apply_patch: "Edit files",
+    apply_diff: "Edit files",
+};
+function toHumanReadablePermissionTitle(permission) {
+    const mapped = PERMISSION_TITLE_BY_NAME[permission];
+    if (mapped) {
+        return mapped;
+    }
+    const normalized = permission
+        .split(/[\s_-]+/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+    return normalized.length > 0 ? normalized : "Permission request";
+}
+function readFirstStringFromRecord(record, keys) {
+    if (!record) {
+        return null;
+    }
+    for (const key of keys) {
+        const value = readNonEmptyString(record[key]);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function readPermissionField(metadata, keys) {
+    const direct = readFirstStringFromRecord(metadata, keys);
+    if (direct) {
+        return direct;
+    }
+    const nestedInput = readOpenCodeRecord(metadata?.input);
+    return readFirstStringFromRecord(nestedInput, keys);
+}
+function buildOpenCodePermissionInput(params) {
+    return {
+        ...(params.patterns.length > 0 ? { patterns: params.patterns } : {}),
+        ...(params.metadata ? { metadata: params.metadata } : {}),
+        ...(params.tool ? { tool: params.tool } : {}),
+        ...(params.command ? { command: params.command } : {}),
+    };
+}
+function buildOpenCodePermissionDetail(params) {
+    if (params.command) {
+        return {
+            type: "shell",
+            command: params.command,
+            ...(params.cwd ? { cwd: params.cwd } : {}),
+        };
+    }
+    return {
+        type: "unknown",
+        input: {
+            permission: params.permission,
+            ...params.input,
+        },
+        output: null,
+    };
+}
+function buildOpenCodePermissionDescription(params) {
+    const parts = [];
+    if (params.reason) {
+        parts.push(params.reason);
+    }
+    if (params.patterns.length > 0) {
+        parts.push(`Scope: ${params.patterns.join(", ")}`);
+    }
+    return parts.length > 0 ? parts.join(" - ") : undefined;
+}
+export function translateOpenCodeEvent(event, state) {
+    const events = [];
+    switch (event.type) {
+        case "session.created":
+        case "session.updated":
+            appendOpenCodeSessionCreatedOrUpdated(event, state, events);
+            break;
+        case "session.deleted":
+            appendOpenCodeSessionDeleted(event, state, events);
+            break;
+        case "message.updated":
+            appendOpenCodeMessageUpdated(event, state, events);
+            break;
+        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: mapOpenCodeTodosToTimelineItems(event.properties.todos),
+                });
+            }
+            break;
+        case "session.compacted":
+            if (event.properties.sessionID === state.sessionId) {
+                events.push({
+                    type: "timeline",
+                    provider: "opencode",
+                    item: createCompactionTimelineItem("completed"),
+                });
+            }
+            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":
+            appendOpenCodeSessionError(event, state, events);
+            break;
+        case "session.status":
+            appendOpenCodeSessionStatus(event, state, events);
+            break;
+    }
+    return events;
+}
+function resetOpenCodeTurnTrackingState(state) {
+    state.partTypes.clear();
+    state.compactionSummaryMessageIds.clear();
+    state.emittedCompactionPartIds.clear();
+    if (state.suppressAssistantMessagesUntilIdle) {
+        state.suppressAssistantMessagesUntilIdle.active = false;
+    }
+}
+function getOpenCodeSubAgentMaps(state) {
+    state.subAgentsByCallId ?? (state.subAgentsByCallId = new Map());
+    state.subAgentCallIdByChildSessionId ?? (state.subAgentCallIdByChildSessionId = new Map());
+    return {
+        byCallId: state.subAgentsByCallId,
+        callIdByChildSessionId: state.subAgentCallIdByChildSessionId,
+    };
+}
+function getOpenCodeKnownChildSessionIds(state) {
+    state.knownChildSessionIds ?? (state.knownChildSessionIds = new Set());
+    return state.knownChildSessionIds;
+}
+function getOpenCodeSubagentPresentationState(childSessionId, state) {
+    state.subagentPresentationByChildId ?? (state.subagentPresentationByChildId = new Map());
+    const existing = state.subagentPresentationByChildId.get(childSessionId);
+    if (existing) {
+        return existing;
+    }
+    const created = { facts: {} };
+    state.subagentPresentationByChildId.set(childSessionId, created);
+    return created;
+}
+function sumOpenCodeAssistantMessageTokens(tokens) {
+    if (!tokens) {
+        return 0;
+    }
+    return ((readPositiveFiniteNumber(tokens.input) ?? 0) +
+        (readPositiveFiniteNumber(tokens.output) ?? 0) +
+        (readPositiveFiniteNumber(tokens.reasoning) ?? 0) +
+        (readPositiveFiniteNumber(tokens.cache?.read) ?? 0) +
+        (readPositiveFiniteNumber(tokens.cache?.write) ?? 0));
+}
+/** Presentation facts observable on a child assistant message. Token sums only count once the
+ * message completes, so partial frames don't publish a shrinking total. */
+function readOpenCodeAssistantPresentationFacts(info) {
+    const facts = {};
+    const agentName = readNonEmptyString(info.agent);
+    if (agentName) {
+        facts.agentName = agentName;
+    }
+    const modelId = readNonEmptyString(info.modelID);
+    if (modelId) {
+        facts.modelId = modelId;
+    }
+    const variant = readNonEmptyString(info.variant);
+    if (variant) {
+        facts.variant = variant;
+    }
+    if (info.time?.completed !== undefined) {
+        const totalTokens = sumOpenCodeAssistantMessageTokens(info.tokens);
+        if (totalTokens > 0) {
+            facts.totalTokens = totalTokens;
+        }
+    }
+    return Object.keys(facts).length > 0 ? facts : null;
+}
+function isOpenCodeSessionTrackedByParent(sessionId, state) {
+    if (state.sideQuestionSessionIds?.has(sessionId) === true)
+        return false;
+    return (sessionId === state.sessionId ||
+        state.knownChildSessionIds?.has(sessionId) === true ||
+        state.subAgentCallIdByChildSessionId?.has(sessionId) === true);
+}
+function appendOpenCodeChildSessionDetected(child, state, events, status = "running") {
+    if (child.id === state.sessionId ||
+        !isOpenCodeSessionTrackedByParent(child.parentSessionId, state)) {
+        return false;
+    }
+    const knownChildSessionIds = getOpenCodeKnownChildSessionIds(state);
+    // Known limitation: detection runs once per child, so a session record that gains `agent`
+    // only in a later session.updated is not refreshed here. Assistant-frame facts recover the
+    // descriptor title and subtitle via appendChildAssistantPresentationUpsert.
+    if (knownChildSessionIds.has(child.id)) {
+        return false;
+    }
+    knownChildSessionIds.add(child.id);
+    const presentation = getOpenCodeSubagentPresentationState(child.id, state);
+    const subtitle = foldOpenCodeSubagentPresentation(presentation, {
+        ...(child.agent ? { agentName: child.agent } : {}),
+        ...(child.model?.id ? { modelId: child.model.id } : {}),
+        ...(child.model?.variant ? { variant: child.model.variant } : {}),
+    });
+    const title = claimOpenCodeSubagentFallbackTitle(presentation, child.agent);
+    // The row label contract: `description` carries the task (session title fallback), `title`
+    // carries the subagent type. Neither gets a placeholder — absent facts render as nothing.
+    events.push({
+        type: "provider_subagent",
+        provider: "opencode",
+        event: {
+            type: "upsert",
+            id: child.id,
+            parentSubagentId: child.parentSessionId === state.sessionId ? null : child.parentSessionId,
+            ...(title ? { title } : {}),
+            ...(child.title && !presentation.descriptionFromLink ? { description: child.title } : {}),
+            ...(status ? { status } : {}),
+            ...(child.directory ? { cwd: child.directory } : {}),
+            ...(subtitle ? { subtitle } : {}),
+        },
+    });
+    return true;
+}
+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,
+    };
+    maps.byCallId.set(callId, created);
+    return created;
+}
+function linkOpenCodeSubAgentChildSession(activity, childSessionId, state, events) {
+    activity.childSessionId = childSessionId;
+    const maps = getOpenCodeSubAgentMaps(state);
+    maps.callIdByChildSessionId.set(childSessionId, activity.toolCall.callId);
+    appendOpenCodeSubAgentLinkPresentation(activity, childSessionId, state, events);
+}
+/**
+ * When a child session ties to a parent `task` tool call, publish the task's identity onto the
+ * descriptor: `description` (task input), `title` (subagent type), `toolCallId`. Presentation
+ * only — no `status`, so it can never revert a finished child.
+ */
+function appendOpenCodeSubAgentLinkPresentation(activity, childSessionId, state, events) {
+    const detail = activity.toolCall.detail;
+    if (detail.type !== "sub_agent") {
+        return;
+    }
+    const presentation = getOpenCodeSubagentPresentationState(childSessionId, state);
+    if (presentation.linkedToolCallId === activity.toolCall.callId) {
+        return;
+    }
+    presentation.linkedToolCallId = activity.toolCall.callId;
+    const subAgentType = readNonEmptyString(detail.subAgentType);
+    const description = readNonEmptyString(detail.description);
+    if (subAgentType) {
+        presentation.titleFromLink = true;
+        presentation.titleEmitted = true;
+    }
+    if (description) {
+        presentation.descriptionFromLink = true;
+    }
+    const subtitle = foldOpenCodeSubagentPresentation(presentation, subAgentType ? { agentName: subAgentType } : {});
+    events.push({
+        type: "provider_subagent",
+        provider: "opencode",
+        event: {
+            type: "upsert",
+            id: childSessionId,
+            toolCallId: activity.toolCall.callId,
+            ...(subAgentType ? { title: subAgentType } : {}),
+            ...(description ? { description } : {}),
+            ...(subtitle ? { subtitle } : {}),
+        },
+    });
+}
+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 } : {}),
+        },
+    };
+}
+function registerOpenCodeSubAgentToolCall(item, state, events) {
+    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, events);
+    }
+    return buildOpenCodeSubAgentTimelineItem(activity);
+}
+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 appendOpenCodeToolCallTimelineItem(item, state, events) {
+    const timelineItem = registerOpenCodeSubAgentToolCall(item, state, events);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: timelineItem,
+    });
+}
+function appendOpenCodeSubAgentChildSessionLinked(childSessionId, state, events) {
+    const activity = findOnlyOpenCodeSubAgentWaitingForChild(state);
+    if (!activity) {
+        return;
+    }
+    linkOpenCodeSubAgentChildSession(activity, childSessionId, state, events);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: buildOpenCodeSubAgentTimelineItem(activity),
+    });
+}
+function appendOpenCodeSessionCreatedOrUpdated(event, state, events) {
+    const info = readOpenCodeRecord(event.properties.info);
+    if (event.properties.info.id === state.sessionId) {
+        const sessionCost = readPositiveFiniteNumber(info?.cost);
+        if (sessionCost !== undefined) {
+            state.sessionTotalCostUsd = maxFiniteNumber(state.sessionTotalCostUsd, sessionCost);
+            state.accumulatedUsage.totalCostUsd = state.sessionTotalCostUsd;
+        }
+        events.push({
+            type: "thread_started",
+            sessionId: state.sessionId,
+            provider: "opencode",
+        });
+        return;
+    }
+    if (state.sideQuestionSessionIds?.has(event.properties.info.id) === true) {
+        return;
+    }
+    const parentSessionId = readNonEmptyString(info?.parentID) ?? readNonEmptyString(info?.parentId);
+    if (parentSessionId) {
+        const child = readOpenCodeChildSessionInfo({
+            ...info,
+            id: event.properties.info.id,
+            parentID: parentSessionId,
+        });
+        if (child) {
+            appendOpenCodeChildSessionDetected(child, state, events);
+        }
+    }
+    if (parentSessionId === state.sessionId) {
+        appendOpenCodeSubAgentChildSessionLinked(event.properties.info.id, state, events);
+    }
+}
+function appendOpenCodeSessionDeleted(event, state, events) {
+    const sessionId = event.properties.sessionID;
+    if (!isOpenCodeSessionTrackedByParent(sessionId, state)) {
+        return;
+    }
+    state.knownChildSessionIds?.delete(sessionId);
+    state.subAgentCallIdByChildSessionId?.delete(sessionId);
+    state.subagentPresentationByChildId?.delete(sessionId);
+    events.push({
+        type: "provider_subagent",
+        provider: "opencode",
+        event: { type: "remove", id: sessionId },
+    });
+}
+function appendOpenCodeMessageUpdated(event, state, events) {
+    const info = event.properties.info;
+    if (info.sessionID !== state.sessionId) {
+        return;
+    }
+    state.messageRoles.set(info.id, info.role);
+    if (matchesHydratedFingerprint(state.hydratedMessageFingerprints, info.id, info)) {
+        return;
+    }
+    if (info.role === "user") {
+        appendOpenCodeUserMessageUpdated(info, state, events);
+        return;
+    }
+    if (info.role !== "assistant") {
+        return;
+    }
+    if (state.suppressAssistantMessagesUntilIdle?.active) {
+        state.compactionSummaryMessageIds.add(info.id);
+        return;
+    }
+    if (isOpenCodeCompactionSummaryMessage(info)) {
+        state.compactionSummaryMessageIds.add(info.id);
+        return;
+    }
+    const modelLookupKey = resolveOpenCodeModelLookupKeyFromAssistantMessage(info);
+    if (modelLookupKey) {
+        const contextWindowMaxTokens = state.modelContextWindowsByModelKey?.get(modelLookupKey);
+        if (contextWindowMaxTokens !== undefined) {
+            state.onAssistantModelContextWindowResolved?.(contextWindowMaxTokens);
+        }
+    }
+    if (state.emittedStructuredMessageIds.has(info.id) || info.time?.completed === undefined) {
+        return;
+    }
+    const text = stringifyStructuredAssistantMessage(info.structured);
+    if (!text) {
+        return;
+    }
+    state.emittedStructuredMessageIds.add(info.id);
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: { type: "assistant_message", text, messageId: info.id },
+    });
+}
+function appendOpenCodeUserMessageUpdated(info, state, events) {
+    const pendingSteerIndex = state.pendingSteerSubmissions?.findIndex((submission) => submission.providerMessageId === info.id);
+    const pendingSteer = pendingSteerIndex !== undefined && pendingSteerIndex >= 0
+        ? state.pendingSteerSubmissions?.splice(pendingSteerIndex, 1)[0]
+        : undefined;
+    const text = pendingSteer?.text ?? state.pendingUserMessageText;
+    if (!text || text.trim().length === 0 || state.emittedUserMessageIds?.has(info.id)) {
+        return;
+    }
+    state.emittedUserMessageIds?.add(info.id);
+    const clientMessageId = pendingSteer?.clientMessageId ?? state.pendingClientMessageId;
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: {
+            type: "user_message",
+            text,
+            messageId: info.id,
+            ...(clientMessageId ? { clientMessageId } : {}),
+        },
+    });
+}
+function appendOpenCodeMessagePartUpdated(event, state, events) {
+    const part = event.properties.part;
+    if (part.type === "tool" && isOpenCodeTodoWriteToolPart(part)) {
+        return;
+    }
+    if (part.sessionID !== state.sessionId) {
+        return;
+    }
+    if (matchesHydratedFingerprint(state.hydratedPartFingerprints, part.id, part)) {
+        return;
+    }
+    const messageRole = state.messageRoles.get(part.messageID);
+    state.partTypes.set(part.id, part.type);
+    if (state.compactionSummaryMessageIds.has(part.messageID)) {
+        return;
+    }
+    if (shouldSuppressOpenCodeAssistantPart(part, messageRole, state)) {
+        state.compactionSummaryMessageIds.add(part.messageID);
+        return;
+    }
+    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") {
+        if (state.emittedCompactionPartIds.has(part.id)) {
+            return;
+        }
+        state.emittedCompactionPartIds.add(part.id);
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: createCompactionTimelineItem("loading", part.auto ? "auto" : "manual"),
+        });
+        return;
+    }
+    if (part.type === "step-finish") {
+        const stepCost = readPositiveFiniteNumber(part.cost);
+        if (stepCost !== undefined) {
+            state.sessionTotalCostUsd = (state.sessionTotalCostUsd ?? 0) + stepCost;
+        }
+        mergeOpenCodeStepFinishUsage(state.accumulatedUsage, part, {
+            totalCostUsd: state.sessionTotalCostUsd,
+        });
+        if (hasNormalizedOpenCodeUsage(state.accumulatedUsage)) {
+            events.push({
+                type: "usage_updated",
+                provider: "opencode",
+                usage: { ...state.accumulatedUsage },
+            });
+        }
+    }
+}
+function shouldSuppressOpenCodeAssistantPart(part, messageRole, state) {
+    return (state.suppressAssistantMessagesUntilIdle?.active === true &&
+        part.type === "text" &&
+        messageRole !== "user");
+}
+function appendOpenCodeTextPart(part, messageRole, state, events) {
+    if (messageRole === "user") {
+        if (!part.text || state.emittedUserMessageIds?.has(part.messageID)) {
+            return;
+        }
+        state.emittedUserMessageIds?.add(part.messageID);
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "user_message", text: part.text, messageId: part.messageID },
+        });
+        return;
+    }
+    if (!part.time?.end) {
+        return;
+    }
+    const materialized = state.materializedParts.get(part.id);
+    if (materialized?.closed)
+        return;
+    const emittedText = materialized?.messageId === part.messageID ? materialized.emittedText : "";
+    if (!part.text.startsWith(emittedText)) {
+        state.onMaterializationMismatch?.({
+            partId: part.id,
+            messageId: part.messageID,
+            kind: "text",
+        });
+        return;
+    }
+    const suffix = part.text.slice(emittedText.length);
+    state.materializedParts.set(part.id, {
+        messageId: part.messageID,
+        emittedText: part.text,
+        closed: true,
+    });
+    if (suffix) {
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "assistant_message", text: suffix, messageId: part.messageID },
+        });
+    }
+}
+function appendOpenCodeReasoningPart(part, state, events) {
+    if (!part.time.end) {
+        return;
+    }
+    const materialized = state.materializedParts.get(part.id);
+    if (materialized?.closed)
+        return;
+    const emittedText = materialized?.messageId === part.messageID ? materialized.emittedText : "";
+    if (!part.text.startsWith(emittedText)) {
+        state.onMaterializationMismatch?.({
+            partId: part.id,
+            messageId: part.messageID,
+            kind: "reasoning",
+        });
+        return;
+    }
+    const suffix = part.text.slice(emittedText.length);
+    state.materializedParts.set(part.id, {
+        messageId: part.messageID,
+        emittedText: part.text,
+        closed: true,
+    });
+    if (suffix) {
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "reasoning", text: suffix },
+        });
+    }
+}
+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 (messageID && state.compactionSummaryMessageIds.has(messageID)) {
+        return;
+    }
+    if (isReasoning) {
+        if (!appendOpenCodeMaterializedDelta(state, partID, messageID, delta))
+            return;
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "reasoning", text: delta },
+        });
+        return;
+    }
+    if (field !== "text") {
+        return;
+    }
+    if (messageRole === "user") {
+        return;
+    }
+    const assistantMessageId = messageID || partID;
+    if (!assistantMessageId) {
+        return;
+    }
+    if (state.suppressAssistantMessagesUntilIdle?.active === true) {
+        state.compactionSummaryMessageIds.add(assistantMessageId);
+        return;
+    }
+    if (!appendOpenCodeMaterializedDelta(state, partID, assistantMessageId, delta))
+        return;
+    events.push({
+        type: "timeline",
+        provider: "opencode",
+        item: {
+            type: "assistant_message",
+            text: delta,
+            messageId: assistantMessageId,
+        },
+    });
+}
+function appendOpenCodeMaterializedDelta(state, partId, messageId, delta) {
+    if (!partId)
+        return true;
+    const previous = state.materializedParts.get(partId);
+    if (previous?.closed)
+        return false;
+    state.materializedParts.set(partId, {
+        messageId,
+        emittedText: `${previous?.emittedText ?? ""}${delta}`,
+        closed: false,
+    });
+    return true;
+}
+function appendOpenCodePermissionAsked(event, state, events) {
+    if (!isOpenCodeSessionTrackedByParent(event.properties.sessionID, state)) {
+        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,
+            actions: buildOpenCodePermissionActions(),
+        },
+    });
+}
+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 } : {}),
+                allowOther: true,
+            },
+        ];
+    });
+    if (questions.length === 0) {
+        return;
+    }
+    events.push({
+        type: "permission_requested",
+        provider: "opencode",
+        request: {
+            id: event.properties.id,
+            provider: "opencode",
+            name: "question",
+            kind: "question",
+            title: "Question",
+            input: { questions },
+            metadata: {
+                source: "opencode_question",
+                ...event.properties.tool,
+            },
+        },
+    });
+}
+function appendOpenCodeSessionError(event, state, events) {
+    if (event.properties.sessionID !== state.sessionId) {
+        return;
+    }
+    resetOpenCodeTurnTrackingState(state);
+    const error = event.properties.error;
+    if (typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "MessageAbortedError") {
+        events.push({
+            type: "turn_canceled",
+            provider: "opencode",
+            reason: "interrupted",
+        });
+    }
+    else {
+        events.push({
+            type: "turn_failed",
+            provider: "opencode",
+            error: toDiagnosticErrorMessage(error),
+        });
+    }
+}
+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") {
+        // Mirror what opencode's TUI shows: retry attempts are visible activity, not
+        // terminal. opencode itself never gives up — it backs off and tries again
+        // forever. If we silently swallow these the user sees a spinner with no
+        // explanation. Forwarding as a timeline error item is a no-op for old
+        // clients (the schema already supports it).
+        const message = typeof status.message === "string" ? status.message.trim() : "";
+        const text = message
+            ? `Provider retry (attempt ${status.attempt}): ${message}`
+            : `Provider retry (attempt ${status.attempt})`;
+        events.push({
+            type: "timeline",
+            provider: "opencode",
+            item: { type: "error", message: text },
+        });
+        return;
+    }
+}
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+function unwrapOpenCodeGlobalEvent(event) {
+    const record = readOpenCodeRecord(event);
+    if (!record) {
+        return null;
+    }
+    const payload = readOpenCodeRecord(record.payload);
+    if (typeof payload?.type === "string") {
+        return payload;
+    }
+    if (typeof record.type === "string") {
+        return record;
+    }
+    return null;
+}
+function getOpenCodeEventSessionId(event) {
+    const properties = readOpenCodeRecord(event.properties);
+    const info = readOpenCodeRecord(properties?.info);
+    const part = readOpenCodeRecord(properties?.part);
+    return (readNonEmptyString(properties?.sessionID) ??
+        readNonEmptyString(properties?.sessionId) ??
+        readNonEmptyString(info?.sessionID) ??
+        readNonEmptyString(info?.sessionId) ??
+        readNonEmptyString(part?.sessionID) ??
+        readNonEmptyString(part?.sessionId) ??
+        (event.type === "session.created" || event.type === "session.updated"
+            ? readNonEmptyString(info?.id)
+            : null));
+}
+function getOpenCodeRunnerStatusFromEvent(event, sessionId) {
+    if (getOpenCodeEventSessionId(event) !== sessionId) {
+        return null;
+    }
+    if (event.type === "session.status") {
+        return event.properties.status.type;
+    }
+    if (event.type === "session.idle" || event.type === "session.error") {
+        return "idle";
+    }
+    return null;
+}
+function isOpenCodeRunnerActive(status) {
+    return status === "busy" || status === "retry";
+}
+function isOpenCodeTerminalEvent(event, sessionId) {
+    return getOpenCodeRunnerStatusFromEvent(event, sessionId) === "idle";
+}
+function isOpenCodeProviderInternalEvent(event) {
+    return event.type === "provider_subagent";
+}
+function readOpenCodeChildSessionInfo(value) {
+    const record = readOpenCodeRecord(value);
+    if (!record) {
+        return null;
+    }
+    const id = readNonEmptyString(record.id);
+    const parentSessionId = readNonEmptyString(record.parentID) ?? readNonEmptyString(record.parentId);
+    if (!id || !parentSessionId) {
+        return null;
+    }
+    const title = readNonEmptyString(record.title);
+    const directory = readNonEmptyString(record.directory);
+    const revert = readOpenCodeRecord(record.revert);
+    const agent = readNonEmptyString(record.agent);
+    const model = readOpenCodeChildSessionModel(record.model);
+    return {
+        id,
+        parentSessionId,
+        ...(title ? { title } : {}),
+        ...(directory ? { directory } : {}),
+        ...(revert ? { revert } : {}),
+        ...(agent ? { agent } : {}),
+        ...(model ? { model } : {}),
+    };
+}
+function readOpenCodeChildSessionModel(value) {
+    const record = readOpenCodeRecord(value);
+    const id = readNonEmptyString(record?.id);
+    if (!record || !id) {
+        return null;
+    }
+    const variant = readNonEmptyString(record.variant);
+    return {
+        id,
+        ...(variant ? { variant } : {}),
+    };
+}
+function readOpenCodeChildSessionInfosFromResponse(response) {
+    const record = readOpenCodeRecord(response);
+    if (!record || record.error) {
+        return null;
+    }
+    const data = record.data;
+    if (!Array.isArray(data)) {
+        return null;
+    }
+    return data.flatMap((item) => {
+        const child = readOpenCodeChildSessionInfo(item);
+        return child ? [child] : [];
+    });
+}
+async function listOpenCodeChildSessions(client, sessionId, directory, signal) {
+    const sessionIdResponse = await client.session.children({ sessionID: sessionId, directory }, { signal });
+    return readOpenCodeChildSessionInfosFromResponse(sessionIdResponse) ?? [];
+}
+class OpenCodeAgentSession {
+    constructor(config, client, sessionId, logger, modelContextWindowsByModelKey = new Map(), events = EMPTY_OPENCODE_EVENT_SOURCE, releaseServer, persistSession = true, agentId, serverUrl, externallyDriven = false, releaseBridge) {
+        this.events = events;
+        this.agentId = agentId;
+        this.serverUrl = serverUrl;
+        this.externallyDriven = externallyDriven;
+        this.provider = "opencode";
+        this.capabilities = OPENCODE_CAPABILITIES;
+        this.currentMode = null;
+        this.autoAcceptEnabled = false;
+        this.pendingPermissions = new Map();
+        this.abortController = null;
+        this.accumulatedUsage = {};
+        this.mcpConfigured = false;
+        this.mcpSetupPromise = null;
+        this.messageRoles = new Map();
+        this.pendingUserMessageText = null;
+        this.pendingClientMessageId = null;
+        this.pendingSteerSubmissions = [];
+        this.emittedUserMessageIds = new Set();
+        this.materializedParts = new Map();
+        this.activeDispatchMessageId = null;
+        this.emittedStructuredMessageIds = new Set();
+        this.compactionSummaryMessageIds = new Set();
+        this.emittedCompactionPartIds = new Set();
+        this.suppressAssistantMessagesUntilIdle = { active: false };
+        this.partTypes = new Map();
+        this.availableModesCache = null;
+        this.subscribers = new Set();
+        this.nextTurnOrdinal = 0;
+        this.turnState = { status: "idle" };
+        /**
+         * Settlement of every session-scoped abort issued so far. It outlives the stop
+         * that issued it because a request still in flight can cancel a replacement
+         * run, and a rejection means we never proved the runner stopped.
+         */
+        this.abortSettlement = Promise.resolve();
+        this.externalStatusReconciliationStarted = false;
+        this.runnerStatusRevision = 0;
+        this.runningToolCalls = new Map();
+        this.subAgentsByCallId = new Map();
+        this.subAgentCallIdByChildSessionId = new Map();
+        this.knownChildSessionIds = new Set();
+        this.sideQuestionSessionIds = new Set();
+        this.subagentPresentationByChildId = new Map();
+        this.childTranslationStates = new Map();
+        this.childSessionCwds = new Map();
+        this.childStatuses = new Map();
+        this.pendingPermissionDirectories = new Map();
+        this.childHydrationPromise = null;
+        this.childHydrationCompleted = false;
+        this.unrelatedSessionIds = new Set();
+        this.ingress = Promise.resolve();
+        this.gapRepairRevision = 0;
+        this.recoveryAbortController = new AbortController();
+        this.unsubscribeEvents = null;
+        this.closed = false;
+        this.deletedFromProvider = false;
+        this.config = config;
+        this.client = client;
+        this.sessionId = sessionId;
+        this.logger = logger.child({ agentId: this.agentId });
+        this.modelContextWindowsByModelKey = modelContextWindowsByModelKey;
+        this.currentMode = normalizeOpenCodeModeId(config.modeId);
+        this.autoAcceptEnabled = !config.toolPolicy && isOpenCodeAutoAcceptEnabled(config);
+        this.releaseServer = releaseServer ?? null;
+        this.releaseBridge = releaseBridge ?? null;
+        this.persistSession = persistSession;
+        this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(config.model);
+        this.unsubscribeEvents = this.events.subscribe((input) => {
+            if ("type" in input && input.type === "server-exited")
+                this.recoveryAbortController.abort(input.error);
+            this.ingress = this.ingress
+                .then(() => this.consumeEventSourceInput(input))
+                .catch((error) => {
+                this.logger.warn({ err: error, sessionId: this.sessionId }, "OpenCode event ingress failed");
+            });
+        });
+    }
+    get id() {
+        return this.sessionId;
+    }
+    get activeForegroundTurnId() {
+        return this.turnState.status === "running" ? this.turnState.turnId : null;
+    }
+    get features() {
+        return [buildOpenCodeAutoAcceptFeature(this.config)];
+    }
+    async getRuntimeInfo() {
+        return {
+            provider: "opencode",
+            sessionId: this.sessionId,
+            model: this.config.model ?? null,
+            modeId: this.currentMode,
+        };
+    }
+    async setModel(modelId) {
+        const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
+        this.config.model = normalizedModelId ?? undefined;
+        this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(this.config.model);
+    }
+    async setThinkingOption(thinkingOptionId) {
+        const normalizedThinkingOptionId = normalizeOpenCodeVariantId(thinkingOptionId);
+        this.config.thinkingOptionId = normalizedThinkingOptionId ?? undefined;
+    }
+    async run(prompt, options) {
+        return runProviderTurn({
+            prompt,
+            runOptions: options,
+            startTurn: (p, o) => this.startTurn(p, o),
+            subscribe: (callback) => this.subscribe(callback),
+            getSessionId: () => this.sessionId,
+        });
+    }
+    async interrupt() {
+        const turnId = this.activeForegroundTurnId;
+        this.abortController?.abort();
+        const abort = this.issueStop(turnId);
+        // COMPAT(opencodeSlowAbort): OpenCode 1.14.42+ blocks session.abort until
+        // the running tool actually stops, which can be tens of seconds for
+        // long-running tools. Cap the wait so the user-visible cancel lands
+        // quickly while still giving OpenCode a chance to confirm the abort
+        // cleanly. Drop the timeout once upstream returns abort acknowledgement
+        // before tool teardown.
+        const settledAbort = abort.then(() => undefined, (error) => error);
+        // Only the cap is tolerated. A settled failure means the runner may still be
+        // going, and the caller must hear about it.
+        const abortFailure = await withTimeout(settledAbort, 2000, "OpenCode session.abort").catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId, turnId }, "OpenCode session.abort did not settle within the cancel cap");
+            return undefined;
+        });
+        if (abortFailure !== undefined) {
+            throw abortFailure;
+        }
+    }
+    async steerActiveTurn(prompt, options) {
+        if (this.closed || this.activeForegroundTurnId !== options.expectedTurnId) {
+            return { status: "unavailable" };
+        }
+        if (await this.resolveSlashCommandInvocation(prompt)) {
+            return { status: "unavailable" };
+        }
+        if (this.activeForegroundTurnId !== options.expectedTurnId) {
+            return { status: "unavailable" };
+        }
+        const promptId = createOpenCodeMessageId();
+        const pending = {
+            providerMessageId: promptId,
+            text: buildOpenCodeUserTimelineText(prompt),
+            clientMessageId: options.clientMessageId ?? null,
+        };
+        this.pendingSteerSubmissions.push(pending);
+        const parts = buildOpenCodePromptParts(prompt);
+        const systemPrompt = composeSystemPromptParts(this.config.systemPrompt, this.config.daemonAppendSystemPrompt);
+        const permission = buildOpenCodePermissionRules(this.config.providerOptions, this.config.toolPolicy);
+        const model = this.parseModel(this.config.model);
+        const effectiveMode = resolveOpenCodeRuntimeAgentId(this.currentMode);
+        const effectiveVariant = this.config.thinkingOptionId ?? undefined;
+        try {
+            const response = await this.client.session.promptAsync({
+                sessionID: this.sessionId,
+                directory: this.config.cwd,
+                messageID: promptId,
+                parts,
+                ...(systemPrompt ? { system: systemPrompt } : {}),
+                ...(permission ? { permission } : {}),
+                ...(model ? { model } : {}),
+                ...(effectiveMode ? { agent: effectiveMode } : {}),
+                ...(effectiveVariant ? { variant: effectiveVariant } : {}),
+            });
+            if (response.error) {
+                if (isOpenCodeDefinitiveSteerRejection(response.error, response.response?.status)) {
+                    this.removePendingSteerSubmission(promptId);
+                    return { status: "unavailable" };
+                }
+                throw new Error(`OpenCode steer request failed: ${toDiagnosticErrorMessage(response.error)}`);
+            }
+            if (options.clearPendingPermissions) {
+                await this.clearPendingPermissionsForSteer();
+            }
+            return { status: "accepted" };
+        }
+        catch (error) {
+            if (isOpenCodeDefinitiveSteerRejection(error)) {
+                this.removePendingSteerSubmission(promptId);
+                return { status: "unavailable" };
+            }
+            throw error;
+        }
+    }
+    async askSideQuestion(question, history, options) {
+        if (this.closed)
+            return { status: "unavailable", reason: "session_closed" };
+        try {
+            return await askOpenCodeSideQuestion({
+                client: this.client,
+                parentSessionId: this.sessionId,
+                cwd: this.config.cwd,
+                question,
+                history,
+                messageId: createOpenCodeMessageId(),
+                logger: this.logger,
+                signal: options?.signal,
+                onForkCreated: (forkSessionId) => this.registerSideQuestionFork(forkSessionId),
+                onForkReleased: (forkSessionId) => this.sideQuestionSessionIds.delete(forkSessionId),
+                model: this.parseModel(this.config.model),
+                agent: resolveOpenCodeRuntimeAgentId(this.currentMode) ?? undefined,
+                variant: this.config.thinkingOptionId,
+            });
+        }
+        catch (error) {
+            return {
+                status: "failed",
+                error: toDiagnosticErrorMessage(error),
+                threading: "threaded",
+            };
+        }
+    }
+    removePendingSteerSubmission(providerMessageId) {
+        const index = this.pendingSteerSubmissions.findIndex((submission) => submission.providerMessageId === providerMessageId);
+        if (index >= 0) {
+            this.pendingSteerSubmissions.splice(index, 1);
+        }
+    }
+    async clearPendingPermissionsForSteer() {
+        const requestIds = Array.from(this.pendingPermissions.keys());
+        for (const requestId of requestIds) {
+            if (!this.pendingPermissions.has(requestId))
+                continue;
+            await this.respondToPermission(requestId, {
+                behavior: "deny",
+                message: "The user answered with a message instead of approving. Their message follows.",
+            });
+        }
+    }
+    async revertBoth(input) {
+        await revertOpenCodeConversationAndFiles({
+            client: this.client,
+            sessionId: this.sessionId,
+            cwd: this.config.cwd,
+            messageId: input.messageId,
+        });
+    }
+    abortSession(turnId, reason) {
+        return this.client.session
+            .abort({
+            sessionID: this.sessionId,
+            directory: this.config.cwd,
+        })
+            .then((response) => {
+            if (response.error) {
+                throw new Error(toDiagnosticErrorMessage(response.error));
+            }
+            return undefined;
+        })
+            .catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId, turnId, reason }, "OpenCode session.abort rejected");
+            throw error;
+        });
+    }
+    /**
+     * Gate every runner-affecting operation on the previous stop. OpenCode runs one
+     * runner per session and aborts it session-wide, so a replacement may start
+     * only once the canceled run published its terminal and our own abort settled.
+     * A failed abort never proved the runner stopped, so it fails closed until the
+     * next Stop issues a fresh one.
+     */
+    async awaitRunnerQuiescence() {
+        const providerIdle = this.waitUntilProviderIdle();
+        // A failed abort is decisive on its own, so let it reject this wait without
+        // leaving the still-running observation unhandled.
+        void providerIdle.catch(() => undefined);
+        let observed = this.abortSettlement;
+        await Promise.all([observed, providerIdle]);
+        // Stop can issue a further abort while we waited, and the settlement is
+        // replaced rather than mutated, so drain until what we observed is current.
+        while (this.abortSettlement !== observed) {
+            observed = this.abortSettlement;
+            await observed;
+        }
+    }
+    async waitUntilProviderIdle() {
+        if (this.turnState.status !== "stopping")
+            return;
+        await withTimeout(this.observeProviderStopBoundary(this.turnState.stop), OPENCODE_PENDING_ABORT_START_TIMEOUT_MS, "OpenCode previous turn to stop");
+    }
+    async observeProviderStopBoundary(stop) {
+        let delayMs = 100;
+        while (this.isStopping(stop)) {
+            const boundary = await Promise.race([
+                stop.terminal.promise.then(() => "terminal"),
+                waitForOpenCodeStopProbe(delayMs, this.recoveryAbortController.signal).then(() => "probe"),
+            ]);
+            if (boundary === "terminal")
+                return;
+            await this.reconcileStopWithProviderStatus(stop);
+            delayMs = Math.min(delayMs * 2, OPENCODE_STOP_STATUS_MAX_DELAY_MS);
+        }
+    }
+    async reconcileStopWithProviderStatus(stop) {
+        try {
+            if ((await this.readProviderRunnerStatus()) === "idle") {
+                this.finishStoppingTurn(stop);
+            }
+        }
+        catch (error) {
+            this.logger.warn({ err: error, sessionId: this.sessionId, turnId: stop.pendingCancellationTurnId }, "Failed to reconcile the OpenCode stop with provider session status");
+        }
+    }
+    async readProviderRunnerStatus() {
+        const response = await this.client.session.status({ directory: this.config.cwd }, { signal: this.recoveryAbortController.signal });
+        if (response.error) {
+            throw new Error(`Failed to confirm OpenCode session status: ${toDiagnosticErrorMessage(response.error)}`);
+        }
+        const statuses = readOpenCodeRecord(response.data);
+        if (!statuses) {
+            throw new Error("OpenCode returned an invalid session status response");
+        }
+        const status = readOpenCodeRecord(statuses[this.sessionId]);
+        // OpenCode drops idle sessions from the status map entirely.
+        if (!status) {
+            return "idle";
+        }
+        const statusType = readNonEmptyString(status.type);
+        if (statusType !== "idle" && statusType !== "busy" && statusType !== "retry") {
+            throw new Error(`OpenCode returned an unknown session status '${statusType ?? "missing"}'`);
+        }
+        return statusType;
+    }
+    async startTurn(prompt, options) {
+        if (this.closed) {
+            throw new Error("OpenCode session is closed");
+        }
+        if (this.turnState.status === "running") {
+            throw new Error("A foreground turn is already active");
+        }
+        try {
+            await this.awaitRunnerQuiescence();
+        }
+        catch (error) {
+            this.rethrowRunnerWaitError(error);
+        }
+        if (this.closed) {
+            throw new Error("OpenCode session is closed");
+        }
+        if (this.turnState.status !== "idle") {
+            throw new Error("OpenCode is still stopping the previous turn");
+        }
+        this.runningToolCalls.clear();
+        this.subAgentsByCallId.clear();
+        this.subAgentCallIdByChildSessionId.clear();
+        const turnAbortController = new AbortController();
+        this.abortController = turnAbortController;
+        await this.ensureMcpServersConfigured();
+        const contextWindowMaxTokens = this.resolveSelectedModelContextWindowMaxTokens();
+        this.accumulatedUsage = contextWindowMaxTokens !== undefined ? { contextWindowMaxTokens } : {};
+        const parts = buildOpenCodePromptParts(prompt);
+        this.pendingUserMessageText = buildOpenCodeUserTimelineText(prompt);
+        this.pendingClientMessageId = options?.clientMessageId ?? null;
+        this.suppressAssistantMessagesUntilIdle.active = false;
+        const model = this.parseModel(this.config.model);
+        const thinkingOptionId = this.config.thinkingOptionId;
+        const effectiveVariant = thinkingOptionId ?? undefined;
+        const effectiveMode = resolveOpenCodeRuntimeAgentId(this.currentMode);
+        await this.awaitEventStreamReady(turnAbortController);
+        const turnId = this.createTurnId();
+        this.materializedParts.clear();
+        this.turnState = { status: "running", turnId };
+        this.notifySubscribers({ type: "turn_started", provider: "opencode" }, turnId);
+        const slashCommand = await this.resolveSlashCommandInvocation(prompt);
+        if (slashCommand) {
+            if (slashCommand.commandName === "compact" || slashCommand.commandName === "summarize") {
+                this.activeDispatchMessageId = null;
+                this.suppressAssistantMessagesUntilIdle.active = true;
+                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.suppressAssistantMessagesUntilIdle.active = false;
+                        this.finishForegroundTurn({
+                            type: "turn_failed",
+                            provider: "opencode",
+                            error: toDiagnosticErrorMessage(response.error),
+                        }, turnId);
+                    }
+                    return;
+                })
+                    .catch((error) => {
+                    this.suppressAssistantMessagesUntilIdle.active = false;
+                    this.finishForegroundTurn({
+                        type: "turn_failed",
+                        provider: "opencode",
+                        error: toDiagnosticErrorMessage(error),
+                    }, turnId);
+                });
+                return { turnId };
+            }
+            // command() is only dispatch acknowledgement. OpenCode session events are
+            // the source of truth for when the command turn becomes idle or fails.
+            this.activeDispatchMessageId = createOpenCodeMessageId();
+            void this.client.session
+                .command({
+                sessionID: this.sessionId,
+                directory: this.config.cwd,
+                command: slashCommand.commandName,
+                arguments: slashCommand.args ?? "",
+                messageID: this.activeDispatchMessageId,
+                ...(this.config.model ? { model: this.config.model } : {}),
+                ...(effectiveMode ? { agent: effectiveMode } : {}),
+                ...(effectiveVariant ? { variant: effectiveVariant } : {}),
+            })
+                .then((response) => {
+                if (response.error) {
+                    if (isOpenCodeHeadersTimeoutFailure(response.error)) {
+                        this.logger.warn({
+                            err: response.error,
+                            commandName: slashCommand.commandName,
+                            turnId,
+                        }, "OpenCode slash command hit a header timeout; waiting for SSE terminal event");
+                        return;
+                    }
+                    const errorMsg = toDiagnosticErrorMessage(response.error);
+                    this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: errorMsg }, turnId);
+                }
+                return;
+            })
+                .catch((err) => {
+                if (isOpenCodeHeadersTimeoutFailure(err)) {
+                    this.logger.warn({
+                        err,
+                        commandName: slashCommand.commandName,
+                        turnId,
+                    }, "OpenCode slash command hit a header timeout; waiting for SSE terminal event");
+                    return;
+                }
+                this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: toDiagnosticErrorMessage(err) }, turnId);
+            });
+        }
+        else {
+            const dispatchMessageId = createOpenCodeMessageId();
+            this.activeDispatchMessageId = dispatchMessageId;
+            // 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 () => {
+                this.traceOpenCode("provider.opencode.prompt_async.start", {
+                    turnId,
+                    sessionId: this.sessionId,
+                    model,
+                    effectiveMode,
+                    effectiveVariant,
+                    partTypes: parts.map((p) => p.type),
+                });
+                try {
+                    const systemPrompt = composeSystemPromptParts(this.config.systemPrompt, this.config.daemonAppendSystemPrompt);
+                    const permission = buildOpenCodePermissionRules(this.config.providerOptions, this.config.toolPolicy);
+                    const promptResponse = await this.client.session.promptAsync({
+                        sessionID: this.sessionId,
+                        directory: this.config.cwd,
+                        messageID: dispatchMessageId,
+                        parts,
+                        ...(options?.outputSchema
+                            ? {
+                                format: {
+                                    type: "json_schema",
+                                    schema: options.outputSchema,
+                                },
+                            }
+                            : {}),
+                        ...(systemPrompt ? { system: systemPrompt } : {}),
+                        ...(permission ? { permission } : {}),
+                        ...(model ? { model } : {}),
+                        ...(effectiveMode ? { agent: effectiveMode } : {}),
+                        ...(effectiveVariant ? { variant: effectiveVariant } : {}),
+                    });
+                    this.traceOpenCode("provider.opencode.prompt_async.response", {
+                        turnId,
+                        hasError: promptResponse.error !== undefined,
+                        error: promptResponse.error,
+                        data: promptResponse.data,
+                    });
+                    if (promptResponse.error) {
+                        this.finishForegroundTurn({
+                            type: "turn_failed",
+                            provider: "opencode",
+                            error: toDiagnosticErrorMessage(promptResponse.error),
+                        }, turnId);
+                    }
+                }
+                catch (error) {
+                    this.traceOpenCode("provider.opencode.prompt_async.throw", {
+                        turnId,
+                        error: error instanceof Error
+                            ? { name: error.name, message: error.message, stack: error.stack }
+                            : String(error),
+                    });
+                    this.finishForegroundTurn({
+                        type: "turn_failed",
+                        provider: "opencode",
+                        error: toDiagnosticErrorMessage(error),
+                    }, turnId);
+                }
+            })();
+        }
+        return { turnId };
+    }
+    async awaitEventStreamReady(turnAbortController) {
+        try {
+            await withTimeout(this.events.ready(), OPENCODE_EVENT_STREAM_READY_TIMEOUT_MS, "OpenCode server.connected event");
+        }
+        catch (error) {
+            if (this.abortController === turnAbortController)
+                this.abortController = null;
+            if (!(error instanceof Error) || error.message !== "OpenCode server.connected event") {
+                throw error;
+            }
+            const diagnostics = this.events.diagnostics?.();
+            if (!diagnostics)
+                throw error;
+            throw new Error(`${error.message}; your message was not sent. ${formatOpenCodeEventStreamDiagnostics(diagnostics)}`, { cause: error });
+        }
+    }
+    rethrowRunnerWaitError(error) {
+        if (this.closed)
+            throw new Error("OpenCode session is closed", { cause: error });
+        throw error;
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        this.startExternalStatusReconciliation();
+        this.startChildSessionHydration();
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    startExternalStatusReconciliation() {
+        if (!this.externallyDriven || this.externalStatusReconciliationStarted || this.closed) {
+            return;
+        }
+        this.externalStatusReconciliationStarted = true;
+        void this.reconcileExternalRunnerStatus().catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId }, "Failed to reconcile externally driven OpenCode session status");
+        });
+    }
+    async reconcileExternalRunnerStatus() {
+        await this.events.ready();
+        const observedRevision = this.runnerStatusRevision;
+        const runnerStatus = await this.readProviderRunnerStatus();
+        if (this.runnerStatusRevision !== observedRevision ||
+            this.turnState.status !== "idle" ||
+            !isOpenCodeRunnerActive(runnerStatus)) {
+            return;
+        }
+        this.startAutonomousTurn();
+    }
+    startChildSessionHydration() {
+        if (this.childHydrationPromise) {
+            return;
+        }
+        const hydration = this.hydrateChildSessions()
+            .then(() => {
+            this.childHydrationCompleted = true;
+            return undefined;
+        })
+            .finally(() => {
+            if (this.childHydrationPromise === hydration) {
+                this.childHydrationPromise = null;
+            }
+        });
+        this.childHydrationPromise = hydration;
+        void hydration.catch((error) => {
+            this.logger.warn({ err: error, sessionId: this.sessionId }, "OpenCode child hydration failed");
+        });
+    }
+    async hydrateChildSessions(recovered = false) {
+        const discovered = await this.discoverChildSessions();
+        const statusesByDirectory = await this.readChildStatuses(discovered);
+        for (const child of discovered) {
+            await this.hydrateDiscoveredChild(child, statusesByDirectory, recovered);
+        }
+    }
+    async discoverChildSessions() {
+        const queue = [{ id: this.sessionId, directory: this.config.cwd }];
+        const visited = new Set();
+        const discovered = [];
+        while (queue.length > 0 && visited.size < OPENCODE_CHILD_SESSION_HYDRATION_LIMIT) {
+            const parent = queue.shift();
+            if (!parent || visited.has(parent.id)) {
+                continue;
+            }
+            visited.add(parent.id);
+            const children = await listOpenCodeChildSessions(this.client, parent.id, parent.directory, this.recoveryAbortController.signal);
+            if (this.closed)
+                return discovered;
+            for (const child of children) {
+                discovered.push(child);
+                if (visited.size + queue.length < OPENCODE_CHILD_SESSION_HYDRATION_LIMIT) {
+                    queue.push({ id: child.id, directory: child.directory ?? parent.directory });
+                }
+            }
+        }
+        return discovered;
+    }
+    async readChildStatuses(children) {
+        const statusesByDirectory = new Map();
+        for (const directory of new Set(children.map((child) => child.directory ?? this.config.cwd))) {
+            const response = await this.client.session
+                .status({ directory }, { signal: this.recoveryAbortController.signal })
+                .catch(() => null);
+            const record = readOpenCodeRecord(response);
+            statusesByDirectory.set(directory, record && !record.error ? readOpenCodeRecord(record.data) : null);
+        }
+        return statusesByDirectory;
+    }
+    async hydrateDiscoveredChild(child, statusesByDirectory, recovered) {
+        const directory = child.directory ?? this.config.cwd;
+        const snapshot = statusesByDirectory.get(directory) ?? null;
+        const status = readOpenCodeRecord(snapshot?.[child.id]);
+        const active = snapshot === null || status?.type === "busy" || status?.type === "retry";
+        const detectedStatus = active ? "running" : "completed";
+        const detectionEvents = [];
+        appendOpenCodeChildSessionDetected(child, this.createTranslationState(), detectionEvents, recovered ? null : detectedStatus);
+        for (const event of detectionEvents) {
+            this.recordProviderInternalEvent(event);
+            this.notifySubscribers(event, null);
+        }
+        let messages = null;
+        try {
+            messages = await this.hydrateChildSessionTimeline(child, recovered);
+        }
+        catch (error) {
+            this.logger.warn({ err: error, sessionId: child.id }, "OpenCode child timeline hydration failed");
+        }
+        if (!recovered)
+            return;
+        const latestAssistant = messages?.findLast((message) => message.info.role === "assistant");
+        const recoveredStatus = recoverChildStatus(snapshot !== null, status?.type, latestAssistant);
+        if (!recoveredStatus)
+            return;
+        const statusEvent = {
+            type: "provider_subagent",
+            provider: "opencode",
+            event: { type: "upsert", id: child.id, status: recoveredStatus },
+        };
+        this.recordProviderInternalEvent(statusEvent);
+        this.notifySubscribers(statusEvent, null);
+    }
+    async hydrateChildSessionTimeline(child, recovered = false) {
+        const messages = await readOpenCodeSessionMessagesFromSdk(this.client, {
+            id: child.id,
+            directory: child.directory ?? this.config.cwd,
+            ...(child.revert ? { revert: child.revert } : {}),
+        }, this.recoveryAbortController.signal);
+        if (recovered) {
+            for (const message of messages) {
+                await this.consumeOpenCodeStreamEvent({
+                    rawEvent: {
+                        directory: child.directory ?? this.config.cwd,
+                        payload: { type: "message.updated", properties: { info: message.info } },
+                    },
+                    eventCount: 0,
+                });
+                for (const part of message.parts) {
+                    await this.consumeOpenCodeStreamEvent({
+                        rawEvent: {
+                            directory: child.directory ?? this.config.cwd,
+                            payload: { type: "message.part.updated", properties: { part } },
+                        },
+                        eventCount: 0,
+                    });
+                }
+            }
+            this.emitHydratedChildPresentation(child, messages);
+            return messages;
+        }
+        const translationState = this.getChildTranslationState(child.id);
+        let latestReplayedMessage = null;
+        for (const message of messages) {
+            if (message.info.role === "assistant" && message.info.time?.completed === undefined) {
+                continue;
+            }
+            latestReplayedMessage = message;
+            for (const timelineEvent of buildOpenCodeReplayTimelineEvents(message)) {
+                const event = {
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: {
+                        type: "timeline",
+                        id: child.id,
+                        item: timelineEvent.item,
+                        ...(timelineEvent.timestamp ? { timestamp: timelineEvent.timestamp } : {}),
+                    },
+                };
+                this.recordProviderInternalEvent(event);
+                this.notifySubscribers(event, null);
+            }
+        }
+        if (latestReplayedMessage) {
+            translationState.hydratedMessageFingerprints?.set(latestReplayedMessage.info.id, JSON.stringify(latestReplayedMessage.info));
+            for (const part of latestReplayedMessage.parts) {
+                translationState.hydratedPartFingerprints?.set(part.id, JSON.stringify(part));
+            }
+        }
+        this.emitHydratedChildPresentation(child, messages);
+        return messages;
+    }
+    /**
+     * After replaying a historical child, derive presentation facts from the last assistant
+     * message (the session record's agent/model were already folded at detection) and publish
+     * any missing title plus the updated subtitle once. Presentation-only: no `status`.
+     */
+    emitHydratedChildPresentation(child, messages) {
+        const lastAssistant = messages.findLast((message) => message.info.role === "assistant");
+        if (!lastAssistant) {
+            return;
+        }
+        const facts = readOpenCodeAssistantPresentationFacts(lastAssistant.info);
+        if (!facts) {
+            return;
+        }
+        const presentation = getOpenCodeSubagentPresentationState(child.id, this.getChildTranslationState(child.id));
+        const subtitle = foldOpenCodeSubagentPresentation(presentation, facts);
+        const title = claimOpenCodeSubagentFallbackTitle(presentation, facts.agentName);
+        if (!subtitle && !title) {
+            return;
+        }
+        const event = {
+            type: "provider_subagent",
+            provider: "opencode",
+            event: {
+                type: "upsert",
+                id: child.id,
+                ...(title ? { title } : {}),
+                ...(subtitle ? { subtitle } : {}),
+            },
+        };
+        this.recordProviderInternalEvent(event);
+        this.notifySubscribers(event, null);
+    }
+    recordProviderInternalEvent(event) {
+        if (event.type !== "provider_subagent") {
+            return;
+        }
+        if (event.event.type === "upsert") {
+            this.unrelatedSessionIds.delete(event.event.id);
+            if (event.event.cwd) {
+                this.childSessionCwds.set(event.event.id, event.event.cwd);
+            }
+            if (this.serverUrl) {
+                registerOpenCodeChildSessionServerUrl(event.event.id, this.serverUrl);
+            }
+        }
+        else if (event.event.type === "remove") {
+            unregisterOpenCodeChildSessionServerUrl(event.event.id);
+            this.childTranslationStates.delete(event.event.id);
+            this.childSessionCwds.delete(event.event.id);
+            this.childStatuses.delete(event.event.id);
+            this.subagentPresentationByChildId.delete(event.event.id);
+        }
+    }
+    async consumeEventSourceInput(input) {
+        if (!("payload" in input)) {
+            if (this.turnState.status === "stopping")
+                return this.finishStoppingTurn(this.turnState.stop);
+            const turnId = this.activeForegroundTurnId;
+            if (turnId) {
+                this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: input.error.message }, turnId);
+            }
+            return;
+        }
+        if (input.payload.type === "server.connected") {
+            await this.reconcileAfterGap(++this.gapRepairRevision);
+            return;
+        }
+        await this.consumeOpenCodeStreamEvent({ rawEvent: input, eventCount: 0 });
+    }
+    async reconcileAfterGap(revision, refresh = true, delay = 100) {
+        if (revision !== this.gapRepairRevision)
+            return;
+        const turnId = this.activeForegroundTurnId;
+        const dispatchMessageId = this.activeDispatchMessageId;
+        await this.refreshGapScope(refresh);
+        if (revision !== this.gapRepairRevision || !turnId)
+            return;
+        const runnerStatus = await this.readProviderRunnerStatus().catch(() => null);
+        if (revision !== this.gapRepairRevision)
+            return;
+        if (runnerStatus === null) {
+            this.scheduleGapRepair(revision, delay);
+            return;
+        }
+        if (dispatchMessageId === null) {
+            if (runnerStatus === "idle") {
+                this.suppressAssistantMessagesUntilIdle.active = false;
+                this.finishForegroundTurn({ type: "turn_completed", provider: "opencode" }, turnId);
+            }
+            return;
+        }
+        const messages = await readOpenCodeSessionMessagesFromSdk(this.client, { id: this.sessionId, directory: this.config.cwd }, this.recoveryAbortController.signal).catch(() => null);
+        if (revision !== this.gapRepairRevision)
+            return;
+        if (messages === null) {
+            this.scheduleGapRepair(revision, delay);
+            return;
+        }
+        const boundary = messages.findIndex((message) => message.info.id === dispatchMessageId);
+        if (boundary < 0) {
+            if (runnerStatus === "idle") {
+                this.finishForegroundTurn({ type: "turn_failed", provider: "opencode", error: "Active dispatch not found" }, turnId);
+            }
+            return;
+        }
+        for (const message of messages.slice(boundary)) {
+            if (revision !== this.gapRepairRevision)
+                return;
+            await this.consumeOpenCodeStreamEvent({
+                rawEvent: {
+                    directory: this.config.cwd,
+                    payload: { type: "message.updated", properties: { info: message.info } },
+                },
+                eventCount: 0,
+            });
+            for (const part of message.parts) {
+                if (revision !== this.gapRepairRevision)
+                    return;
+                await this.consumeOpenCodeStreamEvent({
+                    rawEvent: {
+                        directory: this.config.cwd,
+                        payload: { type: "message.part.updated", properties: { part } },
+                    },
+                    eventCount: 0,
+                });
+            }
+        }
+        if (runnerStatus === "idle" && this.activeForegroundTurnId === turnId) {
+            await this.settleRecoveredGap(messages, boundary);
+        }
+    }
+    async refreshGapScope(refresh) {
+        if (!refresh)
+            return;
+        await this.hydrateChildSessions(true).catch(() => undefined);
+        await this.reconcileBlockingRequests();
+    }
+    async settleRecoveredGap(messages, boundary) {
+        const latestAssistant = messages
+            .slice(boundary)
+            .findLast((message) => message.info.role === "assistant");
+        const persistedError = latestAssistant && "error" in latestAssistant.info ? latestAssistant.info.error : undefined;
+        const payload = persistedError
+            ? {
+                type: "session.error",
+                properties: { sessionID: this.sessionId, error: persistedError },
+            }
+            : {
+                type: "session.status",
+                properties: { sessionID: this.sessionId, status: { type: "idle" } },
+            };
+        await this.consumeOpenCodeStreamEvent({
+            rawEvent: { directory: this.config.cwd, payload },
+            eventCount: 0,
+        });
+    }
+    scheduleGapRepair(revision, delayMs) {
+        setTimeout(() => {
+            if (revision !== this.gapRepairRevision || this.recoveryAbortController.signal.aborted)
+                return;
+            const nextDelay = Math.min(delayMs * 2, OPENCODE_STOP_STATUS_MAX_DELAY_MS);
+            this.ingress = this.ingress
+                .then(() => this.reconcileAfterGap(revision, false, nextDelay))
+                .catch(() => undefined);
+        }, delayMs).unref();
+    }
+    async reconcileBlockingRequests() {
+        const directories = new Set([this.config.cwd, ...this.childSessionCwds.values()]);
+        for (const directory of directories) {
+            const [permissions, questions] = await Promise.all([
+                this.client.permission
+                    .list({ directory }, { signal: this.recoveryAbortController.signal })
+                    .catch(() => null),
+                this.client.question
+                    .list({ directory }, { signal: this.recoveryAbortController.signal })
+                    .catch(() => null),
+            ]);
+            for (const [kind, response] of [
+                ["tool", permissions],
+                ["question", questions],
+            ]) {
+                const record = readOpenCodeRecord(response);
+                if (!record || record.error || !Array.isArray(record.data))
+                    continue;
+                const liveIds = new Set();
+                for (const properties of record.data) {
+                    const propertiesRecord = readOpenCodeRecord(properties);
+                    const id = readNonEmptyString(propertiesRecord?.id);
+                    const sessionId = readNonEmptyString(propertiesRecord?.sessionID);
+                    if (!id || !sessionId || !this.isOwnedSessionId(sessionId))
+                        continue;
+                    liveIds.add(id);
+                    await this.consumeOpenCodeStreamEvent({
+                        rawEvent: {
+                            directory,
+                            payload: {
+                                type: kind === "question" ? "question.asked" : "permission.asked",
+                                properties,
+                            },
+                        },
+                        eventCount: 0,
+                    });
+                }
+                for (const [id, pendingDirectory] of this.pendingPermissionDirectories) {
+                    const pending = this.pendingPermissions.get(id);
+                    if (pendingDirectory !== directory ||
+                        liveIds.has(id) ||
+                        (kind === "question") !== (pending?.kind === "question")) {
+                        continue;
+                    }
+                    this.pendingPermissionDirectories.delete(id);
+                    this.pendingPermissions.delete(id);
+                    this.notifySubscribers({
+                        type: "permission_resolved",
+                        provider: "opencode",
+                        requestId: id,
+                        resolution: { behavior: "allow" },
+                    }, null);
+                }
+            }
+        }
+    }
+    isOwnedSessionId(sessionId) {
+        return sessionId === this.sessionId || this.knownChildSessionIds.has(sessionId);
+    }
+    async consumeOpenCodeStreamEvent(params) {
+        const { rawEvent, eventCount } = params;
+        let turnId = this.activeForegroundTurnId;
+        const event = unwrapOpenCodeGlobalEvent(rawEvent);
+        this.traceOpenCode("provider.opencode.raw_event", {
+            turnId: turnId ?? undefined,
+            n: eventCount,
+            type: event?.type,
+            rawType: readOpenCodeRecord(rawEvent)?.type,
+            directory: readOpenCodeRecord(rawEvent)?.directory,
+            rawEvent,
+            properties: event?.properties,
+        });
+        if (!event) {
+            return;
+        }
+        this.observeRunnerStatusEvent(event);
+        if (this.discardEventWhileStopping(event, eventCount)) {
+            return;
+        }
+        const translated = await this.translateEvent(event);
+        const foregroundEvents = [];
+        for (const translatedEvent of translated) {
+            if (isOpenCodeProviderInternalEvent(translatedEvent)) {
+                this.notifySubscribers(translatedEvent, null);
+            }
+            else {
+                foregroundEvents.push(translatedEvent);
+            }
+        }
+        if (!turnId && this.shouldStartAutonomousTurn(event)) {
+            turnId = this.startAutonomousTurn();
+        }
+        if (!turnId) {
+            this.emitBackgroundPermissionRequests(foregroundEvents);
+            this.traceOpenCode("provider.opencode.event.skip", {
+                n: eventCount,
+                reason: "no_active_turn",
+                type: event.type,
+            });
+            return;
+        }
+        this.traceOpenCode("provider.opencode.parsed_event", {
+            turnId,
+            n: eventCount,
+            count: foregroundEvents.length,
+            types: foregroundEvents.map((t) => t.type),
+            events: foregroundEvents,
+        });
+        for (const e of foregroundEvents) {
+            if (this.activeForegroundTurnId !== turnId) {
+                this.traceOpenCode("provider.opencode.parsed_event.skip_active", { turnId, type: e.type });
+                return;
+            }
+            if (e.type === "timeline" && e.item.type === "tool_call") {
+                this.trackToolCall(e.item);
+            }
+            const terminalEvent = toTerminalTurnEvent(e);
+            if (terminalEvent) {
+                this.traceOpenCode("provider.opencode.event.terminal", {
+                    turnId,
+                    type: terminalEvent.type,
+                });
+                this.finishForegroundTurn(terminalEvent, turnId);
+                return;
+            }
+            this.notifySubscribers(e, turnId);
+        }
+    }
+    discardEventWhileStopping(event, eventCount) {
+        if (this.turnState.status !== "stopping" ||
+            getOpenCodeEventSessionId(event) !== this.sessionId) {
+            return false;
+        }
+        // Residue of the canceled run must not surface as a new turn. Its terminal
+        // is the authoritative end of the stop, so anything OpenCode publishes
+        // afterwards belongs to a new run by construction and takes the live path.
+        if (isOpenCodeTerminalEvent(event, this.sessionId)) {
+            this.finishStoppingTurn(this.turnState.stop);
+        }
+        this.traceOpenCode("provider.opencode.event.skip", {
+            n: eventCount,
+            reason: "turn_stopping",
+            type: event.type,
+        });
+        return true;
+    }
+    emitBackgroundPermissionRequests(events) {
+        for (const event of events) {
+            if (event.type === "permission_requested") {
+                this.notifySubscribers(event, null);
+            }
+        }
+    }
+    observeRunnerStatusEvent(event) {
+        if (getOpenCodeRunnerStatusFromEvent(event, this.sessionId) !== null) {
+            this.runnerStatusRevision += 1;
+        }
+    }
+    shouldStartAutonomousTurn(event) {
+        if (this.turnState.status !== "idle") {
+            return false;
+        }
+        // Message records are mutable and can be patched after the runner stops.
+        // Only OpenCode's execution status is authoritative for autonomous activity.
+        const runnerStatus = getOpenCodeRunnerStatusFromEvent(event, this.sessionId);
+        return runnerStatus !== null && isOpenCodeRunnerActive(runnerStatus);
+    }
+    startAutonomousTurn() {
+        const turnId = this.createTurnId();
+        this.materializedParts.clear();
+        this.turnState = { status: "running", turnId };
+        this.runningToolCalls.clear();
+        this.subAgentsByCallId.clear();
+        this.subAgentCallIdByChildSessionId.clear();
+        this.pendingSteerSubmissions = [];
+        this.pendingUserMessageText = null;
+        this.pendingClientMessageId = null;
+        this.activeDispatchMessageId = null;
+        this.abortController = null;
+        this.notifySubscribers({ type: "turn_started", provider: "opencode" }, turnId);
+        return turnId;
+    }
+    finishForegroundTurn(event, turnId) {
+        this.traceOpenCode("provider.opencode.finish_foreground_turn", {
+            turnId,
+            activeTurnId: this.activeForegroundTurnId,
+            type: event.type,
+            error: event.type === "turn_failed" ? event.error : undefined,
+            reason: event.type === "turn_canceled" ? event.reason : undefined,
+        });
+        if (this.activeForegroundTurnId !== turnId) {
+            return;
+        }
+        if (event.type === "turn_canceled" || event.type === "turn_failed") {
+            this.synthesizeInterruptedToolCalls(turnId);
+        }
+        else {
+            this.runningToolCalls.clear();
+        }
+        this.pendingUserMessageText = null;
+        this.pendingClientMessageId = null;
+        this.pendingSteerSubmissions = [];
+        this.turnState = { status: "idle" };
+        this.abortController = null;
+        this.notifySubscribers(event, turnId);
+    }
+    isStopping(stop) {
+        return this.turnState.status === "stopping" && this.turnState.stop === stop;
+    }
+    issueStop(turnId) {
+        if (this.turnState.status === "stopping") {
+            // Stop pressed again during a stop retries that same stop. There is one
+            // runner per session, so a second boundary would race the first — and
+            // after a failed abort, a fresh one is both the only proof that can still
+            // acknowledge the canceled turn and the only way out of fail-closed.
+            return this.issueOwnedAbort(this.turnState.stop);
+        }
+        const stop = {
+            pendingCancellationTurnId: turnId,
+            terminal: createDeferred(),
+        };
+        const abort = this.issueOwnedAbort(stop);
+        if (turnId) {
+            this.synthesizeInterruptedToolCalls(turnId);
+            // An idle session has no run to observe, so only abort settlement gates
+            // reuse there. A running one also owes the canceled run's terminal.
+            this.turnState = { status: "stopping", stop };
+        }
+        this.pendingUserMessageText = null;
+        this.pendingClientMessageId = null;
+        this.pendingSteerSubmissions = [];
+        this.abortController = null;
+        return abort;
+    }
+    issueOwnedAbort(stop) {
+        const abort = this.runOwnedAbort(stop.pendingCancellationTurnId);
+        // Abort is session-scoped, so its settlement is too: an older request lands
+        // on the runner whenever the server gets to it, however many stops have come
+        // and gone since. Only the newest abort may hold the gate closed, since
+        // recovering from a failed one is what pressing Stop again is for.
+        const stillInFlight = this.abortSettlement.catch(() => undefined);
+        this.abortSettlement = Promise.all([stillInFlight, abort]).then(() => undefined);
+        void this.abortSettlement.catch(() => undefined);
+        // Cancellation is acknowledged as soon as an owned abort succeeds, or when
+        // the provider publishes the canceled run's terminal.
+        void abort.then(() => this.acknowledgeCancellation(stop), () => undefined);
+        return abort;
+    }
+    acknowledgeCancellation(stop) {
+        const turnId = stop.pendingCancellationTurnId;
+        if (!turnId) {
+            return;
+        }
+        stop.pendingCancellationTurnId = null;
+        this.notifySubscribers({ type: "turn_canceled", provider: "opencode", reason: "interrupted" }, turnId);
+    }
+    /**
+     * Issues the session-scoped abort for one stop, retrying it once. The stop owns
+     * every abort it needs: a detached retry would outlive its own boundary and
+     * cancel whichever run happened to be current when it landed.
+     */
+    runOwnedAbort(turnId) {
+        // The turn hop also converts a synchronous SDK throw into a rejection.
+        return Promise.resolve()
+            .then(() => this.abortSession(turnId, "interrupt"))
+            .catch((error) => {
+            if (this.closed) {
+                throw error;
+            }
+            return this.abortSession(turnId, "stop_retry");
+        });
+    }
+    finishStoppingTurn(stop) {
+        if (!this.isStopping(stop)) {
+            return;
+        }
+        // Acknowledge before leaving the stopping state so a successor run adopted
+        // from the very next event cannot start ahead of the cancellation.
+        this.acknowledgeCancellation(stop);
+        resetOpenCodeTurnTrackingState(this.createTranslationState());
+        const contextWindowMaxTokens = this.resolveSelectedModelContextWindowMaxTokens();
+        this.accumulatedUsage = contextWindowMaxTokens !== undefined ? { contextWindowMaxTokens } : {};
+        this.turnState = { status: "idle" };
+        stop.terminal.resolve();
+    }
+    trackToolCall(item) {
+        if (item.status === "running") {
+            this.runningToolCalls.set(item.callId, item);
+            return;
+        }
+        this.runningToolCalls.delete(item.callId);
+    }
+    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,
+                    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);
+        }
+        this.runningToolCalls.clear();
+    }
+    /**
+     * The fork id only exists once session.fork resolves, so its session.created event can land
+     * first and be translated into a subagent row. Registering reaps that row, which is why this
+     * removes as well as records.
+     */
+    registerSideQuestionFork(forkSessionId) {
+        this.sideQuestionSessionIds.add(forkSessionId);
+        // Both deletes must run: || would skip the second whenever the first succeeded.
+        const wasKnownChild = this.knownChildSessionIds.delete(forkSessionId);
+        const hadSubAgentCall = this.subAgentCallIdByChildSessionId.delete(forkSessionId);
+        const raced = wasKnownChild || hadSubAgentCall;
+        this.subagentPresentationByChildId.delete(forkSessionId);
+        this.childStatuses.delete(forkSessionId);
+        if (raced) {
+            this.notifySubscribers({
+                type: "provider_subagent",
+                provider: "opencode",
+                event: { type: "remove", id: forkSessionId },
+            });
+        }
+    }
+    notifySubscribers(event, turnIdOverride) {
+        if (this.closed) {
+            return;
+        }
+        if (event.type === "provider_subagent" && event.event.type === "upsert" && event.event.status) {
+            const previous = this.childStatuses.get(event.event.id);
+            const current = event.event.parentSubagentId === undefined && previous?.parentSubagentId !== undefined
+                ? { ...event.event, parentSubagentId: previous.parentSubagentId }
+                : event.event;
+            if (isDeepStrictEqual(previous, current))
+                return;
+            this.childStatuses.set(event.event.id, structuredClone(current));
+        }
+        const turnId = turnIdOverride === null ? null : (turnIdOverride ?? this.activeForegroundTurnId);
+        const tagged = turnId ? { ...event, turnId } : event;
+        this.traceOpenCode("provider.opencode.event_emit", {
+            turnId: getAgentStreamEventTurnId(tagged),
+            event: tagged,
+        });
+        for (const callback of this.subscribers) {
+            try {
+                callback(tagged);
+            }
+            catch { }
+        }
+    }
+    createTurnId() {
+        this.gapRepairRevision += 1;
+        return `opencode-turn-${this.nextTurnOrdinal++}`;
+    }
+    traceOpenCode(msg, data = {}) {
+        this.logger.trace({
+            agentId: this.agentId,
+            provider: "opencode",
+            sessionId: this.sessionId,
+            turnId: data.turnId ?? this.activeForegroundTurnId ?? undefined,
+            ...data,
+        }, msg);
+    }
+    async *streamHistory() {
+        const sessionResponse = await this.client.session.get({
+            sessionID: this.sessionId,
+            directory: this.config.cwd,
+        });
+        const response = await this.client.session.messages({
+            sessionID: this.sessionId,
+            directory: this.config.cwd,
+        });
+        if (response.error || !response.data) {
+            return;
+        }
+        const messages = filterOpenCodeRevertedMessages(response.data, sessionResponse.error ? null : sessionResponse.data?.revert);
+        for (const message of messages) {
+            for (const event of buildOpenCodeReplayTimelineEvents(message)) {
+                yield event;
+            }
+        }
+    }
+    async getAvailableModes() {
+        if (this.availableModesCache) {
+            return this.availableModesCache;
+        }
+        const response = await openCodeMetadataLimit(() => this.client.app.agents({
+            directory: this.config.cwd,
+        }));
+        const agents = response.error || !response.data ? [] : response.data;
+        const discoveredModes = agents.filter(isSelectableOpenCodeAgent).map(mapOpenCodeAgentToMode);
+        this.availableModesCache = mergeOpenCodeModes(discoveredModes);
+        return this.availableModesCache;
+    }
+    async getCurrentMode() {
+        return this.currentMode;
+    }
+    async listCommands() {
+        return await listOpenCodeCommandsFromSdk(this.client, this.config.cwd);
+    }
+    async setMode(modeId) {
+        const normalizedModeId = normalizeOpenCodeModeId(modeId);
+        if (normalizedModeId === OPENCODE_LEGACY_FULL_ACCESS_MODE_ID) {
+            this.currentMode = OPENCODE_BUILD_MODE_ID;
+            await this.setFeature(OPENCODE_AUTO_ACCEPT_FEATURE_ID, true);
+            return;
+        }
+        this.currentMode = normalizedModeId;
+        this.config.modeId = normalizedModeId ?? undefined;
+    }
+    async setFeature(featureId, value) {
+        if (featureId !== OPENCODE_AUTO_ACCEPT_FEATURE_ID) {
+            throw new Error(`Unsupported OpenCode feature '${featureId}'`);
+        }
+        const enabled = value === true;
+        this.autoAcceptEnabled = enabled;
+        this.config.featureValues = {
+            ...this.config.featureValues,
+            [OPENCODE_AUTO_ACCEPT_FEATURE_ID]: enabled,
+        };
+    }
+    getPendingPermissions() {
+        return Array.from(this.pendingPermissions.values());
+    }
+    async respondToPermission(requestId, response) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error(`No pending permission request with id '${requestId}'`);
+        }
+        const directory = this.pendingPermissionDirectories.get(requestId) ?? this.config.cwd;
+        if (pending.kind === "question") {
+            if (response.behavior === "deny") {
+                await this.client.question.reject({
+                    requestID: requestId,
+                    directory,
+                });
+            }
+            else {
+                const answersRecord = readOpenCodeRecord(response.updatedInput?.answers);
+                const questions = Array.isArray(pending.input?.questions) ? pending.input.questions : [];
+                const answers = questions.map((item) => {
+                    const header = readNonEmptyString(readOpenCodeRecord(item)?.header);
+                    const rawAnswer = header ? readNonEmptyString(answersRecord?.[header]) : null;
+                    if (!rawAnswer) {
+                        return [];
+                    }
+                    return rawAnswer
+                        .split(",")
+                        .map((entry) => entry.trim())
+                        .filter((entry) => entry.length > 0);
+                });
+                await this.client.question.reply({
+                    requestID: requestId,
+                    directory,
+                    answers,
+                });
+            }
+            this.pendingPermissions.delete(requestId);
+            this.pendingPermissionDirectories.delete(requestId);
+            return;
+        }
+        const reply = resolveOpenCodePermissionReply(response);
+        await this.client.permission.reply({
+            requestID: requestId,
+            directory,
+            reply,
+            message: response.behavior === "deny" ? response.message : undefined,
+        });
+        this.pendingPermissions.delete(requestId);
+        this.pendingPermissionDirectories.delete(requestId);
+    }
+    describePersistence() {
+        return {
+            provider: "opencode",
+            sessionId: this.sessionId,
+            nativeHandle: this.sessionId,
+            metadata: {
+                cwd: this.config.cwd,
+                ...(this.config.modeId ? { modeId: this.config.modeId } : {}),
+                ...(this.config.model ? { model: this.config.model } : {}),
+            },
+        };
+    }
+    async close() {
+        try {
+            this.closed = true;
+            this.abortController?.abort();
+            this.recoveryAbortController.abort();
+            this.unsubscribeEvents?.();
+            this.unsubscribeEvents = null;
+            await this.ingress.catch(() => undefined);
+            this.subscribers.clear();
+            await abortOpenCodeSession({
+                client: this.client,
+                sessionId: this.sessionId,
+                directory: this.config.cwd,
+                logger: this.logger,
+            });
+            await this.deleteProviderSessionIfEphemeral();
+            this.turnState = { status: "idle" };
+        }
+        finally {
+            this.releaseBridge?.();
+            this.releaseBridge = null;
+            await this.releaseServer?.();
+            this.releaseServer = null;
+        }
+    }
+    async deleteProviderSessionIfEphemeral() {
+        if (this.persistSession || this.deletedFromProvider) {
+            return;
+        }
+        this.deletedFromProvider = true;
+        try {
+            const response = await this.client.session.delete({
+                sessionID: this.sessionId,
+                directory: this.config.cwd,
+            });
+            if (response.error) {
+                throw new Error(`OpenCode session.delete failed: ${JSON.stringify(response.error)}`);
+            }
+        }
+        catch (error) {
+            this.logger.debug({ err: error, sessionId: this.sessionId }, "Failed to delete non-persistent OpenCode session");
+        }
+    }
+    parseSlashCommandInput(text) {
+        const trimmed = text.trim();
+        if (!trimmed.startsWith("/") || trimmed.length <= 1) {
+            return null;
+        }
+        const withoutPrefix = trimmed.slice(1);
+        const firstWhitespaceIdx = withoutPrefix.search(/\s/);
+        const commandName = firstWhitespaceIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, firstWhitespaceIdx);
+        if (!commandName || commandName.includes("/")) {
+            return null;
+        }
+        const rawArgs = firstWhitespaceIdx === -1 ? "" : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+        return rawArgs.length > 0 ? { commandName, args: rawArgs } : { commandName };
+    }
+    async resolveSlashCommandInvocation(prompt) {
+        if (typeof prompt !== "string") {
+            return null;
+        }
+        const parsed = this.parseSlashCommandInput(prompt);
+        if (!parsed) {
+            return null;
+        }
+        try {
+            const commands = await this.listCommands();
+            return commands.some((command) => command.name === parsed.commandName) ? parsed : null;
+        }
+        catch (error) {
+            this.logger.warn({ err: error, commandName: parsed.commandName }, "Failed to resolve slash command; falling back to plain prompt input");
+            return null;
+        }
+    }
+    parseModel(model) {
+        if (!model) {
+            return undefined;
+        }
+        const parts = model.split("/");
+        if (parts.length >= 2) {
+            return { providerID: parts[0], modelID: parts.slice(1).join("/") };
+        }
+        return { providerID: "opencode", modelID: model };
+    }
+    async ensureMcpServersConfigured() {
+        if (this.mcpConfigured) {
+            return;
+        }
+        const mcpServers = this.config.mcpServers;
+        if (!mcpServers || Object.keys(mcpServers).length === 0) {
+            this.mcpConfigured = true;
+            return;
+        }
+        if (!this.mcpSetupPromise) {
+            this.mcpSetupPromise = this.configureMcpServers(mcpServers);
+        }
+        try {
+            await this.mcpSetupPromise;
+            this.mcpConfigured = true;
+        }
+        catch (error) {
+            this.mcpSetupPromise = null;
+            throw error;
+        }
+    }
+    async configureMcpServers(mcpServers) {
+        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({
+            directory: this.config.cwd,
+            name,
+            config,
+        }));
+    }
+    async runMcpOperation(operation, name, run) {
+        const response = await run();
+        const error = response.error ?? readOpenCodeMcpOperationError(response.data, name);
+        if (!error) {
+            return;
+        }
+        if (isAlreadyPresentMcpError(error)) {
+            return;
+        }
+        throw new Error(`Failed to ${operation} OpenCode MCP server '${name}': ${toDiagnosticErrorMessage(error)}`);
+    }
+    createTranslationState() {
+        return {
+            sessionId: this.sessionId,
+            cwd: this.config.cwd,
+            messageRoles: this.messageRoles,
+            pendingUserMessageText: this.pendingUserMessageText,
+            pendingClientMessageId: this.pendingClientMessageId,
+            pendingSteerSubmissions: this.pendingSteerSubmissions,
+            emittedUserMessageIds: this.emittedUserMessageIds,
+            accumulatedUsage: this.accumulatedUsage,
+            sessionTotalCostUsd: this.sessionTotalCostUsd,
+            materializedParts: this.materializedParts,
+            emittedStructuredMessageIds: this.emittedStructuredMessageIds,
+            compactionSummaryMessageIds: this.compactionSummaryMessageIds,
+            emittedCompactionPartIds: this.emittedCompactionPartIds,
+            suppressAssistantMessagesUntilIdle: this.suppressAssistantMessagesUntilIdle,
+            partTypes: this.partTypes,
+            subAgentsByCallId: this.subAgentsByCallId,
+            subAgentCallIdByChildSessionId: this.subAgentCallIdByChildSessionId,
+            knownChildSessionIds: this.knownChildSessionIds,
+            sideQuestionSessionIds: this.sideQuestionSessionIds,
+            subagentPresentationByChildId: this.subagentPresentationByChildId,
+            modelContextWindowsByModelKey: this.modelContextWindowsByModelKey,
+            onMaterializationMismatch: (diagnostic) => {
+                this.logger.warn({ ...diagnostic, sessionId: this.sessionId }, "OpenCode final part snapshot replaced streamed content");
+            },
+            onAssistantModelContextWindowResolved: (contextWindowMaxTokens) => {
+                this.accumulatedUsage.contextWindowMaxTokens = contextWindowMaxTokens;
+                if (!this.config.model) {
+                    this.selectedModelContextWindowMaxTokens = contextWindowMaxTokens;
+                }
+            },
+        };
+    }
+    getChildTranslationState(sessionId) {
+        const existing = this.childTranslationStates.get(sessionId);
+        if (existing) {
+            return existing;
+        }
+        const state = {
+            sessionId,
+            cwd: this.config.cwd,
+            messageRoles: new Map(),
+            emittedUserMessageIds: new Set(),
+            accumulatedUsage: {},
+            materializedParts: new Map(),
+            emittedStructuredMessageIds: new Set(),
+            compactionSummaryMessageIds: new Set(),
+            emittedCompactionPartIds: new Set(),
+            hydratedMessageFingerprints: new Map(),
+            hydratedPartFingerprints: new Map(),
+            suppressAssistantMessagesUntilIdle: { active: false },
+            partTypes: new Map(),
+            subAgentsByCallId: new Map(),
+            subAgentCallIdByChildSessionId: new Map(),
+            knownChildSessionIds: new Set(),
+            subagentPresentationByChildId: this.subagentPresentationByChildId,
+            modelContextWindowsByModelKey: this.modelContextWindowsByModelKey,
+            onMaterializationMismatch: (diagnostic) => {
+                this.logger.warn({ ...diagnostic, sessionId }, "OpenCode final part snapshot replaced streamed content");
+            },
+        };
+        this.childTranslationStates.set(sessionId, state);
+        return state;
+    }
+    appendProviderSubagentEvents(event, translated) {
+        const childSessionId = getOpenCodeEventSessionId(event);
+        const isKnownChild = childSessionId && this.knownChildSessionIds.has(childSessionId);
+        if (!childSessionId || childSessionId === this.sessionId || !isKnownChild) {
+            return;
+        }
+        translated.push(...this.translateProviderSubagentEvent(childSessionId, event));
+    }
+    translateProviderSubagentEvent(sessionId, event) {
+        const translated = translateOpenCodeEvent(event, this.getChildTranslationState(sessionId));
+        const events = [];
+        let markedRunning = false;
+        const markRunning = () => {
+            if (markedRunning)
+                return;
+            markedRunning = true;
+            events.push({
+                type: "provider_subagent",
+                provider: "opencode",
+                event: { type: "upsert", id: sessionId, status: "running" },
+            });
+        };
+        if (event.type === "session.status" && event.properties.status.type === "busy") {
+            markRunning();
+        }
+        this.appendChildAssistantPresentationUpsert(sessionId, event, events);
+        for (const childEvent of translated) {
+            if (childEvent.type === "timeline") {
+                markRunning();
+                events.push({
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: {
+                        type: "timeline",
+                        id: sessionId,
+                        item: childEvent.item,
+                        timestamp: childEvent.timestamp,
+                    },
+                });
+            }
+            else if (childEvent.type === "turn_started") {
+                markRunning();
+            }
+            else if (childEvent.type === "turn_completed") {
+                events.push({
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: { type: "upsert", id: sessionId, status: "completed" },
+                });
+            }
+            else if (childEvent.type === "turn_failed") {
+                events.push({
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: { type: "upsert", id: sessionId, status: "failed" },
+                });
+            }
+            else if (childEvent.type === "turn_canceled") {
+                events.push({
+                    type: "provider_subagent",
+                    provider: "opencode",
+                    event: { type: "upsert", id: sessionId, status: "canceled" },
+                });
+            }
+            else if (childEvent.type === "permission_requested" &&
+                childEvent.request.kind === "question") {
+                events.push(childEvent);
+            }
+        }
+        return events;
+    }
+    /**
+     * Fold presentation facts (agent, model, variant, completed-message tokens) off a child
+     * assistant `message.updated` frame and emit the missing title and/or changed subtitle.
+     * Never carries `status`: a presentation upsert must not revert a finished child.
+     */
+    appendChildAssistantPresentationUpsert(sessionId, event, events) {
+        if (event.type !== "message.updated") {
+            return;
+        }
+        const info = event.properties.info;
+        if (info.sessionID !== sessionId || info.role !== "assistant") {
+            return;
+        }
+        const facts = readOpenCodeAssistantPresentationFacts(info);
+        if (!facts) {
+            return;
+        }
+        const presentation = getOpenCodeSubagentPresentationState(sessionId, this.getChildTranslationState(sessionId));
+        const subtitle = foldOpenCodeSubagentPresentation(presentation, facts);
+        const title = claimOpenCodeSubagentFallbackTitle(presentation, facts.agentName);
+        if (!subtitle && !title) {
+            return;
+        }
+        events.push({
+            type: "provider_subagent",
+            provider: "opencode",
+            event: {
+                type: "upsert",
+                id: sessionId,
+                ...(title ? { title } : {}),
+                ...(subtitle ? { subtitle } : {}),
+            },
+        });
+    }
+    async translateEvent(event) {
+        const eventSessionId = getOpenCodeEventSessionId(event);
+        if (event.type !== "session.created" &&
+            eventSessionId &&
+            eventSessionId !== this.sessionId &&
+            !this.knownChildSessionIds.has(eventSessionId) &&
+            !this.unrelatedSessionIds.has(eventSessionId)) {
+            if (!this.childHydrationCompleted) {
+                this.startChildSessionHydration();
+                await this.childHydrationPromise?.catch(() => undefined);
+            }
+            if (!this.knownChildSessionIds.has(eventSessionId)) {
+                this.unrelatedSessionIds.add(eventSessionId);
+            }
+        }
+        const translated = translateOpenCodeEvent(event, this.createTranslationState());
+        this.appendProviderSubagentEvents(event, translated);
+        const events = [];
+        if (typeof this.accumulatedUsage.totalCostUsd === "number") {
+            this.sessionTotalCostUsd = maxFiniteNumber(this.sessionTotalCostUsd, this.accumulatedUsage.totalCostUsd);
+        }
+        for (const translatedEvent of translated) {
+            this.recordProviderInternalEvent(translatedEvent);
+            if (translatedEvent.type === "permission_requested") {
+                const directory = (eventSessionId ? this.childSessionCwds.get(eventSessionId) : undefined) ??
+                    this.config.cwd;
+                const autoApproved = await this.tryAutoApproveToolPermission(translatedEvent.request, directory);
+                if (autoApproved) {
+                    continue;
+                }
+                this.pendingPermissions.set(translatedEvent.request.id, translatedEvent.request);
+                this.pendingPermissionDirectories.set(translatedEvent.request.id, directory);
+            }
+            if (translatedEvent.type === "turn_completed") {
+                if (hasNormalizedOpenCodeUsage(this.accumulatedUsage)) {
+                    translatedEvent.usage = this.accumulatedUsage;
+                }
+                const contextWindowMaxTokens = this.resolveSelectedModelContextWindowMaxTokens();
+                this.accumulatedUsage =
+                    contextWindowMaxTokens !== undefined ? { contextWindowMaxTokens } : {};
+            }
+            events.push(translatedEvent);
+        }
+        return events;
+    }
+    async tryAutoApproveToolPermission(request, directory) {
+        if (!this.autoAcceptEnabled || request.kind !== "tool") {
+            return false;
+        }
+        try {
+            await this.client.permission.reply({
+                requestID: request.id,
+                directory,
+                reply: "once",
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.warn({ err: error, requestId: request.id }, "Failed to auto-approve OpenCode tool permission");
+            return false;
+        }
+    }
+    resolveSelectedModelContextWindowMaxTokens() {
+        return this.selectedModelContextWindowMaxTokens;
+    }
+    resolveConfiguredModelContextWindowMaxTokens(modelId) {
+        const modelLookupKey = parseOpenCodeModelLookupKey(modelId);
+        if (!modelLookupKey) {
+            return undefined;
+        }
+        return this.modelContextWindowsByModelKey.get(modelLookupKey);
+    }
+}
+//# sourceMappingURL=opencode-agent.js.map