@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/agents/providers/codex-sdk.js

@@ -23,9 +23,16 @@ function withCodexSdkModelReasoningEffort(threadOptions) {
     };
 }
 let codexConstructor = Codex;
+function getCodexConstructor(override) {
+    if (override)
+        return override;
+    return codexConstructor;
+}
+/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
 export function setCodexSdkConstructorForTests(constructor) {
     codexConstructor = constructor;
 }
+/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
 export function resetCodexSdkConstructorForTests() {
     codexConstructor = Codex;
 }
@@ -60,7 +67,12 @@ function extractAgentMessage(event) {
     if (event.type !== CODEX_EVENT_ITEM_COMPLETED && event.type !== CODEX_EVENT_ITEM_UPDATED) {
         return undefined;
     }
-    return event.item.type === "agent_message" ? coerceString(event.item.text) : undefined;
+    if (event.item.type !== "agent_message")
+        return undefined;
+    const text = coerceString(event.item.text);
+    if (!text)
+        return undefined;
+    return { id: event.item.id, text };
 }
 function codexActivityCall(item) {
     switch (item.type) {
@@ -157,18 +169,23 @@ function emitCodexSemanticEvent(builder, event) {
         ...(phase === "started" ? {} : { result: codexActivityResult(event.item) }),
     });
 }
+/** @deprecated Use the codex-app-server adapter. */
 export async function startCodexSdk(prompt, cwd, options) {
     const threadId = options.threadId?.trim();
     const recordedEventTypes = [];
     let totalEventCount = 0;
     let activeAbort;
+    let runReturned = false;
     appendDebugLog(`startCodexSdk: executable=${options.executable ?? "codex"} model=${options.model ?? "default"} ${CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY}=${String(options.config?.[CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY] ?? "default")} mode=${threadId ? "resume" : "fresh"}`, { cwd, section: CODEX_SDK_PROVIDER });
     return createProjectionDriver({
         steerMode: "replay",
         initialTurn: options.initialTurn,
         onIngress: options.onIngress,
-        async abort() {
+        async abort(mode) {
             activeAbort?.abort();
+            if (mode === "force" && !runReturned) {
+                throw new Error("codex-sdk cannot guarantee forced termination");
+            }
         },
         async run(builder) {
             activeAbort = new AbortController();
@@ -186,7 +203,7 @@ export async function startCodexSdk(prompt, cwd, options) {
                     config: options.config,
                     env,
                 };
-                const sdk = new codexConstructor(codexOptions);
+                const sdk = new (getCodexConstructor(options.codexConstructor))(codexOptions);
                 const threadOptions = withCodexSdkModelReasoningEffort(options.threadOptions);
                 const thread = threadId ? sdk.resumeThread(threadId, threadOptions) : sdk.startThread(threadOptions);
                 const streamed = await thread.runStreamed(prompt, { signal: activeAbort.signal });
@@ -255,8 +272,8 @@ export async function startCodexSdk(prompt, cwd, options) {
                         emitCodexSemanticEvent(builder, event);
                         const message = extractAgentMessage(event);
                         if (message) {
-                            lastAgentMessage = message;
-                            builder.emit({ type: "message", text: message });
+                            lastAgentMessage = message.text;
+                            builder.emit({ type: "message", id: message.id, text: message.text });
                         }
                     });
                 }
@@ -304,6 +321,7 @@ export async function startCodexSdk(prompt, cwd, options) {
                 throw error;
             }
             finally {
+                runReturned = true;
                 linked.removeEventListener("abort", onOuterAbort);
             }
         },

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

@@ -0,0 +1,344 @@
+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 { 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) });
+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 function setOpencodeSdkLoaderForTests(loader) {
+    setLoader(loader);
+}
+export function resetOpencodeSdkLoaderForTests() {
+    resetLoader();
+}
+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 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 : new Error(String(error));
+    const rememberEnqueueFailure = (error) => {
+        const failure = asProviderError(error);
+        enqueueFailure ??= failure;
+        return failure;
+    };
+    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 receipt = await 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 });
+        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;
+        await client.v2.session.switchModel({ sessionID: activeSessionId, model: baseModelRef }, { throwOnError: true, signal: executionSignal });
+    };
+    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 = executionSignal ?? new AbortController().signal;
+            await waitIdle();
+            await client.v2.session.switchModel({
+                sessionID: activeSessionId,
+                model: { providerID: baseModelRef.providerID, id: baseModelRef.id, variant: tellEffort },
+            }, { throwOnError: true, signal });
+            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;
+            streamAbort?.abort();
+            if (mode === "force") {
+                const failures = [];
+                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);
+                }
+                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) {
+                try {
+                    await sdk.client.v2.session.interrupt({ sessionID: activeSessionId }, { throwOnError: true });
+                }
+                catch {
+                    // idle interrupt may error
+                }
+            }
+        },
+        async run(builder) {
+            builderRef = builder;
+            streamAbort = new AbortController();
+            const combined = new AbortController();
+            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), 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 new Error(message);
+                }
+                idleMonitor = new OpencodeIdleMonitor(sdk.client.v2.session, activeSessionId, combined.signal);
+                eventController = createOpencodeEventController({
+                    builder,
+                    control,
+                    idleMonitorIngress: () => idleMonitor?.ingress(),
+                    onEvidence: options.onEvidence,
+                    onSyncCheckpoint: options.onSyncCheckpoint,
+                    onDeliveryOpportunity: options.onDeliveryOpportunity,
+                    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 eventsResult = await sdk.client.v2.session.events({ sessionID: activeSessionId }, { signal: streamAbort.signal });
+                const streamTask = (async () => {
+                    try {
+                        for await (const item of eventsResult.stream) {
+                            if (streamAbort.signal.aborted || combined.signal.aborted)
+                                break;
+                            eventController.processUnknownStreamItem(item);
+                        }
+                    }
+                    catch (error) {
+                        if (!streamAbort.signal.aborted && !combined.signal.aborted)
+                            throw error;
+                    }
+                })();
+                await promptSteer(sdk.client, prompt);
+                await waitIdle();
+                await drainEnqueueTail();
+                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 new Error(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;
+                try {
+                    await sdk?.close?.();
+                }
+                catch (error) {
+                    rejectRunSettled(error);
+                    throw error;
+                }
+                finally {
+                    builder.signal.removeEventListener("abort", forward);
+                    options.signal?.removeEventListener("abort", forward);
+                    resolveRunSettled();
+                }
+            }
+        },
+    });
+}