@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/agents/providers/codex-app-server/registration.js

@@ -0,0 +1,248 @@
+import * as path from "node:path";
+import { z } from "zod";
+import { executableSchema, isConfigKeyForbidden, providerCommonFields, providerEnvSchema, structuredTomlValueSchema, writableRootItemSchema, } from "../../../config/settings/provider-instance-fields.js";
+import { exactKeys, optionalJsonObject, optionalString, optionalStringRecord, parseAbsoluteRootList, snapshotError, } from "../../launch-snapshot/parse-helpers.js";
+import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
+import { FlowError } from "../../../flow-error.js";
+import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
+import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
+import { codexAppServerSessionSchema } from "./session-schema.js";
+const startCodexAppServer = async (prompt, cwd, options) => {
+    const { startCodexAppServer: start } = await import("./adapter.js");
+    return start(prompt, cwd, options);
+};
+const ACCESS_VALUES = new Set(["write"]);
+const NETWORK_VALUES = new Set(["disabled", "enabled"]);
+function admitResumeShape(schema, session, resumePath) {
+    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
+    if (!envelopeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
+    }
+    if (session.provider !== CODEX_APP_SERVER_PROVIDER) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${CODEX_APP_SERVER_PROVIDER}'. Cross-provider resume is not supported.`);
+    }
+    if (session.version !== SUBAGENT_SESSION_VERSION) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
+    }
+    const shapeResult = schema.safeParse(session.handle);
+    if (!shapeResult.success) {
+        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
+    }
+    return shapeResult.data;
+}
+function parseSandboxPolicy(value) {
+    const sandbox = value;
+    if (sandbox === null || typeof sandbox !== "object" || Array.isArray(sandbox)) {
+        throw snapshotError("provider.sandboxPolicy", "must be a plain JSON object");
+    }
+    const record = sandbox;
+    exactKeys(record, ["type", "writableRoots", "networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"], "provider.sandboxPolicy");
+    if (record.type !== "workspaceWrite")
+        throw snapshotError("provider.sandboxPolicy.type", "must equal 'workspaceWrite'");
+    const roots = parseAbsoluteRootList(record.writableRoots, "provider.sandboxPolicy.writableRoots");
+    for (const key of ["networkAccess", "excludeTmpdirEnvVar", "excludeSlashTmp"]) {
+        if (typeof record[key] !== "boolean")
+            throw snapshotError(`provider.sandboxPolicy.${key}`, "must be a boolean");
+    }
+    return Object.freeze({
+        type: "workspaceWrite",
+        writableRoots: roots,
+        networkAccess: record.networkAccess,
+        excludeTmpdirEnvVar: record.excludeTmpdirEnvVar,
+        excludeSlashTmp: record.excludeSlashTmp,
+    });
+}
+export const codexAppServerRegistration = {
+    name: CODEX_APP_SERVER_PROVIDER,
+    start: startCodexAppServer,
+    sessionSchema: codexAppServerSessionSchema,
+    rejectsGlobalWritableRoots: true,
+    effortField: "effort",
+    instanceSchema: z
+        .object({
+        kind: z.literal(CODEX_APP_SERVER_PROVIDER),
+        ...providerCommonFields,
+        executable: executableSchema.optional(),
+        profile: z.string().optional(),
+        config: structuredTomlValueSchema.optional(),
+        writableRoots: z.array(writableRootItemSchema).optional(),
+        env: providerEnvSchema,
+    })
+        .strict()
+        .superRefine((data, ctx) => {
+        if (data.config) {
+            for (const key of Object.keys(data.config)) {
+                if (isConfigKeyForbidden(key)) {
+                    ctx.addIssue({
+                        code: z.ZodIssueCode.custom,
+                        path: ["config", key],
+                        message: `"${key}" is owned by the Akuma or Keiyaku execution, not this provider instance`,
+                    });
+                }
+            }
+        }
+    }),
+    builtinInstance: {
+        name: CODEX_APP_SERVER_PROVIDER,
+        source: "builtin",
+        instance: { kind: CODEX_APP_SERVER_PROVIDER, executable: "codex" },
+    },
+    builtinAkumaProfiles: [
+        { name: "akuma-codex", description: "Default Codex app-server Akuma." },
+    ],
+    portablePolicy: {
+        access: new Set(ACCESS_VALUES),
+        network: new Set(NETWORK_VALUES),
+        webSearch: new Set(),
+    },
+    maxCaptureChars: (config) => config.codex.execMaxCaptureChars,
+    buildCallTerms: ({ snapshot, baseTerms }) => {
+        const provider = snapshot.provider;
+        return {
+            ...baseTerms,
+            provider: CODEX_APP_SERVER_PROVIDER,
+            ...(provider.model !== undefined ? { model: provider.model } : {}),
+            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
+            ...(provider.profile !== undefined ? { profile: provider.profile } : {}),
+            ...(provider.config !== undefined ? { config: provider.config } : {}),
+            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
+            ...(provider.sandboxPolicy !== undefined
+                ? { sandboxPolicy: provider.sandboxPolicy }
+                : {}),
+            ...(provider.approvalPolicy !== undefined ? { approvalPolicy: provider.approvalPolicy } : {}),
+            ...(provider.env !== undefined ? { env: provider.env } : {}),
+            developerInstructions: snapshot.akuma.body || undefined,
+            onCheckpoint() { },
+        };
+    },
+    resolveLaunchProvider: ({ common, instance, model, effort, executionCwd, projectRoot, network, }) => {
+        if (instance.kind !== CODEX_APP_SERVER_PROVIDER) {
+            throw new Error(`resolveLaunchProvider expected ${CODEX_APP_SERVER_PROVIDER}`);
+        }
+        const codexInstance = instance;
+        const roots = [
+            path.resolve(executionCwd),
+            ...(codexInstance.writableRoots ?? []).map((root) => path.resolve(projectRoot, root)),
+        ];
+        const writableRoots = [...new Set(roots)];
+        return Object.freeze({
+            ...common,
+            kind: CODEX_APP_SERVER_PROVIDER,
+            ...(codexInstance.executable !== undefined ? { executable: codexInstance.executable } : {}),
+            ...(codexInstance.profile !== undefined ? { profile: codexInstance.profile } : {}),
+            ...(codexInstance.config !== undefined ? { config: codexInstance.config } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(!configOwnsSandboxPolicy(codexInstance.config)
+                ? {
+                    sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({
+                        writableRoots,
+                        networkAccess: network === "enabled",
+                    }),
+                }
+                : {}),
+            ...(!configOwnsApprovalPolicy(codexInstance.config) ? { approvalPolicy: "never" } : {}),
+            ...(codexInstance.env !== undefined ? { env: codexInstance.env } : {}),
+        });
+    },
+    parseLaunchProvider: (provider, common) => {
+        exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "model", "effort", "sandboxPolicy", "approvalPolicy", "env"], "provider");
+        if ("approvalPolicy" in provider && provider.approvalPolicy !== "never") {
+            throw snapshotError("provider.approvalPolicy", "must equal 'never'");
+        }
+        const executable = optionalString(provider, "executable", "provider");
+        const profile = optionalString(provider, "profile", "provider");
+        const config = optionalJsonObject(provider, "config");
+        const model = optionalString(provider, "model", "provider");
+        const effort = optionalString(provider, "effort", "provider");
+        const sandboxPolicy = "sandboxPolicy" in provider ? parseSandboxPolicy(provider.sandboxPolicy) : undefined;
+        const env = optionalStringRecord(provider, "env");
+        return Object.freeze({
+            ...common,
+            kind: CODEX_APP_SERVER_PROVIDER,
+            ...(executable !== undefined ? { executable } : {}),
+            ...(profile !== undefined ? { profile } : {}),
+            ...(config !== undefined ? { config } : {}),
+            ...(model !== undefined ? { model } : {}),
+            ...(effort !== undefined ? { effort } : {}),
+            ...(sandboxPolicy !== undefined ? { sandboxPolicy } : {}),
+            ...(provider.approvalPolicy === "never" ? { approvalPolicy: "never" } : {}),
+            ...(env !== undefined ? { env } : {}),
+        });
+    },
+    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
+    providerEffortAndModel: (provider) => {
+        const resolved = provider;
+        return { model: resolved.model, effort: resolved.effort };
+    },
+    attachLoader: (terms) => terms,
+    nativePolicyOwnership: (instanceName, instance) => {
+        if (instance.kind !== CODEX_APP_SERVER_PROVIDER)
+            return null;
+        const config = instance.config;
+        if (!config) {
+            return Object.freeze({
+                access: Object.freeze([]),
+                network: Object.freeze([]),
+                webSearch: Object.freeze([]),
+            });
+        }
+        const access = [];
+        const network = [];
+        const webSearch = [];
+        const owns = (key) => Object.prototype.hasOwnProperty.call(config, key);
+        const add = (target, key) => {
+            target.push({ path: `providers.${instanceName}.config.${key}`, value: config[key] });
+        };
+        if (owns("sandbox_mode"))
+            add(access, "sandbox_mode");
+        if (owns("approval_policy"))
+            add(access, "approval_policy");
+        for (const key of Object.keys(config)) {
+            if (key !== "sandbox_workspace_write" && !key.startsWith("sandbox_workspace_write."))
+                continue;
+            add(access, key);
+            add(network, key);
+        }
+        if (owns("web_search"))
+            add(webSearch, "web_search");
+        return Object.freeze({
+            access: Object.freeze(access),
+            network: Object.freeze(network),
+            webSearch: Object.freeze(webSearch),
+        });
+    },
+    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onIngress, }) => {
+        if (terms.provider !== CODEX_APP_SERVER_PROVIDER) {
+            throw new Error(`startLive expected ${CODEX_APP_SERVER_PROVIDER}`);
+        }
+        const codexTerms = terms;
+        const options = {
+            model: codexTerms.model,
+            effort: codexTerms.effort,
+            profile: codexTerms.profile,
+            config: codexTerms.config,
+            sandboxPolicy: codexTerms.sandboxPolicy,
+            approvalPolicy: codexTerms.approvalPolicy,
+            executable: codexTerms.executable,
+            env: codexTerms.env,
+            signal,
+            developerInstructions: codexTerms.developerInstructions,
+            onSyncCheckpoint,
+            onDeliveryOpportunity,
+            onEvidence: codexTerms.onEvidence,
+            onIngress,
+            initialTurn: codexTerms.initialTurn,
+        };
+        const { startCodexAppServer: start } = await import("./adapter.js");
+        if (reviveTerms) {
+            const session = admitResumeShape(codexAppServerSessionSchema, reviveTerms.session, reviveTerms.resumePath);
+            return start(codexTerms.prompt, codexTerms.workdir, {
+                ...options,
+                threadId: session.threadId,
+                codexHome: session.codexHome,
+            });
+        }
+        return start(codexTerms.prompt, codexTerms.workdir, options);
+    },
+};

