subharness 0.0.4 → 0.0.7

package/dist/adapters/opencode.js

@@ -0,0 +1,569 @@
+import { randomBytes } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AgentError } from "../errors.js";
+import { NativeApprovals } from "./approval-lifetime.js";
+import { resolveOpencodeRoute } from "./opencode-access.js";
+import { createOpencodeRuntime, gatewayBaseUrl } from "./opencode-config.js";
+import { OpencodeHttp, startOpencodeProcess, supportedOpencodeVersion } from "./opencode-http.js";
+import { startOpencodeTools } from "./opencode-tools.js";
+export async function openOpencode(options) {
+    const harness = options.harness;
+    if (harness.kind !== "opencode")
+        throw new AgentError("INVALID_CONFIG", "OpenCode received configuration for a different harness.");
+    const model = harness.model;
+    const route = resolveOpencodeRoute(model, options.access);
+    const cwd = await realpath(options.cwd).catch(() => resolve(options.cwd));
+    const runtime = await createOpencodeRuntime(options, route);
+    const tools = await startOpencodeTools(options.agent).catch(async (error) => { await runtime.close(); throw error; });
+    const password = randomBytes(32).toString("base64url");
+    runtime.env.OPENCODE_SERVER_PASSWORD = password;
+    let native;
+    let eventController;
+    let sessionID;
+    try {
+        native = await startOpencodeProcess(cwd, runtime.env);
+        const http = new OpencodeHttp(native.url, cwd, password);
+        await verifyStartup(http, runtime.config, options, route);
+        const approvals = new NativeApprovals();
+        const pendingApprovals = new Set();
+        const approvalTasks = new Set();
+        let active;
+        let closed = false;
+        let first = true;
+        let closing;
+        let fatalEventError;
+        const abortNative = async () => {
+            if (!sessionID)
+                return;
+            await http.json(`/session/${encodeURIComponent(sessionID)}/abort`, { method: "POST", timeout: 1_000 }).catch(() => { });
+        };
+        const fail = (error) => {
+            const current = active;
+            if (!current) {
+                fatalEventError ??= error;
+                return;
+            }
+            current.failure ??= error;
+            tools.stopAdmission();
+            current.lifecycle.abort();
+            approvals.clear();
+            void abortNative();
+        };
+        const pendingNativePermissions = async () => {
+            const value = await http.json("/permission");
+            if (!Array.isArray(value))
+                protocol("OpenCode returned malformed native permission data.");
+            const result = new Set();
+            for (const item of value) {
+                const id = string(record(item).id);
+                if (!id)
+                    protocol("OpenCode returned malformed native permission data.");
+                result.add(id);
+            }
+            return result;
+        };
+        const reconcilePermissions = async () => {
+            const nativePending = await pendingNativePermissions();
+            for (const id of [...pendingApprovals]) {
+                if (nativePending.has(id))
+                    continue;
+                pendingApprovals.delete(id);
+                approvals.withdraw(id);
+            }
+        };
+        const replyPermission = async (id, decision) => {
+            const nativePending = await pendingNativePermissions();
+            if (!nativePending.has(id)) {
+                pendingApprovals.delete(id);
+                approvals.withdraw(id);
+                return;
+            }
+            await http.json(`/permission/${encodeURIComponent(id)}/reply`, { body: { reply: decision } });
+            pendingApprovals.delete(id);
+            approvals.withdraw(id);
+            if (decision === "reject")
+                await reconcilePermissions();
+        };
+        const handlePermission = (input) => {
+            const task = (async () => {
+                const request = record(input);
+                const id = string(request.id);
+                const nativeSession = string(request.sessionID);
+                const permission = string(request.permission);
+                if (!id || !nativeSession || !permission || !strings(request.patterns) || !strings(request.always)
+                    || !record(request.metadata, true)) {
+                    fail(new AgentError("INPUT_REQUIRED", "OpenCode returned an unsupported native permission request."));
+                    return;
+                }
+                const current = active;
+                if (!current) {
+                    fatalEventError ??= new AgentError("INPUT_REQUIRED", "OpenCode requested permission during startup.");
+                    await http.json(`/permission/${encodeURIComponent(id)}/reply`, { body: { reply: "reject" } }).catch(() => { });
+                    return;
+                }
+                if (!options.onApproval) {
+                    fail(new AgentError("INPUT_REQUIRED", "OpenCode requested permission but no approval handler is available."));
+                    await replyPermission(id, "reject").catch(() => { });
+                    return;
+                }
+                const context = {
+                    permission,
+                    patterns: [...request.patterns],
+                    metadata: request.metadata,
+                    always: [...request.always],
+                    ...(request.tool === undefined ? {} : { tool: request.tool }),
+                };
+                const approval = {
+                    kind: "permission",
+                    harness: "opencode",
+                    message: permissionMessage(permission, request.patterns),
+                    requestedSchema: {
+                        type: "object",
+                        properties: {
+                            decision: { type: "string", oneOf: [
+                                    { const: "once", title: "Allow once" },
+                                    { const: "reject", title: "Deny" },
+                                ] },
+                        },
+                        required: ["decision"],
+                        additionalProperties: false,
+                    },
+                    context,
+                };
+                pendingApprovals.add(id);
+                try {
+                    const answer = await approvals.request(id, approval, options.onApproval, current.lifecycle.signal);
+                    if (answer.decision !== "once" && answer.decision !== "reject") {
+                        throw new AgentError("INVALID_APPROVAL_RESPONSE", "The approval response does not match the requested schema.");
+                    }
+                    await replyPermission(id, answer.decision);
+                }
+                catch (error) {
+                    if (error instanceof AgentError && error.code === "REQUEST_EXPIRED")
+                        return;
+                    const safe = error instanceof AgentError
+                        ? error
+                        : new AgentError("INPUT_REQUIRED", "The OpenCode permission response could not be completed.");
+                    fail(safe);
+                    await replyPermission(id, "reject").catch(() => { });
+                }
+                finally {
+                    pendingApprovals.delete(id);
+                }
+            })();
+            approvalTasks.add(task);
+            void task.then(() => approvalTasks.delete(task), error => {
+                approvalTasks.delete(task);
+                fail(error instanceof AgentError ? error : new AgentError("PROTOCOL_ERROR", "OpenCode returned malformed native permission data."));
+            });
+        };
+        const handleEvent = (value) => {
+            const event = record(value);
+            if (event.type === "permission.asked") {
+                handlePermission(event.properties);
+                return;
+            }
+            if (event.type === "permission.replied") {
+                const properties = record(event.properties);
+                const id = string(properties.requestID);
+                if (!id) {
+                    fail(new AgentError("PROTOCOL_ERROR", "OpenCode returned malformed native permission settlement data."));
+                    return;
+                }
+                pendingApprovals.delete(id);
+                approvals.withdraw(id);
+                if (properties.reply === "reject")
+                    void reconcilePermissions().catch(() => { });
+                return;
+            }
+            if (event.type === "question.asked") {
+                fail(new AgentError("INPUT_REQUIRED", "OpenCode requested unsupported interactive input."));
+                return;
+            }
+            if (event.type === "session.error") {
+                const properties = record(event.properties);
+                if (properties.sessionID === undefined || properties.sessionID === sessionID) {
+                    fail(new AgentError("HARNESS_ERROR", "OpenCode reported a native execution error."));
+                }
+            }
+        };
+        eventController = new AbortController();
+        let eventReady;
+        const eventEstablished = new Promise(resolveReady => { eventReady = resolveReady; });
+        const eventTask = http.events(eventController.signal, handleEvent, eventReady).catch(error => {
+            if (!eventController.signal.aborted)
+                fail(error instanceof AgentError ? error : new AgentError("PROTOCOL_ERROR", "The OpenCode native event stream failed."));
+        });
+        await Promise.race([
+            eventEstablished,
+            eventTask.then(() => { throw fatalEventError ?? new AgentError("PROTOCOL_ERROR", "OpenCode could not establish its native event stream."); }),
+        ]);
+        if (fatalEventError)
+            throw fatalEventError;
+        if (tools.descriptor) {
+            const added = record(await http.json("/mcp", { body: tools.descriptor }));
+            if (record(added[tools.descriptor.name], true)?.status !== "connected") {
+                throw new AgentError("HARNESS_UNAVAILABLE", "OpenCode could not connect the private MCP tool endpoint.");
+            }
+            const status = record(await http.json("/mcp"));
+            if (record(status[tools.descriptor.name], true)?.status !== "connected") {
+                throw new AgentError("HARNESS_UNAVAILABLE", "OpenCode did not retain the private MCP tool connection.");
+            }
+        }
+        const created = record(await http.json("/session", { body: { title: "Subharness", model: { providerID: route.providerID, id: route.modelID } } }));
+        sessionID = string(created.id);
+        if (!sessionID || !samePath(string(created.directory), cwd)
+            || !selection(created.model, "id", route))
+            protocol("OpenCode returned malformed native session data.");
+        if (fatalEventError)
+            throw fatalEventError;
+        tools.onFailure(fail);
+        const session = {
+            async turn(prompt) {
+                if (closed)
+                    throw new AgentError("SESSION_CLOSED", "The OpenCode session has closed.");
+                if (fatalEventError)
+                    throw fatalEventError;
+                if (active)
+                    throw new AgentError("SESSION_BUSY", "OpenCode already has an active turn.");
+                const includeInstructions = first && Boolean(options.agent.instructions);
+                const current = {
+                    completion: undefined,
+                    lifecycle: new AbortController(),
+                    interrupted: false,
+                    closing: false,
+                    settled: false,
+                };
+                active = current;
+                current.completion = (async () => {
+                    tools.beginTurn();
+                    try {
+                        const response = await http.json(`/session/${encodeURIComponent(sessionID)}/message`, {
+                            timeout: false,
+                            body: {
+                                model: { providerID: route.providerID, modelID: route.modelID },
+                                parts: [{ type: "text", text: prompt }],
+                                ...(includeInstructions ? { system: options.agent.instructions } : {}),
+                            },
+                        });
+                        first = false;
+                        if (current.closing)
+                            throw new AgentError("SESSION_CLOSED", "The OpenCode session closed during the turn.");
+                        if (current.interrupted)
+                            throw new AgentError("INTERRUPTED", "The OpenCode turn was interrupted.");
+                        if (current.failure)
+                            throw current.failure;
+                        return terminalText(response, sessionID, route);
+                    }
+                    catch (error) {
+                        if (current.closing)
+                            throw new AgentError("SESSION_CLOSED", "The OpenCode session closed during the turn.");
+                        if (current.interrupted)
+                            throw new AgentError("INTERRUPTED", "The OpenCode turn was interrupted.");
+                        if (current.failure)
+                            throw current.failure;
+                        if (error instanceof AgentError)
+                            throw error;
+                        throw new AgentError("HARNESS_ERROR", "OpenCode could not complete the native turn.");
+                    }
+                    finally {
+                        current.settled = true;
+                        current.lifecycle.abort();
+                        approvals.clear();
+                        tools.stopAdmission();
+                        await Promise.allSettled([...approvalTasks]);
+                        await tools.drain();
+                        if (active === current)
+                            active = undefined;
+                    }
+                })();
+                return await current.completion;
+            },
+            async steer() { throw new AgentError("UNSUPPORTED_DELIVERY", "OpenCode does not expose verified active steering."); },
+            async interrupt() {
+                const current = active;
+                if (!current)
+                    return;
+                current.interrupted = true;
+                current.lifecycle.abort();
+                approvals.clear();
+                tools.stopAdmission();
+                try {
+                    const admitted = await bounded(waitForAdmission(http, sessionID, current), 5_000);
+                    if (admitted) {
+                        const acknowledged = await http.json(`/session/${encodeURIComponent(sessionID)}/abort`, { method: "POST", timeout: 2_000 });
+                        if (acknowledged !== true)
+                            throw new Error();
+                    }
+                    await bounded(waitForNativeStop(http, sessionID, current), 5_000);
+                }
+                catch {
+                    throw new AgentError("CANCELLATION_FAILED", "OpenCode did not confirm native cancellation.");
+                }
+                await current.completion.catch(() => { });
+            },
+            async resume() { throw new AgentError("RECOVERY_UNSUPPORTED", "OpenCode cannot retry failed execution without replaying input."); },
+            async close() {
+                if (closing)
+                    return await closing;
+                closed = true;
+                closing = (async () => {
+                    const current = active;
+                    if (current) {
+                        current.closing = true;
+                        current.lifecycle.abort();
+                    }
+                    approvals.clear();
+                    tools.stopAdmission();
+                    try {
+                        const admitted = current ? await bounded(waitForAdmission(http, sessionID, current), 1_000).catch(() => false) : false;
+                        if (current && admitted)
+                            await http.json(`/session/${encodeURIComponent(sessionID)}/abort`, { method: "POST", timeout: 1_000 }).catch(() => { });
+                        if (current)
+                            await bounded(current.completion.catch(() => { }), 5_000).catch(() => { });
+                        eventController.abort();
+                        if (sessionID)
+                            await http.json(`/session/${encodeURIComponent(sessionID)}`, { method: "DELETE", timeout: 1_000 }).catch(() => { });
+                    }
+                    finally {
+                        const cleanupFailures = [];
+                        for (const cleanup of [
+                            () => native.close(),
+                            async () => { await eventTask; },
+                            () => tools.close(),
+                            () => runtime.close(),
+                        ]) {
+                            try {
+                                await cleanup();
+                            }
+                            catch (error) {
+                                cleanupFailures.push(error);
+                            }
+                        }
+                        if (cleanupFailures.length > 0)
+                            throw cleanupFailures[0];
+                    }
+                })();
+                return await closing;
+            },
+        };
+        return session;
+    }
+    catch (error) {
+        eventController?.abort();
+        if (sessionID && native) {
+            const http = new OpencodeHttp(native.url, cwd, password);
+            await http.json(`/session/${encodeURIComponent(sessionID)}`, { method: "DELETE", timeout: 1_000 }).catch(() => { });
+        }
+        await native?.close().catch(() => { });
+        await tools.close().catch(() => { });
+        await runtime.close().catch(() => { });
+        throw error;
+    }
+}
+async function verifyStartup(http, expected, options, route) {
+    const health = record(await http.json("/global/health"));
+    if (health.healthy !== true || typeof health.version !== "string")
+        protocol("OpenCode returned malformed native health data.");
+    if (health.version !== supportedOpencodeVersion) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode native server version does not match the verified isolated execution profile.");
+    }
+    const config = record(await http.json("/config"));
+    const configuredProviders = record(config.provider, true) ?? {};
+    if (!onlyString(config.enabled_providers, route.providerID) || config.model !== expected.model || config.small_model !== expected.small_model
+        || config.share !== "disabled" || config.autoupdate !== false || !Array.isArray(config.plugin) || config.plugin.length !== 0
+        || config.lsp !== false || config.formatter !== false
+        || !sameOptionalStrings(config.instructions, expected.instructions)
+        || !onlyKey(record(config.permission), "*", "ask")
+        || config.permission?.["*"] !== "ask") {
+        throw new AgentError("INVALID_CONFIG", "OpenCode did not apply the isolated native configuration.");
+    }
+    if (route.kind === "subscription") {
+        if (Object.hasOwn(configuredProviders, route.providerID) || Object.keys(configuredProviders).length !== 0) {
+            throw new AgentError("INVALID_CONFIG", "OpenCode loaded provider configuration that conflicts with native subscription access.");
+        }
+    }
+    else {
+        const providerConfig = record(configuredProviders[route.providerID]);
+        const providerOptions = record(providerConfig.options);
+        const expectedOptionKeys = route.kind === "gateway"
+            ? options.access.type === "vercel-api-key" ? ["apiKey", "baseURL"] : ["baseURL"]
+            : route.baseUrl === undefined ? ["apiKey"] : ["apiKey", "baseURL"];
+        const expectedKey = options.access.type === "vercel-api-key" || options.access.type === "api-key" ? options.access.token : undefined;
+        if (Object.keys(configuredProviders).length !== 1 || providerConfig.npm !== route.configPackage
+            || !Array.isArray(providerConfig.env) || providerConfig.env.length !== 0
+            || providerOptions.apiKey !== expectedKey
+            || (route.kind === "gateway" ? providerOptions.baseURL !== gatewayBaseUrl : providerOptions.baseURL !== route.baseUrl)
+            || !sameStrings(Object.keys(providerOptions).sort(), expectedOptionKeys)) {
+            throw new AgentError("INVALID_CONFIG", "OpenCode did not retain the selected explicit provider configuration.");
+        }
+    }
+    for (const field of ["agent", "mode", "command", "tools"]) {
+        if (record(config[field], true) && Object.keys(config[field]).length > 0) {
+            throw new AgentError("INVALID_CONFIG", "OpenCode loaded excluded native configuration.");
+        }
+    }
+    if (record(config.mcp, true) && Object.keys(config.mcp).length > 0)
+        throw new AgentError("INVALID_CONFIG", "OpenCode loaded an unexpected native MCP configuration.");
+    const providers = record(await http.json("/provider"));
+    if (!Array.isArray(providers.connected) || !providers.connected.every((value) => typeof value === "string") || !Array.isArray(providers.all)) {
+        protocol("OpenCode returned malformed native provider data.");
+    }
+    if (route.kind === "subscription" && providers.all.length === 0 && providers.connected.length === 0) {
+        const defaults = record(providers.default);
+        if (Object.keys(defaults).length !== 0)
+            throw new AgentError("INVALID_CONFIG", "OpenCode returned conflicting native subscription defaults.");
+        throw new AgentError("ACCESS_UNAVAILABLE", "The selected OpenCode native subscription login is unavailable.");
+    }
+    if (providers.all.length !== 1 || record(providers.all[0]).id !== route.providerID) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode enabled an unexpected native provider.");
+    }
+    const selectedProvider = providers.all.find((value) => record(value, true)?.id === route.providerID);
+    if (!selectedProvider)
+        throw new AgentError("INVALID_CONFIG", "OpenCode did not enable the selected native provider.");
+    const provider = record(selectedProvider);
+    const providerOptions = record(provider.options);
+    if (route.kind !== "subscription" && (provider.source !== "config"
+        || providerOptions.apiKey !== (options.access.type === "vercel-oidc" ? undefined : options.access.token))) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode selected an incompatible explicit provider route.");
+    }
+    if (route.kind === "gateway" && providerOptions.baseURL !== gatewayBaseUrl) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode selected an incompatible Gateway endpoint.");
+    }
+    if (route.kind === "direct" && route.baseUrl !== undefined && providerOptions.baseURL !== route.baseUrl) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode did not retain the selected direct provider endpoint override.");
+    }
+    const selectedModel = record(record(provider.models)[route.modelID], true);
+    if (!selectedModel)
+        throw new AgentError("INVALID_CONFIG", "The selected model is absent from OpenCode's native catalog.");
+    const api = record(selectedModel.api);
+    const apiID = string(api.id);
+    if (selectedModel.id !== route.modelID || selectedModel.providerID !== route.providerID || !apiID) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode selected incompatible native model metadata.");
+    }
+    if (route.kind === "gateway" && apiID !== route.modelID)
+        throw new AgentError("INVALID_CONFIG", "OpenCode changed the selected Gateway model route.");
+    if (!record(selectedModel.capabilities, true) || !record(selectedModel.limit, true)) {
+        throw new AgentError("INVALID_CONFIG", "The selected model has incomplete native metadata.");
+    }
+    if (route.kind === "subscription") {
+        if (providers.connected.length === 0) {
+            const defaults = record(providers.default);
+            const defaultModel = string(defaults[route.providerID]);
+            if (provider.source === "custom" && Object.keys(providerOptions).length === 0
+                && Object.keys(defaults).length === 1 && defaultModel
+                && route.unavailablePackages?.includes(api.npm)) {
+                throw new AgentError("ACCESS_UNAVAILABLE", "The selected OpenCode native subscription login is unavailable.");
+            }
+            throw new AgentError("INVALID_CONFIG", "OpenCode returned conflicting native subscription state.");
+        }
+        if (!onlyString(providers.connected, route.providerID))
+            throw new AgentError("INVALID_CONFIG", "OpenCode returned ambiguous native subscription state.");
+        if (provider.source !== "custom" || providerOptions.apiKey !== route.oauthMarker || !route.packages.includes(api.npm)) {
+            throw new AgentError("INVALID_CONFIG", "OpenCode could not verify the selected native OAuth subscription route.");
+        }
+    }
+    else if (!onlyString(providers.connected, route.providerID)) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode did not retain the selected explicit provider route.");
+    }
+    else if (!route.packages.includes(api.npm)) {
+        throw new AgentError("INVALID_CONFIG", "OpenCode selected incompatible native model metadata.");
+    }
+    const agents = await http.json("/agent");
+    if (!Array.isArray(agents))
+        protocol("OpenCode returned malformed native agent data.");
+    for (const agent of agents) {
+        const entry = record(agent);
+        if (entry.model !== undefined && !selection(entry.model, "modelID", route)) {
+            throw new AgentError("INVALID_CONFIG", "OpenCode loaded a native agent with a conflicting model override.");
+        }
+    }
+}
+function terminalText(value, sessionID, route) {
+    const response = record(value);
+    const info = record(response.info);
+    if (info.role !== "assistant" || info.sessionID !== sessionID || typeof info.time?.completed !== "number" || typeof info.finish !== "string" || !Array.isArray(response.parts)) {
+        protocol("OpenCode returned malformed or unfinished terminal data.");
+    }
+    if (info.providerID !== route.providerID || info.modelID !== route.modelID)
+        throw new AgentError("INVALID_CONFIG", "OpenCode changed the requested provider or model during execution.");
+    if (info.error !== undefined)
+        throw new AgentError("HARNESS_ERROR", "OpenCode reported a native execution error.");
+    const text = response.parts.filter((part) => record(part, true)?.type === "text").map((part) => {
+        if (typeof part.text !== "string")
+            protocol("OpenCode returned malformed terminal text.");
+        return part.text;
+    }).join("");
+    if (Buffer.byteLength(text, "utf8") > 1024 * 1024)
+        throw new AgentError("RESPONSE_TOO_LARGE", "The OpenCode response exceeds 1 MiB.");
+    return text;
+}
+function record(value, optional = false) {
+    if (value && typeof value === "object" && !Array.isArray(value))
+        return value;
+    if (optional && value === undefined)
+        return undefined;
+    protocol("OpenCode returned malformed native protocol data.");
+}
+function string(value) { return typeof value === "string" && value.length > 0 ? value : undefined; }
+function strings(value) {
+    return Array.isArray(value) && value.every(item => typeof item === "string") && new Set(value).size === value.length;
+}
+function onlyString(value, expected) { return Array.isArray(value) && value.length === 1 && value[0] === expected; }
+function sameStrings(left, right) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length
+        && left.every((value, index) => typeof value === "string" && value === right[index]);
+}
+function sameOptionalStrings(left, right) {
+    return left === undefined && right === undefined || sameStrings(left, right);
+}
+function onlyKey(value, key, expected) {
+    return Object.keys(value).length === 1 && value[key] === expected;
+}
+function selection(value, modelField, route) {
+    const selected = record(value, true);
+    return Boolean(selected && selected.providerID === route.providerID && selected[modelField] === route.modelID);
+}
+function samePath(left, right) { return left !== undefined && resolve(left) === resolve(right); }
+function permissionMessage(permission, patterns) {
+    const details = patterns.length === 0 ? "" : ` for ${patterns.join(", ")}`;
+    const message = `Allow OpenCode ${permission}${details}?`;
+    return message.length <= 4_096 ? message : `Allow OpenCode ${permission}?`;
+}
+async function waitForNativeStop(http, sessionID, current) {
+    for (;;) {
+        const statuses = record(await http.json("/session/status"));
+        const status = record(statuses[sessionID], true);
+        if (status === undefined && current.settled)
+            return;
+        await new Promise(resolveDelay => setTimeout(resolveDelay, 25));
+    }
+}
+async function waitForAdmission(http, sessionID, current) {
+    for (;;) {
+        if (current.settled)
+            return false;
+        const statuses = record(await http.json("/session/status"));
+        const status = record(statuses[sessionID], true);
+        if (status?.type === "busy" || status?.type === "retry")
+            return true;
+        await new Promise(resolveDelay => setTimeout(resolveDelay, 10));
+    }
+}
+async function bounded(promise, milliseconds) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new AgentError("CANCELLATION_FAILED", "OpenCode did not reach a native terminal outcome.")), milliseconds);
+        timer.unref();
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function protocol(message) { throw new AgentError("PROTOCOL_ERROR", message); }
+//# sourceMappingURL=opencode.js.map