@astrosheep/keiyaku 2.8.5 → 2.9.0

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

@@ -0,0 +1,354 @@
+import { activityCallFromNamedTool } from "../../harness/activity-values.js";
+import { AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
+import { coerceString, emitProviderEvidence } from "../../harness/runtime.js";
+import { appendEventType } from "../event-type-tail.js";
+import { OPENCODE_SDK_PROVIDER } from "./session.js";
+const OPENCODE_EVENT_PROMPTED = "session.next.prompted";
+function isSessionDurableEvent(value) {
+    return Boolean(value
+        && typeof value === "object"
+        && "type" in value
+        && typeof value.type === "string"
+        && String(value.type).startsWith("session.next."));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasMappedDurableShape(event) {
+    const data = event.data;
+    switch (event.type) {
+        case "session.next.text.ended":
+            return isRecord(data)
+                && typeof data.assistantMessageID === "string"
+                && typeof data.text === "string";
+        case "session.next.reasoning.ended":
+            return isRecord(data)
+                && typeof data.assistantMessageID === "string"
+                && typeof data.reasoningID === "string"
+                && typeof data.text === "string";
+        case "session.next.tool.called":
+            return isRecord(data)
+                && typeof data.callID === "string"
+                && typeof data.tool === "string"
+                && isRecord(data.input);
+        case "session.next.tool.progress":
+            return isRecord(data) && typeof data.callID === "string";
+        case "session.next.tool.success":
+            return isRecord(data)
+                && typeof data.callID === "string"
+                && Array.isArray(data.content);
+        case "session.next.tool.failed":
+            return isRecord(data)
+                && typeof data.callID === "string"
+                && isRecord(data.error);
+        case "session.next.step.ended":
+            return isRecord(data)
+                && isRecord(data.tokens)
+                && typeof data.tokens.input === "number"
+                && Number.isFinite(data.tokens.input)
+                && typeof data.tokens.output === "number"
+                && Number.isFinite(data.tokens.output);
+        case "session.next.step.failed":
+            return isRecord(data) && isRecord(data.error);
+        default:
+            return true;
+    }
+}
+function durableSeq(event) {
+    const durable = event.durable;
+    return durable && typeof durable.seq === "number" && Number.isFinite(durable.seq) ? durable.seq : undefined;
+}
+function extractToolCall(tool, 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 lower = tool.toLowerCase();
+    let facts = {};
+    if (lower === "bash" || lower === "shell") {
+        facts = { command: stringFact("command") };
+    }
+    else if (lower === "read") {
+        facts = {
+            path: stringFact("filePath", "path"),
+            offset: integerFact("offset"),
+            limit: integerFact("limit"),
+        };
+    }
+    else if (lower === "write" || lower === "edit") {
+        facts = { path: stringFact("filePath", "path") };
+    }
+    else if (lower === "grep" || lower === "search" || lower === "glob") {
+        facts = { query: stringFact("pattern", "query") };
+    }
+    const classifierTool = lower === "grep" || lower === "glob" ? "search" : tool;
+    return activityCallFromNamedTool(classifierTool, facts);
+}
+function toolResultFromSuccess(event) {
+    const text = event.data.content
+        .map((part) => {
+        const value = part;
+        return isRecord(value) && typeof value.text === "string" ? value.text : "";
+    })
+        .join("");
+    const message = text.trim() || undefined;
+    return { status: "ok", ...(message ? { message } : {}) };
+}
+function toolResultFromFailure(event) {
+    const message = coerceString(event.data.error?.message);
+    return { status: "error", ...(message ? { message } : {}) };
+}
+function extractAssistantText(message) {
+    const text = message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("");
+    return text.trim() || undefined;
+}
+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 recordedEventTypes = [];
+    let totalEventCount = 0;
+    let currentTurnAdmitted = false;
+    let currentTurnFailure;
+    let lastTurnFailure;
+    let lastSeenSeq = 0;
+    let turnOpen = false;
+    const toolCalls = new Map();
+    const requestDelivery = (steerControl) => {
+        try {
+            onDeliveryOpportunity?.(steerControl);
+        }
+        catch {
+            // Delivery observation cannot alter provider control flow.
+        }
+    };
+    const openTurn = () => {
+        if (turnOpen)
+            builder.emit({ type: "turn", phase: "completed" });
+        builder.emit({ type: "turn", phase: "started" });
+        turnOpen = true;
+    };
+    const closeTurn = () => {
+        if (!turnOpen)
+            return;
+        builder.emit({ type: "turn", phase: "completed" });
+        turnOpen = false;
+    };
+    const clearLastTurnFailureOnTerminalEvidence = () => {
+        if (currentTurnAdmitted && currentTurnFailure === undefined) {
+            lastTurnFailure = undefined;
+        }
+    };
+    const mapDurableEvent = (event) => {
+        const seq = durableSeq(event);
+        if (seq !== undefined && seq > lastSeenSeq)
+            lastSeenSeq = seq;
+        totalEventCount += 1;
+        appendEventType(recordedEventTypes, event.type);
+        if (!hasMappedDurableShape(event)) {
+            builder.ingress(OPENCODE_SDK_PROVIDER, event.type, event, "unknown", () => undefined);
+            requestDelivery(control);
+            return;
+        }
+        builder.ingress(OPENCODE_SDK_PROVIDER, event.type, event, "mapped", () => {
+            switch (event.type) {
+                case OPENCODE_EVENT_PROMPTED: {
+                    currentTurnAdmitted = true;
+                    currentTurnFailure = undefined;
+                    openTurn();
+                    if (seq !== undefined) {
+                        const checkpoint = { fence: { kind: "ordinal", ordinal: seq }, consumptionEvidence: true };
+                        if (onEvidence) {
+                            emitProviderEvidence(onEvidence, { type: "checkpoint", provider: OPENCODE_SDK_PROVIDER, fence: checkpoint.fence, source: "notification" }, (text) => builder.emit({ type: "diagnostic", text }));
+                        }
+                        onSyncCheckpoint?.(control, checkpoint);
+                    }
+                    break;
+                }
+                case "session.next.text.ended": {
+                    const text = coerceString(event.data.text)?.trim();
+                    if (text) {
+                        builder.emit({
+                            type: "message",
+                            id: event.data.assistantMessageID || "opencode-text",
+                            text,
+                        });
+                    }
+                    clearLastTurnFailureOnTerminalEvidence();
+                    break;
+                }
+                case "session.next.reasoning.ended": {
+                    const text = coerceString(event.data.text) ?? "";
+                    if (!text)
+                        break;
+                    const truncated = text.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
+                    builder.emit({
+                        type: "thought",
+                        id: event.data.reasoningID || event.data.assistantMessageID || "opencode-reasoning",
+                        text: text.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
+                        final: true,
+                        ...(truncated ? { truncated: true } : {}),
+                    });
+                    break;
+                }
+                case "session.next.tool.called": {
+                    const call = extractToolCall(event.data.tool, event.data.input);
+                    toolCalls.set(event.data.callID, { tool: event.data.tool, call });
+                    builder.emit({
+                        type: "activity",
+                        phase: "started",
+                        id: event.data.callID,
+                        tool: event.data.tool,
+                        call,
+                    });
+                    break;
+                }
+                case "session.next.tool.success": {
+                    const prior = toolCalls.get(event.data.callID);
+                    const call = prior?.call ?? { kind: "other", display: "tool" };
+                    const tool = prior?.tool ?? "tool";
+                    builder.emit({
+                        type: "activity",
+                        phase: "completed",
+                        id: event.data.callID,
+                        tool,
+                        call,
+                        result: toolResultFromSuccess(event),
+                    });
+                    toolCalls.delete(event.data.callID);
+                    break;
+                }
+                case "session.next.tool.failed": {
+                    const prior = toolCalls.get(event.data.callID);
+                    const call = prior?.call ?? { kind: "other", display: "tool" };
+                    const tool = prior?.tool ?? "tool";
+                    builder.emit({
+                        type: "activity",
+                        phase: "completed",
+                        id: event.data.callID,
+                        tool,
+                        call,
+                        result: toolResultFromFailure(event),
+                    });
+                    toolCalls.delete(event.data.callID);
+                    break;
+                }
+                case "session.next.tool.progress": {
+                    const prior = toolCalls.get(event.data.callID);
+                    builder.emit({
+                        type: "activity",
+                        phase: "updated",
+                        id: event.data.callID,
+                        tool: prior?.tool ?? "tool",
+                        call: prior?.call ?? { kind: "other", display: "tool" },
+                    });
+                    break;
+                }
+                case "session.next.step.ended": {
+                    const tokens = event.data.tokens;
+                    builder.emit({
+                        type: "usage",
+                        inputTokens: tokens.input,
+                        outputTokens: tokens.output,
+                    });
+                    clearLastTurnFailureOnTerminalEvidence();
+                    break;
+                }
+                case "session.next.step.failed": {
+                    const message = coerceString(event.data.error?.message) ?? `${OPENCODE_SDK_PROVIDER} step failed`;
+                    const failure = new Error(message);
+                    currentTurnFailure = failure;
+                    lastTurnFailure = failure;
+                    builder.emit({ type: "diagnostic", text: message });
+                    builder.emit({ type: "fail", message });
+                    break;
+                }
+                default:
+                    break;
+            }
+        });
+        requestDelivery(control);
+    };
+    const processUnknownStreamItem = (item) => {
+        idleMonitorIngress();
+        if (isSessionDurableEvent(item)) {
+            mapDurableEvent(item);
+            return;
+        }
+        if (item && typeof item === "object" && "data" in item) {
+            const data = item.data;
+            if (typeof data === "string") {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (isSessionDurableEvent(parsed)) {
+                        mapDurableEvent(parsed);
+                        return;
+                    }
+                }
+                catch {
+                    // fall through to unknown
+                }
+            }
+            else if (isSessionDurableEvent(data)) {
+                mapDurableEvent(data);
+                return;
+            }
+        }
+        const nativeType = item && typeof item === "object" && "type" in item && typeof item.type === "string"
+            ? item.type
+            : item && typeof item === "object" && "event" in item && typeof item.event === "string"
+                ? item.event
+                : "session.event";
+        builder.ingress(OPENCODE_SDK_PROVIDER, nativeType, item, "unknown", () => undefined);
+        requestDelivery(control);
+    };
+    const drainHistory = async (after) => {
+        let cursor = after;
+        for (;;) {
+            const priorCursor = cursor;
+            const page = await client.v2.session.history({ sessionID: getSessionId(), after: cursor }, { throwOnError: true, signal: options.executionSignal });
+            const body = page.data;
+            const events = body.data ?? [];
+            for (const event of events) {
+                if (!isSessionDurableEvent(event)) {
+                    builder.ingress(OPENCODE_SDK_PROVIDER, "session.history", event, "unknown", () => undefined);
+                    requestDelivery(control);
+                    continue;
+                }
+                const seq = durableSeq(event);
+                if (seq !== undefined && seq <= cursor)
+                    continue;
+                mapDurableEvent(event);
+                if (seq !== undefined)
+                    cursor = seq;
+            }
+            if (!body.hasMore || events.length === 0 || cursor === priorCursor)
+                break;
+        }
+    };
+    return {
+        processUnknownStreamItem,
+        drainHistory,
+        closeTurn,
+        lastSeenSeq: () => lastSeenSeq,
+        lastTurnFailure: () => lastTurnFailure,
+        recordedEventTypes: () => recordedEventTypes,
+        totalEventCount: () => totalEventCount,
+        finalAssistantText(messages) {
+            const finalAssistant = extractFinalAssistantMessage(messages);
+            const finalMessage = finalAssistant ? extractAssistantText(finalAssistant) : undefined;
+            return { finalAssistant, finalMessage };
+        },
+    };
+}

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

