@astrosheep/keiyaku 2.8.5 → 2.9.1

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

@@ -1,363 +0,0 @@
-import { z } from "zod";
-import { FlowError } from "../../flow-error.js";
-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, coerceString, createAbortError, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
-import { activityCallFromNamedTool } from "../harness/activity-values.js";
-import { appendEventType, renderEventTypeSummary } from "./event-type-tail.js";
-/** Identity-only opacity boundary for OpenCode session.prompt variant. */
-function toOpencodeSdkVariant(effort) {
-    return effort;
-}
-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_SDK_PROVIDER = "opencode-sdk";
-function opencodeIngressDisposition(event) {
-    if (event.type === OPENCODE_EVENT_SESSION_IDLE)
-        return "acknowledged-unpersisted";
-    if (event.type === OPENCODE_EVENT_SESSION_ERROR)
-        return "mapped";
-    if (event.type === "message.part.updated" && event.properties.part.type === "tool") {
-        return event.properties.part.state.status === "pending" ? "acknowledged-unpersisted" : "mapped";
-    }
-    return "unknown";
-}
-const OPENCODE_DEFAULT_EXECUTABLE = "opencode";
-const OPENCODE_ASSISTANT_ROLE = "assistant";
-const OPENCODE_TEXT_PART_TYPE = "text";
-let opencodeSdkLoader;
-/**
- * Convert configured opaque OpenCode model string at the first slash into the
- * 1.17.20 prompt model object. No string compatibility path remains.
- */
-export function parseOpencodeModelRef(model) {
-    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),
-        modelID: trimmed.slice(slash + 1),
-    };
-}
-function extractTextFromMessage(message) {
-    if (!message?.parts)
-        return undefined;
-    const text = message.parts
-        .filter((part) => 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;
-}
-function eventSessionId(event) {
-    const properties = event.properties;
-    if (!properties || typeof properties !== "object" || !("sessionID" in properties))
-        return undefined;
-    return typeof properties.sessionID === "string" ? properties.sessionID : undefined;
-}
-function extractToolCall(part) {
-    const input = part.state.input;
-    const stringFact = (primary, fallback) => {
-        const first = input[primary];
-        if (typeof first === "string" && first.length > 0)
-            return first;
-        const second = fallback === undefined ? undefined : input[fallback];
-        return typeof second === "string" && second.length > 0 ? second : undefined;
-    };
-    const integerFact = (key) => {
-        const value = input[key];
-        return typeof value === "number" && Number.isInteger(value) ? value : undefined;
-    };
-    const tool = part.tool.toLowerCase();
-    let facts = {};
-    if (tool === "bash" || tool === "shell") {
-        facts = { command: stringFact("command") };
-    }
-    else if (tool === "read") {
-        facts = {
-            path: stringFact("filePath", "path"),
-            offset: integerFact("offset"),
-            limit: integerFact("limit"),
-        };
-    }
-    else if (tool === "write" || tool === "edit") {
-        facts = { path: stringFact("filePath", "path") };
-    }
-    else if (tool === "grep" || tool === "search" || tool === "glob") {
-        facts = { query: stringFact("pattern", "query") };
-    }
-    const classifierTool = tool === "grep" || tool === "glob" ? "search" : part.tool;
-    return activityCallFromNamedTool(classifierTool, facts);
-}
-function completedResult(state) {
-    const exit = state.metadata.exit;
-    const exitCode = typeof exit === "number" && Number.isInteger(exit) ? exit : undefined;
-    const message = coerceString(state.output);
-    return {
-        status: exitCode !== undefined && exitCode !== 0 ? "error" : "ok",
-        ...(message ? { message } : {}),
-        ...(exitCode === undefined ? {} : { exitCode }),
-    };
-}
-function isToolPartUpdated(event) {
-    return event.type === "message.part.updated" && event.properties.part.type === "tool";
-}
-function sessionErrorMessage(event) {
-    const data = event.properties.error?.data;
-    const message = data && "message" in data ? coerceString(data.message) : undefined;
-    return message ?? `${OPENCODE_SDK_PROVIDER} session error`;
-}
-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(cwd);
-    }
-    const sdk = await createOpencode({
-        executable,
-        directory: cwd,
-        env,
-        signal,
-    });
-    return {
-        client: sdk.client,
-        close: sdk.server?.close,
-    };
-}
-async function awaitSessionIdle(input) {
-    const firstRunning = new Map();
-    const running = new Set();
-    const subscribed = await input.client.event.subscribe({ directory: input.directory });
-    for await (const event of subscribed.stream) {
-        if (eventSessionId(event) !== input.sessionId) {
-            continue;
-        }
-        input.incrementEventCount();
-        appendEventType(input.recordedEventTypes, event.type);
-        let sessionError;
-        input.builder.ingress(OPENCODE_SDK_PROVIDER, event.type, event, opencodeIngressDisposition(event), () => {
-            if (event.type === OPENCODE_EVENT_SESSION_ERROR) {
-                sessionError = sessionErrorMessage(event);
-                input.builder.emit({ type: "diagnostic", text: sessionError });
-                input.builder.emit({ type: "fail", message: sessionError });
-                return;
-            }
-            if (isToolPartUpdated(event)) {
-                const part = event.properties.part;
-                if (part.state.status === "pending")
-                    return;
-                if (part.state.status === "running") {
-                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
-                    if (!firstRunning.has(part.id))
-                        firstRunning.set(part.id, activity);
-                    const phase = running.has(part.id) ? "updated" : "started";
-                    running.add(part.id);
-                    input.builder.emit({ type: "activity", phase, id: part.id, ...activity });
-                }
-                else if (part.state.status === "completed") {
-                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
-                    input.builder.emit({
-                        type: "activity",
-                        phase: "completed",
-                        id: part.id,
-                        ...activity,
-                        result: completedResult(part.state),
-                    });
-                }
-                else if (part.state.status === "error") {
-                    const activity = firstRunning.get(part.id) ?? { tool: part.tool, call: extractToolCall(part) };
-                    input.builder.emit({
-                        type: "activity",
-                        phase: "completed",
-                        id: part.id,
-                        ...activity,
-                        result: { status: "error", message: part.state.error },
-                    });
-                }
-            }
-        });
-        if (sessionError !== undefined)
-            throw new Error(sessionError);
-        if (event.type === OPENCODE_EVENT_SESSION_IDLE) {
-            return;
-        }
-    }
-    const message = `${OPENCODE_SDK_PROVIDER} event stream ended before ${OPENCODE_EVENT_SESSION_IDLE}`;
-    input.builder.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;
-    // A configured value is always intentional. Validate even empty/blank input
-    // before loading the SDK so it cannot silently become the provider default.
-    const modelRef = options.model === undefined ? undefined : parseOpencodeModelRef(options.model);
-    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",
-        initialTurn: options.initialTurn,
-        onIngress: options.onIngress,
-        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`);
-                // OpenCode 1.17.20 session.create has no model field; keep cwd only.
-                const session = sessionId
-                    ? await withAbort(sdk.client.session.get({ sessionID: sessionId, directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`)
-                    : await withAbort(sdk.client.session.create({ directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                resumedSessionId = session.data.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,
-                    builder,
-                    sessionId: activeSessionId,
-                    directory: cwd,
-                    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 textPart = { type: OPENCODE_TEXT_PART_TYPE, text: prompt };
-                builder.emit({ type: "turn", phase: "started" });
-                const promptPromise = sdk.client.session.prompt({
-                    sessionID: activeSessionId,
-                    directory: cwd,
-                    ...(modelRef ? { model: modelRef } : {}),
-                    ...(options.effort ? { variant: toOpencodeSdkVariant(options.effort) } : {}),
-                    parts: [textPart],
-                }, { throwOnError: true });
-                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.data);
-                if (!finalMessage) {
-                    const messages = await withAbort(sdk.client.session.messages({ sessionID: activeSessionId, directory: cwd }, { throwOnError: true }), combined.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-                    finalMessage = extractFinalAssistantMessage(messages.data);
-                }
-                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: "turn", phase: "completed" });
-                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);
-            }
-        },
-    });
-}