@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -1,402 +0,0 @@
-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 { 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, } from "./session.js";
-export { opencodeSessionSchema } from "./session-schema.js";
-export function parseOpencodeModelRef(model, effort) {
-    const trimmed = model.trim();
-    const slash = trimmed.indexOf("/");
-    if (slash <= 0 || slash === trimmed.length - 1) {
-        throw new FlowError("INVALID_SETTINGS", `Invalid opencode model '${model}'. Expected opaque shape '<provider>/<model>' with non-empty segments split at the first slash.`);
-    }
-    return {
-        providerID: trimmed.slice(0, slash),
-        id: trimmed.slice(slash + 1),
-        ...(effort !== undefined ? { variant: effort } : {}),
-    };
-}
-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();
-    const executable = options.executable ?? OPENCODE_DEFAULT_EXECUTABLE;
-    const baseModelRef = options.model === undefined
-        ? undefined
-        : parseOpencodeModelRef(options.model, options.effort);
-    const baseEffort = options.effort;
-    let activeSessionId;
-    let sdk;
-    let streamAbort;
-    let executionSignal;
-    let idleMonitor;
-    let enqueueTail = Promise.resolve();
-    let enqueueFailure;
-    let acceptingEnqueue = true;
-    let builderRef;
-    let streamTask;
-    let gracefulInterruptRequested = false;
-    let gracefulProviderSettlement;
-    let resolveRunSettled;
-    let rejectRunSettled;
-    const runSettled = new Promise((resolve, reject) => {
-        resolveRunSettled = resolve;
-        rejectRunSettled = reject;
-    });
-    runSettled.catch(() => undefined);
-    let eventController;
-    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, {
-                type: "outbound",
-                provider: OPENCODE_SDK_PROVIDER,
-                direction: "input",
-                kind: tellId ? "steer" : "turn-start",
-                ...sha256Utf8(text),
-            }, (textDiagnostic) => builderRef?.emit({ type: "diagnostic", text: textDiagnostic }));
-        }
-        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",
-            // 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) {
-            emitProviderEvidence(options.onEvidence, {
-                type: "ack",
-                provider: OPENCODE_SDK_PROVIDER,
-                fence: { kind: "ordinal", ordinal },
-                outbound: tellId ? "steer" : "run",
-            }, (textDiagnostic) => builderRef?.emit({ type: "diagnostic", text: textDiagnostic }));
-        }
-        return { fence: { kind: "ordinal", ordinal } };
-    };
-    const waitIdle = async () => {
-        if (!idleMonitor)
-            throw new Error(`${OPENCODE_SDK_PROVIDER} cannot observe idle: no active session`);
-        await idleMonitor.waitForIdle();
-    };
-    const applyBaseModel = async (client) => {
-        if (!baseModelRef)
-            return;
-        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) {
-            throw new Error(`${OPENCODE_SDK_PROVIDER} cannot steer: no active session`);
-        }
-        const client = sdk.client;
-        const tellEffort = tell.effort;
-        if (tellEffort !== undefined && tellEffort !== baseEffort) {
-            if (!baseModelRef) {
-                throw new FlowError("INVALID_EFFORT_OVERRIDE", `Effort '${tellEffort}' requires an explicit model.`);
-            }
-            const signal = activeExecutionSignal();
-            await waitIdle();
-            await withAbort(client.v2.session.switchModel({
-                sessionID: activeSessionId,
-                model: { providerID: baseModelRef.providerID, id: baseModelRef.id, variant: tellEffort },
-            }, { throwOnError: true, signal }), signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-            const ack = await promptSteer(client, tell.text, tell.id);
-            return {
-                ack,
-                settle: (async () => {
-                    await waitIdle();
-                    await applyBaseModel(client);
-                })(),
-            };
-        }
-        return { ack: await promptSteer(client, tell.text, tell.id), settle: Promise.resolve() };
-    };
-    const enqueue = (tell) => {
-        if (!acceptingEnqueue) {
-            return Promise.reject(enqueueFailure ?? new Error(`${OPENCODE_SDK_PROVIDER} session is no longer accepting tells`));
-        }
-        let resolveAck;
-        let rejectAck;
-        let ackResolved = false;
-        const ack = new Promise((resolve, reject) => {
-            resolveAck = resolve;
-            rejectAck = reject;
-        });
-        const job = enqueueTail.then(async () => {
-            if (enqueueFailure) {
-                rejectAck(enqueueFailure);
-                return;
-            }
-            try {
-                const submission = await submitTell(tell);
-                ackResolved = true;
-                resolveAck(submission.ack);
-                await submission.settle;
-            }
-            catch (error) {
-                const failure = rememberEnqueueFailure(error);
-                if (!ackResolved)
-                    rejectAck(failure);
-                throw failure;
-            }
-        });
-        enqueueTail = job.catch((error) => {
-            rememberEnqueueFailure(error);
-        });
-        return ack;
-    };
-    const drainEnqueueTail = async () => {
-        for (;;) {
-            const observed = enqueueTail;
-            await observed;
-            if (observed !== enqueueTail)
-                continue;
-            acceptingEnqueue = false;
-            if (enqueueFailure)
-                throw enqueueFailure;
-            return;
-        }
-    };
-    appendDebugLog(`startOpencode: executable=${executable} model=${options.model ?? "default"} mode=${sessionId ? "resume" : "fresh"}`, { cwd, section: OPENCODE_SDK_PROVIDER });
-    return createProjectionDriver({
-        steerMode: "mid-execution",
-        initialTurn: options.initialTurn,
-        enqueue,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            acceptingEnqueue = false;
-            if (mode === "force") {
-                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) {
-                    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) {
-                    throw new AggregateError(failures, `${OPENCODE_SDK_PROVIDER} forced abort failed`);
-                }
-                return;
-            }
-            if (sdk && activeSessionId) {
-                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 });
-            options.signal?.addEventListener("abort", forward, { once: true });
-            if (builder.signal.aborted || options.signal?.aborted)
-                forward();
-            const control = { enqueue };
-            try {
-                const env = buildSubagentEnv(options.env);
-                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({
-                        location: { directory: cwd },
-                        ...(baseModelRef ? { model: baseModelRef } : {}),
-                    }, { throwOnError: true, signal: combined.signal }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                activeSessionId = sessionIdFrom(sessionResponse.data.data, sessionId);
-                if (!activeSessionId) {
-                    const message = `${OPENCODE_SDK_PROVIDER} exec could not determine session id`;
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                options.onSessionAdmission?.({
-                    session: {
-                        provider: OPENCODE_SDK_PROVIDER,
-                        version: SUBAGENT_SESSION_VERSION,
-                        handle: { sessionId: activeSessionId },
-                    },
-                });
-                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,
-                    onTellReceipt: options.onTellReceipt,
-                    listLaunchAdmissions: options.listLaunchAdmissions,
-                    executionSignal: combined.signal,
-                    getSessionId: () => activeSessionId,
-                    client: sdk.client,
-                });
-                if (options.onEvidence) {
-                    emitProviderEvidence(options.onEvidence, { type: "session", provider: OPENCODE_SDK_PROVIDER, sessionId: activeSessionId }, (text) => builder.emit({ type: "diagnostic", text }));
-                }
-                if (sessionId && baseModelRef) {
-                    await applyBaseModel(sdk.client);
-                }
-                const eventsResultTask = withAbort(sdk.client.v2.session.events({ sessionID: activeSessionId }, { signal: streamSignal }), streamSignal, `${OPENCODE_SDK_PROVIDER} event stream cancelled by client`);
-                streamTask = (async () => {
-                    try {
-                        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 (!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;
-                const launchAcknowledgement = await promptSteer(sdk.client, prompt);
-                await options.onLaunchAdmission?.({
-                    fence: launchAcknowledgement.fence,
-                    tellIds: options.launchTellIds ?? [],
-                });
-                eventController?.reconcileLaunchAdmissions();
-                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());
-                const lastTurnFailure = eventController.lastTurnFailure();
-                if (lastTurnFailure)
-                    throw lastTurnFailure;
-                const messagesResponse = await withAbort(sdk.client.v2.session.messages({ sessionID: activeSessionId, order: "desc", limit: 32 }, { throwOnError: true, signal: combined.signal }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                const messagesBody = messagesResponse.data;
-                const messages = messagesBody.data ?? [];
-                const { finalAssistant, finalMessage } = eventController.finalAssistantText(messages);
-                if (finalAssistant?.error) {
-                    const message = coerceString(finalAssistant.error.message) ?? `${OPENCODE_SDK_PROVIDER} assistant error`;
-                    builder.emit({ type: "diagnostic", text: message });
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                if (finalMessage) {
-                    builder.emit({
-                        type: "message",
-                        id: finalAssistant?.id ?? "opencode-final",
-                        text: finalMessage,
-                    });
-                }
-                eventController.closeTurn();
-                const sessionEnvelope = {
-                    provider: "opencode-sdk",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: { sessionId: activeSessionId },
-                };
-                const resolvedFinal = finalMessage ?? "";
-                builder.emit({
-                    type: "done",
-                    finalMessage: resolvedFinal,
-                    session: sessionEnvelope,
-                });
-                return { finalMessage: resolvedFinal, session: sessionEnvelope };
-            }
-            catch (error) {
-                appendDebugLog(`startOpencode error: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`, { cwd, section: OPENCODE_SDK_PROVIDER });
-                throw error;
-            }
-            finally {
-                acceptingEnqueue = false;
-                if (activeSessionId) {
-                    appendDebugBlock("opencode-sdk stdout event types", renderEventTypeSummary(eventController?.recordedEventTypes() ?? [], eventController?.totalEventCount() ?? 0), { cwd, section: OPENCODE_SDK_PROVIDER });
-                }
-                streamAbort?.abort();
-                idleMonitor?.dispose();
-                idleMonitor = undefined;
-                executionSignal = undefined;
-                streamTask = undefined;
-                try {
-                    await sdk?.close?.();
-                }
-                catch (error) {
-                    rejectRunSettled(error);
-                    throw error;
-                }
-                finally {
-                    builder.signal.removeEventListener("abort", forward);
-                    options.signal?.removeEventListener("abort", forward);
-                    resolveRunSettled();
-                }
-            }
-        },
-    });
-}
-// Compiler-level binding to the named ProviderAdapter function contract.
-startOpencode;