@astrosheep/keiyaku 0.1.86 → 1.0.0

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

@@ -0,0 +1,193 @@
+import { z } from "zod";
+import { Codex } from "@openai/codex-sdk";
+import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../../keiyaku.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, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
+import { coerceString } from "../../agents/index.js";
+let codexConstructor = Codex;
+export function setCodexSdkConstructorForTests(constructor) {
+    codexConstructor = constructor;
+}
+export function resetCodexSdkConstructorForTests() {
+    codexConstructor = Codex;
+}
+export const codexThreadSchema = z.object({ threadId: z.string().trim().min(1) });
+const CODEX_EVENT_THREAD_STARTED = "thread.started";
+const CODEX_EVENT_TURN_STARTED = "turn.started";
+const CODEX_EVENT_TURN_FAILED = "turn.failed";
+const CODEX_EVENT_ERROR = "error";
+const CODEX_EVENT_ITEM_COMPLETED = "item.completed";
+const CODEX_EVENT_ITEM_UPDATED = "item.updated";
+const CODEX_SDK_PROVIDER = "codex-sdk";
+const MAX_RECORDED_EVENT_TYPES = 100;
+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;
+}
+function appendEventType(recordedTypes, eventType) {
+    if (recordedTypes.length === MAX_RECORDED_EVENT_TYPES) {
+        recordedTypes.shift();
+    }
+    recordedTypes.push(eventType);
+}
+function renderEventTypeSummary(eventTypes, totalEventCount) {
+    if (eventTypes.length === 0)
+        return "(no streamed events)";
+    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
+    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
+    if (totalEventCount <= eventTypes.length)
+        return summary;
+    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
+}
+export async function startCodexSdk(prompt, cwd, options) {
+    const threadId = options.threadId?.trim();
+    const recordedEventTypes = [];
+    let totalEventCount = 0;
+    let activeAbort;
+    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",
+        async abort() {
+            activeAbort?.abort();
+        },
+        async run(builder) {
+            activeAbort = new AbortController();
+            const linked = options.signal ?? builder.signal;
+            const onOuterAbort = () => activeAbort?.abort();
+            linked.addEventListener("abort", onOuterAbort, { once: true });
+            if (linked.aborted)
+                onOuterAbort();
+            builder.signal.addEventListener("abort", onOuterAbort, { once: true });
+            try {
+                const env = buildSubagentEnv();
+                const codexOptions = {
+                    codexPathOverride: options.executable,
+                    profile: options.profile,
+                    config: options.config,
+                    env,
+                };
+                const sdk = new codexConstructor(codexOptions);
+                const threadOptions = options.threadOptions;
+                const thread = threadId ? sdk.resumeThread(threadId, threadOptions) : sdk.startThread(threadOptions);
+                const streamed = await thread.runStreamed(prompt, { signal: activeAbort.signal });
+                const eventIterator = streamed.events[Symbol.asyncIterator]();
+                // The SDK iterable is lazy: its first next() starts the native run.
+                // Record outbound bytes immediately before that crossing, then ack only
+                // after it settles (including a legitimate no-event completion).
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, {
+                        type: "outbound",
+                        provider: CODEX_SDK_PROVIDER,
+                        direction: "input",
+                        kind: "replay-prompt",
+                        ...sha256Utf8(prompt),
+                    }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                const firstEvent = await eventIterator.next();
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, {
+                        type: "ack",
+                        provider: CODEX_SDK_PROVIDER,
+                        fence: { kind: "ordinal", ordinal: 0 },
+                        outbound: "run",
+                    }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                const events = async function* () {
+                    if (!firstEvent.done)
+                        yield firstEvent.value;
+                    while (true) {
+                        const next = await eventIterator.next();
+                        if (next.done)
+                            return;
+                        yield next.value;
+                    }
+                };
+                let resumeToken;
+                let lastAgentMessage;
+                let turnFailedMessage;
+                let streamErrorMessage;
+                for await (const event of events()) {
+                    if (activeAbort.signal.aborted) {
+                        throw Object.assign(new Error(`${CODEX_SDK_PROVIDER} exec cancelled by client`), { name: "AbortError" });
+                    }
+                    totalEventCount += 1;
+                    appendEventType(recordedEventTypes, event.type);
+                    builder.emit({ type: "output", value: event });
+                    if (event.type === CODEX_EVENT_THREAD_STARTED) {
+                        resumeToken = event.thread_id;
+                        if (options.onEvidence)
+                            emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_SDK_PROVIDER, threadId: resumeToken }, (text) => builder.emit({ type: "diagnostic", text }));
+                    }
+                    else if (event.type === CODEX_EVENT_TURN_STARTED && !resumeToken) {
+                        builder.emit({
+                            type: "fail",
+                            message: `${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`,
+                        });
+                        throw new Error(`${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`);
+                    }
+                    else if (event.type === CODEX_EVENT_TURN_FAILED) {
+                        turnFailedMessage = coerceString(event.error.message) ?? `${CODEX_SDK_PROVIDER} turn failed`;
+                    }
+                    else if (event.type === CODEX_EVENT_ERROR) {
+                        streamErrorMessage = coerceString(event.message) ?? `${CODEX_SDK_PROVIDER} stream error`;
+                        builder.emit({ type: "diagnostic", text: `${streamErrorMessage}\n` });
+                    }
+                    const message = extractAgentMessage(event);
+                    if (message) {
+                        lastAgentMessage = message;
+                        builder.emit({ type: "message", text: message });
+                    }
+                }
+                if (turnFailedMessage) {
+                    builder.emit({ type: "diagnostic", text: turnFailedMessage });
+                    builder.emit({ type: "fail", message: turnFailedMessage });
+                    throw new Error(turnFailedMessage);
+                }
+                if (streamErrorMessage && !lastAgentMessage) {
+                    builder.emit({ type: "fail", message: streamErrorMessage });
+                    throw new Error(streamErrorMessage);
+                }
+                if (!resumeToken) {
+                    appendDebugLog(`Missing required codex event: ${CODEX_EVENT_THREAD_STARTED} with thread_id.`, {
+                        cwd,
+                        section: CODEX_SDK_PROVIDER,
+                    });
+                    appendDebugBlock("codex-sdk stdout event types", renderEventTypeSummary(recordedEventTypes, totalEventCount), {
+                        cwd,
+                        section: CODEX_SDK_PROVIDER,
+                    });
+                    builder.emit({
+                        type: "fail",
+                        message: `${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`,
+                    });
+                    throw new Error(`${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`);
+                }
+                const finalMessage = lastAgentMessage ?? "";
+                const session = {
+                    provider: "codex-sdk",
+                    version: SUBAGENT_SESSION_VERSION,
+                    handle: { threadId: resumeToken },
+                };
+                if (options.onEvidence)
+                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_SDK_PROVIDER, fence: { kind: "ordinal", ordinal: 1 }, source: "response" }, (text) => builder.emit({ type: "diagnostic", text }));
+                builder.emit({
+                    type: "done",
+                    finalMessage,
+                    session,
+                });
+                return { finalMessage, session };
+            }
+            catch (error) {
+                appendDebugLog(`startCodexSdk error: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`, { cwd, section: CODEX_SDK_PROVIDER });
+                throw error;
+            }
+            finally {
+                linked.removeEventListener("abort", onOuterAbort);
+            }
+        },
+    });
+}

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