package/build/agents/providers/codex-app-server/session-schema.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+/** Session handle for codex-app-server: thread id plus optional CODEX_HOME for cross-process resume. */
+export const codexAppServerSessionSchema = z.object({
+    threadId: z.string().trim().min(1),
+    codexHome: z.string().trim().min(1).optional(),
+});

package/build/agents/providers/codex-app-server/session.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
 import { coerceString } from "../../harness/runtime.js";
-const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 export class CodexAppServerProcess {
     onEvidence;
     onEvidenceDiagnostic;
@@ -243,24 +243,30 @@ export class CodexAppServerProcess {
                 // Graceful cleanup is best-effort.
             }
         }
-        const forceKill = new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                if (!this.exitSettled) {
-                    try {
-                        this.child.kill("SIGKILL");
-                    }
-                    catch {
-                        // Graceful escalation is best-effort.
-                    }
+        const forceKill = setTimeout(() => {
+            if (!this.exitSettled) {
+                try {
+                    this.child.kill("SIGKILL");
                 }
-                resolve();
-            }, 1000);
-            timer.unref?.();
-        });
-        const hardBound = new Promise((resolve) => {
-            const timer = setTimeout(resolve, 2000);
+                catch {
+                    // The hard bound below reports the missing exit proof.
+                }
+            }
+        }, 1000);
+        forceKill.unref?.();
+        let hardBoundTimer;
+        const hardBound = new Promise((_, reject) => {
+            hardBoundTimer = setTimeout(() => reject(new Error(`${CODEX_APP_SERVER_PROVIDER} process exit was not observed`)), 2000);
+            const timer = hardBoundTimer;
             timer.unref?.();
         });