@@ -0,0 +1,180 @@
+import { createOpencode } from "../../opencode-sdk.js";
+import { coerceString, createAbortError } from "../../harness/runtime.js";
+export const OPENCODE_SDK_PROVIDER = "opencode-sdk";
+export const OPENCODE_DEFAULT_EXECUTABLE = "opencode";
+const OPENCODE_COMPLETE_EVENT_TRAILING_DEBOUNCE_MS = 200;
+const OPENCODE_SILENT_FALLBACK_INITIAL_MS = 1_000;
+const OPENCODE_SILENT_FALLBACK_MAX_MS = 5_000;
+export class OpencodeIdleMonitor {
+    session;
+    sessionId;
+    signal;
+    cycle;
+    resolveCycle;
+    rejectCycle;
+    timer;
+    queryRunning = false;
+    ingressEpoch = 0;
+    settledIngressEpoch = 0;
+    observedIngressEpoch = 0;
+    fallbackDelayMs = OPENCODE_SILENT_FALLBACK_INITIAL_MS;
+    disposed = false;
+    constructor(session, sessionId, signal) {
+        this.session = session;
+        this.sessionId = sessionId;
+        this.signal = signal;
+        this.signal.addEventListener("abort", this.onAbort, { once: true });
+    }
+    waitForIdle() {
+        if (this.disposed)
+            return Promise.reject(createAbortError(`${OPENCODE_SDK_PROVIDER} exec cancelled by client`));
+        if (this.cycle)
+            return this.cycle;
+        this.cycle = new Promise((resolve, reject) => {
+            this.resolveCycle = resolve;
+            this.rejectCycle = reject;
+        });
+        this.observedIngressEpoch = this.settledIngressEpoch;
+        this.query();
+        return this.cycle;
+    }
+    ingress() {
+        this.ingressEpoch += 1;
+        if (!this.cycle)
+            return;
+        this.fallbackDelayMs = OPENCODE_SILENT_FALLBACK_INITIAL_MS;
+        this.clearTimer();
+        if (!this.queryRunning)
+            this.scheduleTrailingQuery();
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.clearTimer();
+        this.signal.removeEventListener("abort", this.onAbort);
+        this.fail(createAbortError(`${OPENCODE_SDK_PROVIDER} exec cancelled by client`));
+    }
+    onAbort = () => {
+        this.dispose();
+    };
+    clearTimer() {
+        if (this.timer === undefined)
+            return;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    schedule(delayMs) {
+        if (!this.cycle || this.disposed)
+            return;
+        this.clearTimer();
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.query();
+        }, delayMs);
+    }
+    scheduleTrailingQuery() {
+        this.observedIngressEpoch = this.ingressEpoch;
+        this.schedule(OPENCODE_COMPLETE_EVENT_TRAILING_DEBOUNCE_MS);
+    }
+    finish() {
+        this.clearTimer();
+        const resolve = this.resolveCycle;
+        this.cycle = undefined;
+        this.resolveCycle = undefined;
+        this.rejectCycle = undefined;
+        this.settledIngressEpoch = this.ingressEpoch;
+        this.fallbackDelayMs = OPENCODE_SILENT_FALLBACK_INITIAL_MS;
+        resolve?.();
+    }
+    fail(error) {
+        this.clearTimer();
+        const reject = this.rejectCycle;
+        this.cycle = undefined;
+        this.resolveCycle = undefined;
+        this.rejectCycle = undefined;
+        reject?.(error);
+    }
+    async query() {
+        if (!this.cycle || this.queryRunning || this.disposed)
+            return;
+        this.queryRunning = true;
+        const queryIngressEpoch = this.ingressEpoch;
+        const hadUnobservedIngress = queryIngressEpoch > this.observedIngressEpoch;
+        this.observedIngressEpoch = queryIngressEpoch;
+        try {
+            const response = await withAbort(this.session.active({ throwOnError: true, signal: this.signal }), this.signal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
+            if (!this.cycle || this.disposed)
+                return;
+            const active = response.data.data;
+            if (this.ingressEpoch > queryIngressEpoch) {
+                this.scheduleTrailingQuery();
+                return;
+            }
+            if (!Object.prototype.hasOwnProperty.call(active, this.sessionId)) {
+                this.finish();
+                return;
+            }
+            if (hadUnobservedIngress) {
+                this.scheduleTrailingQuery();
+            }
+            else {
+                const delayMs = this.fallbackDelayMs;
+                this.fallbackDelayMs = Math.min(delayMs * 2, OPENCODE_SILENT_FALLBACK_MAX_MS);
+                this.schedule(delayMs);
+            }
+        }
+        catch (error) {
+            this.fail(error);
+        }
+        finally {
+            this.queryRunning = false;
+            if (this.ingressEpoch > this.observedIngressEpoch && this.timer === undefined && !this.disposed) {
+                this.scheduleTrailingQuery();
+            }
+        }
+    }
+}
+let opencodeSdkLoader;
+export function sessionIdFrom(info, fallback) {
+    return coerceString(info.id) ?? fallback;
+}
+export 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);
+        });
+    });
+}
+export 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,
+    };
+}
+export function setOpencodeSdkLoaderForTests(loader) {
+    opencodeSdkLoader = loader;
+}
+export function resetOpencodeSdkLoaderForTests() {
+    opencodeSdkLoader = undefined;
+}