@@ -0,0 +1,257 @@
+import { z } from "zod";
+import { appendDebugBlock, appendDebugLog } from "../../telemetry/debug-log.js";
+import { createOpencode } from "../opencode-sdk.js";
+import { SUBAGENT_SESSION_VERSION } from "../session.js";
+import { createProjectionDriver } from "../harness/execution-handle.js";
+import { buildSubagentEnv, createAbortError } from "../harness/runtime.js";
+import { emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
+import { coerceString } from "../index.js";
+export const opencodeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });
+const OPENCODE_EVENT_SESSION_IDLE = "session.idle";
+const OPENCODE_EVENT_SESSION_ERROR = "session.error";
+const OPENCODE_EVENT_MESSAGE_UPDATED = "message.updated";
+const OPENCODE_EVENT_MESSAGE_PART_UPDATED = "message.part.updated";
+const OPENCODE_EVENT_MESSAGE_PART_ADDED = "message.part.added";
+const OPENCODE_SDK_PROVIDER = "opencode-sdk";
+const OPENCODE_DEFAULT_EXECUTABLE = "opencode";
+const OPENCODE_MAX_RECORDED_EVENT_TYPES = 100;
+const OPENCODE_ASSISTANT_ROLE = "assistant";
+const OPENCODE_TEXT_PART_TYPE = "text";
+let opencodeSdkLoader;
+function appendEventType(recordedTypes, eventType) {
+    if (recordedTypes.length === OPENCODE_MAX_RECORDED_EVENT_TYPES) {
+        recordedTypes.shift();
+    }
+    recordedTypes.push(eventType);
+}
+function renderEventTypeSummary(eventTypes, totalEventCount) {
+    if (eventTypes.length === 0)
+        return "(no streamed events)";
+    const startIndex = Math.max(totalEventCount - eventTypes.length, 0);
+    const summary = eventTypes.map((eventType, index) => `${startIndex + index + 1}. ${eventType}`).join("\n");
+    if (totalEventCount <= eventTypes.length)
+        return summary;
+    return `...[showing last ${eventTypes.length} of ${totalEventCount} events]...\n${summary}`;
+}
+function extractTextFromMessage(message) {
+    if (!message?.parts)
+        return undefined;
+    const text = message.parts
+        .filter((part) => !part.type || part.type === OPENCODE_TEXT_PART_TYPE)
+        .map((part) => coerceString(part.text))
+        .filter((part) => Boolean(part))
+        .join("");
+    return text.trim() || undefined;
+}
+function extractFinalAssistantMessage(messages) {
+    let lastText;
+    let lastAssistantText;
+    for (const message of messages) {
+        const text = extractTextFromMessage(message);
+        if (!text)
+            continue;
+        lastText = text;
+        if (message.info?.role === OPENCODE_ASSISTANT_ROLE) {
+            lastAssistantText = text;
+        }
+    }
+    return lastAssistantText ?? lastText;
+}
+async function withAbort(promise, signal, message) {
+    if (signal.aborted) {
+        throw createAbortError(message);
+    }
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            signal.removeEventListener("abort", onAbort);
+        };
+        const onAbort = () => {
+            cleanup();
+            reject(createAbortError(message));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            cleanup();
+            reject(error);
+        });
+    });
+}
+async function loadOpencodeSdk(executable, cwd, env, signal) {
+    if (opencodeSdkLoader) {
+        return opencodeSdkLoader();
+    }
+    const sdk = await createOpencode({
+        executable,
+        directory: cwd,
+        env,
+        signal,
+    });
+    return {
+        client: sdk.client,
+        close: sdk.server?.close,
+    };
+}
+async function awaitSessionIdle(input) {
+    const subscribed = await input.client.event.subscribe();
+    for await (const event of subscribed.stream) {
+        input.emit({ type: "output", value: event });
+        input.incrementEventCount();
+        appendEventType(input.recordedEventTypes, event.type);
+        if (event.properties?.sessionID !== input.sessionId) {
+            continue;
+        }
+        if (event.type === OPENCODE_EVENT_SESSION_ERROR) {
+            const errorMessage = coerceString(event.error?.message) ??
+                coerceString(event.properties?.message) ??
+                `${OPENCODE_SDK_PROVIDER} session error`;
+            input.emit({ type: "diagnostic", text: errorMessage });
+            input.emit({ type: "fail", message: errorMessage });
+            throw new Error(errorMessage);
+        }
+        if (event.type === OPENCODE_EVENT_SESSION_IDLE ||
+            event.type === OPENCODE_EVENT_MESSAGE_UPDATED ||
+            event.type === OPENCODE_EVENT_MESSAGE_PART_UPDATED ||
+            event.type === OPENCODE_EVENT_MESSAGE_PART_ADDED) {
+            if (event.type === OPENCODE_EVENT_SESSION_IDLE) {
+                return;
+            }
+        }
+    }
+    const message = `${OPENCODE_SDK_PROVIDER} event stream ended before ${OPENCODE_EVENT_SESSION_IDLE}`;
+    input.emit({ type: "fail", message });
+    throw new Error(message);
+}
+export function setOpencodeSdkLoaderForTests(loader) {
+    opencodeSdkLoader = loader;
+}
+export function resetOpencodeSdkLoaderForTests() {
+    opencodeSdkLoader = undefined;
+}
+export async function startOpencode(prompt, cwd, options = {}) {
+    const sessionId = options.sessionId?.trim();
+    const executable = options.executable ?? OPENCODE_DEFAULT_EXECUTABLE;
+    const recordedEventTypes = [];
+    let totalEventCount = 0;
+    let resumedSessionId;
+    let sdk;
+    let activeAbort;
+    appendDebugLog(`startOpencode: executable=${executable} model=${options.model ?? "default"} mode=${sessionId ? "resume" : "fresh"}`, { cwd, section: OPENCODE_SDK_PROVIDER });
+    return createProjectionDriver({
+        steerMode: "replay",
+        async abort() {
+            activeAbort?.abort();
+        },
+        async run(builder) {
+            activeAbort = new AbortController();
+            const combined = new AbortController();
+            const forward = () => combined.abort();
+            builder.signal.addEventListener("abort", forward, { once: true });
+            options.signal?.addEventListener("abort", forward, { once: true });
+            activeAbort.signal.addEventListener("abort", forward, { once: true });
+            if (builder.signal.aborted || options.signal?.aborted || activeAbort.signal.aborted) {
+                forward();
+            }
+            try {
+                const env = buildSubagentEnv();
+                sdk = await withAbort(loadOpencodeSdk(executable, cwd, env, combined.signal), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                const session = sessionId
+                    ? await withAbort(sdk.client.session.get({ path: { id: sessionId } }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`)
+                    : await withAbort(sdk.client.session.create({
+                        body: {
+                            ...(options.model ? { model: options.model } : {}),
+                            cwd,
+                        },
+                    }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                resumedSessionId = session.id || sessionId;
+                if (!resumedSessionId) {
+                    const message = `${OPENCODE_SDK_PROVIDER} exec could not determine session id`;
+                    builder.emit({ type: "fail", message });
+                    throw new Error(message);
+                }
+                const activeSessionId = resumedSessionId;
+                if (options.onEvidence)
+                    emitProviderEvidence(options.onEvidence, { type: "session", provider: OPENCODE_SDK_PROVIDER, sessionId: activeSessionId }, (text) => builder.emit({ type: "diagnostic", text }));
+                const idlePromise = awaitSessionIdle({
+                    client: sdk.client,
+                    emit: builder.emit,
+                    sessionId: activeSessionId,
+                    recordedEventTypes,
+                    incrementEventCount: () => {
+                        totalEventCount += 1;
+                    },
+                });
+                // session.prompt is the OpenCode SDK input crossing. Emitting the run
+                // acknowledgement after the call returns keeps synchronous startup
+                // failures replayable without delaying completion of the request.
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, {
+                        type: "outbound",
+                        provider: OPENCODE_SDK_PROVIDER,
+                        direction: "input",
+                        kind: "replay-prompt",
+                        ...sha256Utf8(prompt),
+                    }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                const promptPromise = sdk.client.session.prompt({
+                    path: { id: activeSessionId },
+                    body: {
+                        ...(options.model ? { model: options.model } : {}),
+                        parts: [{ type: OPENCODE_TEXT_PART_TYPE, text: prompt }],
+                    },
+                });
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, {
+                        type: "ack",
+                        provider: OPENCODE_SDK_PROVIDER,
+                        fence: { kind: "ordinal", ordinal: 0 },
+                        outbound: "run",
+                    }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                const [promptResult] = await withAbort(Promise.all([promptPromise, idlePromise]), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                let finalMessage = extractTextFromMessage(promptResult);
+                if (!finalMessage) {
+                    const messages = await withAbort(sdk.client.session.messages({ path: { id: activeSessionId } }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+                    finalMessage = extractFinalAssistantMessage(messages);
+                }
+                if (finalMessage) {
+                    builder.emit({ type: "message", text: finalMessage });
+                }
+                const sessionEnvelope = {
+                    provider: "opencode-sdk",
+                    version: SUBAGENT_SESSION_VERSION,
+                    handle: { sessionId: resumedSessionId },
+                };
+                const resolvedFinal = finalMessage ?? "";
+                if (options.onEvidence) {
+                    emitProviderEvidence(options.onEvidence, {
+                        type: "checkpoint",
+                        provider: OPENCODE_SDK_PROVIDER,
+                        fence: { kind: "ordinal", ordinal: 1 },
+                        source: "response",
+                    }, (text) => builder.emit({ type: "diagnostic", text }));
+                }
+                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 {
+                if (resumedSessionId) {
+                    appendDebugBlock("opencode-sdk stdout event types", renderEventTypeSummary(recordedEventTypes, totalEventCount), { cwd, section: OPENCODE_SDK_PROVIDER });
+                }
+                await sdk?.close?.();
+                builder.signal.removeEventListener("abort", forward);
+                options.signal?.removeEventListener("abort", forward);
+            }
+        },
+    });
+}