-        await Promise.race([this.exitPromise, Promise.all([forceKill, this.exitPromise]).then(() => undefined), hardBound]);
+        try {
+            await Promise.race([this.exitPromise, hardBound]);
+        }
+        finally {
+            clearTimeout(forceKill);
+            if (hardBoundTimer)
+                clearTimeout(hardBoundTimer);
+        }
     }
 }

package/build/agents/providers/codex-app-server/terms.js

@@ -0,0 +1 @@
+export {};

package/build/agents/providers/opencode-sdk/adapter.js

@@ -1,13 +1,13 @@
-import { z } from "zod";
 import { FlowError } from "../../../flow-error.js";
 import { appendDebugBlock, appendDebugLog } from "../../../telemetry/debug-log.js";
 import { SUBAGENT_SESSION_VERSION } from "../../session.js";
 import { createProjectionDriver } from "../../harness/execution-handle.js";
-import { buildSubagentEnv, coerceString, emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
+import { awaitProviderAbortSettlement, buildSubagentEnv, coerceString, createAbortError, emitProviderEvidence, sha256Utf8, } from "../../harness/runtime.js";
 import { renderEventTypeSummary } from "../event-type-tail.js";
 import { createOpencodeEventController } from "./events.js";
-import { OPENCODE_DEFAULT_EXECUTABLE, OPENCODE_SDK_PROVIDER, OpencodeIdleMonitor, loadOpencodeSdk, sessionIdFrom, withAbort, setOpencodeSdkLoaderForTests as setLoader, resetOpencodeSdkLoaderForTests as resetLoader, } from "./session.js";
-export const opencodeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });
+import { OPENCODE_DEFAULT_EXECUTABLE, OPENCODE_SDK_PROVIDER, OpencodeIdleMonitor, loadOpencodeSdk, sessionIdFrom, withAbort, } from "./session.js";
+export { opencodeSessionSchema } from "./session-schema.js";
 export function parseOpencodeModelRef(model, effort) {
     const trimmed = model.trim();
     const slash = trimmed.indexOf("/");
@@ -20,11 +20,12 @@ export function parseOpencodeModelRef(model, effort) {
         ...(effort !== undefined ? { variant: effort } : {}),
     };
 }
-export function setOpencodeSdkLoaderForTests(loader) {
-    setLoader(loader);
-}
-export function resetOpencodeSdkLoaderForTests() {
-    resetLoader();
+export async function settleOpencodeGracefulInterrupt(input) {
+    await input.interrupt();
+    await input.waitForIdle();
+    input.stopStream();
+    await input.waitForStream();
+    await input.drainHistory();
 }
 export async function startOpencode(prompt, cwd, options = {}) {
     const sessionId = options.sessionId?.trim();
@@ -42,6 +43,9 @@ export async function startOpencode(prompt, cwd, options = {}) {
     let enqueueFailure;
     let acceptingEnqueue = true;
     let builderRef;
+    let streamTask;
+    let gracefulInterruptRequested = false;
+    let gracefulProviderSettlement;
     let resolveRunSettled;
     let rejectRunSettled;
     const runSettled = new Promise((resolve, reject) => {
@@ -50,12 +54,17 @@ export async function startOpencode(prompt, cwd, options = {}) {
     });
     runSettled.catch(() => undefined);
     let eventController;
-    const asProviderError = (error) => error instanceof Error ? error : new Error(String(error));
+    const asProviderError = (error) => error instanceof Error ? error : createProviderFailure(String(error));
     const rememberEnqueueFailure = (error) => {
         const failure = asProviderError(error);
         enqueueFailure ??= failure;
         return failure;
     };
+    const activeExecutionSignal = () => {
+        if (!executionSignal)
+            throw new Error(`${OPENCODE_SDK_PROVIDER} cannot continue: no active execution signal`);
+        return executionSignal;
+    };
     const promptSteer = async (client, text, tellId) => {
         if (options.onEvidence) {
             emitProviderEvidence(options.onEvidence, {
@@ -66,13 +75,16 @@ export async function startOpencode(prompt, cwd, options = {}) {
                 ...sha256Utf8(text),
             }, (textDiagnostic) => builderRef?.emit({ type: "diagnostic", text: textDiagnostic }));
         }
-        const receipt = await client.v2.session.prompt({
+        const signal = activeExecutionSignal();
+        const receipt = await withAbort(client.v2.session.prompt({
             sessionID: activeSessionId,
             // OpenCode documents no client-id idempotence; omit it and retain the
             // at-least-once retry window until such a contract exists.
             prompt: { text },
             delivery: "steer",
-        }, { throwOnError: true, signal: executionSignal });
+            // V2 only schedules an admitted input for execution when resumed.
+            resume: true,
+        }, { throwOnError: true, signal }), signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
         const admitted = receipt.data.data;
         const ordinal = admitted.admittedSeq;
         if (options.onEvidence) {
@@ -93,7 +105,8 @@ export async function startOpencode(prompt, cwd, options = {}) {
     const applyBaseModel = async (client) => {
         if (!baseModelRef)
             return;
-        await client.v2.session.switchModel({ sessionID: activeSessionId, model: baseModelRef }, { throwOnError: true, signal: executionSignal });
+        const signal = activeExecutionSignal();
+        await withAbort(client.v2.session.switchModel({ sessionID: activeSessionId, model: baseModelRef }, { throwOnError: true, signal }), signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
     };
     const submitTell = async (tell) => {
         if (!sdk || !activeSessionId) {
@@ -105,12 +118,12 @@ export async function startOpencode(prompt, cwd, options = {}) {
             if (!baseModelRef) {
                 throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${tellEffort}' requires an explicit model.`);
             }
-            const signal = executionSignal ?? new AbortController().signal;
+            const signal = activeExecutionSignal();
             await waitIdle();
-            await client.v2.session.switchModel({
+            await withAbort(client.v2.session.switchModel({
                 sessionID: activeSessionId,
                 model: { providerID: baseModelRef.providerID, id: baseModelRef.id, variant: tellEffort },
-            }, { throwOnError: true, signal });
+            }, { throwOnError: true, signal }), signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
             const ack = await promptSteer(client, tell.text, tell.id);
             return {
                 ack,
@@ -176,29 +189,17 @@ export async function startOpencode(prompt, cwd, options = {}) {
         onIngress: options.onIngress,
         async abort(mode) {
             acceptingEnqueue = false;
-            streamAbort?.abort();
             if (mode === "force") {
-                const failures = [];
+                streamAbort?.abort();
+                const attempts = [
+                    awaitProviderAbortSettlement(OPENCODE_SDK_PROVIDER, Promise.resolve().then(() => sdk?.close?.("force")), "forced server close did not settle"),
+                    awaitProviderAbortSettlement(OPENCODE_SDK_PROVIDER, runSettled, "forced execution teardown did not settle"),
+                ];
                 if (sdk && activeSessionId) {
-                    try {
-                        await sdk.client.v2.session.interrupt({ sessionID: activeSessionId }, { throwOnError: true });
-                    }
-                    catch (error) {
-                        failures.push(error);
-                    }
-                }
-                try {
-                    await sdk?.close?.("force");
-                }
-                catch (error) {
-                    failures.push(error);
-                }
-                try {
-                    await runSettled;
-                }
-                catch (error) {
-                    failures.push(error);
+                    attempts.push(awaitProviderAbortSettlement(OPENCODE_SDK_PROVIDER, Promise.resolve().then(() => sdk.client.v2.session.interrupt({ sessionID: activeSessionId }, { throwOnError: true })), "forced native interrupt did not settle"));
                 }
+                const failures = (await Promise.allSettled(attempts))
+                    .flatMap((result) => result.status === "rejected" ? [result.reason] : []);
                 if (failures.length === 1)
                     throw failures[0];
                 if (failures.length > 1) {
@@ -207,18 +208,40 @@ export async function startOpencode(prompt, cwd, options = {}) {
                 return;
             }
             if (sdk && activeSessionId) {
-                try {
-                    await sdk.client.v2.session.interrupt({ sessionID: activeSessionId }, { throwOnError: true });
-                }
-                catch {
-                    // idle interrupt may error
-                }
+                gracefulInterruptRequested = true;
+                gracefulProviderSettlement ??= awaitProviderAbortSettlement(OPENCODE_SDK_PROVIDER, settleOpencodeGracefulInterrupt({
+                    interrupt: () => sdk.client.v2.session.interrupt({ sessionID: activeSessionId }, { throwOnError: true }),
+                    waitForIdle: () => {
+                        if (!idleMonitor)
+                            throw new Error(`${OPENCODE_SDK_PROVIDER} graceful abort lacked idle monitor`);
+                        return idleMonitor.waitForIdle();
+                    },
+                    // Native inactivity is terminal authority. Only then stop the
+                    // local stream and drain all durable history admitted so far.
+                    stopStream: () => {
+                        if (!streamAbort)
+                            throw new Error(`${OPENCODE_SDK_PROVIDER} graceful abort lacked event stream`);
+                        streamAbort.abort();
+                    },
+                    waitForStream: () => {
+                        if (!streamTask)
+                            throw new Error(`${OPENCODE_SDK_PROVIDER} graceful abort lacked stream task`);
+                        return streamTask;
+                    },
+                    drainHistory: () => {
+                        if (!eventController)
+                            throw new Error(`${OPENCODE_SDK_PROVIDER} graceful abort lacked event history controller`);
+                        return eventController.drainHistory(eventController.lastSeenSeq());
+                    },
+                }));
+                await gracefulProviderSettlement;
             }
         },
         async run(builder) {
             builderRef = builder;
             streamAbort = new AbortController();
             const combined = new AbortController();
+            const streamSignal = AbortSignal.any([combined.signal, streamAbort.signal]);
             executionSignal = combined.signal;
             const forward = () => combined.abort();
             builder.signal.addEventListener("abort", forward, { once: true });
@@ -228,7 +251,7 @@ export async function startOpencode(prompt, cwd, options = {}) {
             const control = { enqueue };
             try {
                 const env = buildSubagentEnv(options.env);
-                sdk = await withAbort(loadOpencodeSdk(executable, cwd, env, combined.signal), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                sdk = await withAbort(loadOpencodeSdk(executable, cwd, env, combined.signal, options.loader), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
                 const sessionResponse = sessionId
                     ? await withAbort(sdk.client.v2.session.get({ sessionID: sessionId }, { throwOnError: true, signal: combined.signal }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`)
                     : await withAbort(sdk.client.v2.session.create({
@@ -239,13 +262,14 @@ export async function startOpencode(prompt, cwd, options = {}) {
                 if (!activeSessionId) {
                     const message = `${OPENCODE_SDK_PROVIDER} exec could not determine session id`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 idleMonitor = new OpencodeIdleMonitor(sdk.client.v2.session, activeSessionId, combined.signal);
                 eventController = createOpencodeEventController({
                     builder,
                     control,
                     idleMonitorIngress: () => idleMonitor?.ingress(),
+                    idleMonitorTerminal: () => idleMonitor?.terminal(),
                     onEvidence: options.onEvidence,
                     onSyncCheckpoint: options.onSyncCheckpoint,
                     onDeliveryOpportunity: options.onDeliveryOpportunity,
@@ -259,23 +283,40 @@ export async function startOpencode(prompt, cwd, options = {}) {
                 if (sessionId && baseModelRef) {
                     await applyBaseModel(sdk.client);
                 }
-                const eventsResult = await sdk.client.v2.session.events({ sessionID: activeSessionId }, { signal: streamAbort.signal });
-                const streamTask = (async () => {
+                const eventsResultTask = withAbort(sdk.client.v2.session.events({ sessionID: activeSessionId }, { signal: streamSignal }), streamSignal, `${OPENCODE_SDK_PROVIDER} event stream cancelled by client`);
+                streamTask = (async () => {
                     try {
-                        for await (const item of eventsResult.stream) {
-                            if (streamAbort.signal.aborted || combined.signal.aborted)
+                        const eventsResult = await eventsResultTask;
+                        const iterator = eventsResult.stream[Symbol.asyncIterator]();
+                        for (;;) {
+                            const next = await withAbort(iterator.next(), streamSignal, `${OPENCODE_SDK_PROVIDER} event stream cancelled by client`);
+                            if (next.done || streamSignal.aborted)
                                 break;
+                            const item = next.value;
                             eventController.processUnknownStreamItem(item);
                         }
                     }
                     catch (error) {
-                        if (!streamAbort.signal.aborted && !combined.signal.aborted)
+                        if (!streamSignal.aborted)
                             throw error;
                     }
                 })();
+                streamTask.catch(() => undefined);
+                // Preserve provider sequencing: establish the stream before prompting.
+                // The acquisition itself lives inside streamTask, so local shutdown can
+                // always settle it even when the SDK never resolves events().
+                await eventsResultTask;
                 await promptSteer(sdk.client, prompt);
                 await waitIdle();
+                if (gracefulInterruptRequested) {
+                    await gracefulProviderSettlement;
+                    throw createAbortError(`${OPENCODE_SDK_PROVIDER} session interrupted`);
+                }
                 await drainEnqueueTail();
+                if (gracefulInterruptRequested) {
+                    await gracefulProviderSettlement;
+                    throw createAbortError(`${OPENCODE_SDK_PROVIDER} session interrupted`);
+                }
                 streamAbort.abort();
                 await streamTask;
                 await eventController.drainHistory(eventController.lastSeenSeq());
@@ -290,7 +331,7 @@ export async function startOpencode(prompt, cwd, options = {}) {
                     const message = coerceString(finalAssistant.error.message) ?? `${OPENCODE_SDK_PROVIDER} assistant error`;
                     builder.emit({ type: "diagnostic", text: message });
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 if (finalMessage) {
                     builder.emit({
@@ -326,6 +367,7 @@ export async function startOpencode(prompt, cwd, options = {}) {
                 idleMonitor?.dispose();
                 idleMonitor = undefined;
                 executionSignal = undefined;
+                streamTask = undefined;
                 try {
                     await sdk?.close?.();
                 }
@@ -342,3 +384,5 @@ export async function startOpencode(prompt, cwd, options = {}) {
         },
     });
 }
+// Compiler-level binding to the named ProviderAdapter function contract.
+startOpencode;

package/build/agents/providers/opencode-sdk/events.js

@@ -1,8 +1,9 @@
 import { activityCallFromNamedTool } from "../../harness/activity-values.js";
 import { AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
 import { coerceString, emitProviderEvidence } from "../../harness/runtime.js";
 import { appendEventType } from "../event-type-tail.js";
-import { OPENCODE_SDK_PROVIDER } from "./session.js";
+import { OPENCODE_SDK_PROVIDER, withAbort } from "./session.js";
 const OPENCODE_EVENT_PROMPTED = "session.next.prompted";
 function isSessionDurableEvent(value) {
     return Boolean(value
@@ -116,7 +117,7 @@ function extractFinalAssistantMessage(messages) {
     return messages.find((message) => message.type === "assistant");
 }
 export function createOpencodeEventController(options) {
-    const { builder, control, idleMonitorIngress, onEvidence, onSyncCheckpoint, onDeliveryOpportunity, getSessionId, client, } = options;
+    const { builder, control, idleMonitorIngress, idleMonitorTerminal, onEvidence, onSyncCheckpoint, onDeliveryOpportunity, getSessionId, client, } = options;
     const recordedEventTypes = [];
     let totalEventCount = 0;
     let currentTurnAdmitted = false;
@@ -186,6 +187,7 @@ export function createOpencodeEventController(options) {
                         });
                     }
                     clearLastTurnFailureOnTerminalEvidence();
+                    idleMonitorTerminal();
                     break;
                 }
                 case "session.next.reasoning.ended": {
@@ -263,15 +265,17 @@ export function createOpencodeEventController(options) {
                         outputTokens: tokens.output,
                     });
                     clearLastTurnFailureOnTerminalEvidence();
+                    idleMonitorTerminal();
                     break;
                 }
                 case "session.next.step.failed": {
                     const message = coerceString(event.data.error?.message) ?? `${OPENCODE_SDK_PROVIDER} step failed`;
-                    const failure = new Error(message);
+                    const failure = createProviderFailure(message);
                     currentTurnFailure = failure;
                     lastTurnFailure = failure;
                     builder.emit({ type: "diagnostic", text: message });
                     builder.emit({ type: "fail", message });
+                    idleMonitorTerminal();
                     break;
                 }
                 default:
@@ -317,7 +321,7 @@ export function createOpencodeEventController(options) {
         let cursor = after;
         for (;;) {
             const priorCursor = cursor;
-            const page = await client.v2.session.history({ sessionID: getSessionId(), after: cursor }, { throwOnError: true, signal: options.executionSignal });
+            const page = await withAbort(client.v2.session.history({ sessionID: getSessionId(), after: cursor }, { throwOnError: true, signal: options.executionSignal }), options.executionSignal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
             const body = page.data;
             const events = body.data ?? [];
             for (const event of events) {