@astrosheep/keiyaku 2.9.13 → 4.0.0

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

@@ -1,380 +0,0 @@
-import { exactLaunchInputReceipts } from "../../harness/control-types.js";
-import { activityCallFromNamedTool } from "../../harness/activity-values.js";
-import { AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
-import { createProviderFailure } from "../../harness/provider-adapter.js";
-import { coerceString, emitProviderEvidence } from "../../harness/runtime.js";
-import { appendEventType } from "../event-type-tail.js";
-import { OPENCODE_SDK_PROVIDER, withAbort } 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, idleMonitorTerminal, onEvidence, onSyncCheckpoint, onDeliveryOpportunity, onTellReceipt, listLaunchAdmissions, getSessionId, client, } = options;
-    const recordedEventTypes = [];
-    let totalEventCount = 0;
-    let currentTurnAdmitted = false;
-    let currentTurnFailure;
-    let lastTurnFailure;
-    let lastSeenSeq = 0;
-    let turnOpen = false;
-    const promptedFences = [];
-    const emittedLaunchReceiptKeys = new Set();
-    const toolCalls = new Map();
-    const requestDelivery = (steerControl) => {
-        try {
-            onDeliveryOpportunity?.(steerControl);
-        }
-        catch {
-            // Delivery observation cannot alter provider control flow.
-        }
-    };
-    const reconcileLaunchAdmissions = () => {
-        for (const fence of promptedFences) {
-            const admissions = (listLaunchAdmissions?.() ?? []).filter((admission) => (admission.fence.kind === "ordinal" && fence.kind === "ordinal"
-                && admission.fence.ordinal <= fence.ordinal));
-            for (const receipt of exactLaunchInputReceipts("seen", fence, admissions)) {
-                if (fence.kind !== "ordinal" || receipt.correlation.kind !== "exact")
-                    continue;
-                const key = `${receipt.stage}:${fence.ordinal}:${receipt.correlation.tellId}`;
-                if (emittedLaunchReceiptKeys.has(key))
-                    continue;
-                emittedLaunchReceiptKeys.add(key);
-                onTellReceipt?.(receipt);
-            }
-        }
-    };
-    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 } };
-                        if (onEvidence) {
-                            emitProviderEvidence(onEvidence, { type: "checkpoint", provider: OPENCODE_SDK_PROVIDER, fence: checkpoint.fence, source: "notification" }, (text) => builder.emit({ type: "diagnostic", text }));
-                        }
-                        onSyncCheckpoint?.(control, checkpoint);
-                        promptedFences.push(checkpoint.fence);
-                        reconcileLaunchAdmissions();
-                        onTellReceipt?.({ stage: "seen", correlation: { kind: "fence", fence: checkpoint.fence } });
-                    }
-                    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();
-                    idleMonitorTerminal();
-                    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();
-                    idleMonitorTerminal();
-                    break;
-                }
-                case "session.next.step.failed": {
-                    const message = coerceString(event.data.error?.message) ?? `${OPENCODE_SDK_PROVIDER} step failed`;
-                    const failure = createProviderFailure(message);
-                    currentTurnFailure = failure;
-                    lastTurnFailure = failure;
-                    builder.emit({ type: "diagnostic", text: message });
-                    builder.emit({ type: "fail", message });
-                    idleMonitorTerminal();
-                    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 withAbort(client.v2.session.history({ sessionID: getSessionId(), after: cursor }, { throwOnError: true, signal: options.executionSignal }), options.executionSignal, `${OPENCODE_SDK_PROVIDER} exec cancelled by client`);
-            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,
-        reconcileLaunchAdmissions,
-        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/registration.js

@@ -1,146 +0,0 @@
-import { z } from "zod";
-import { executableSchema, providerCommonFields, providerEnvSchema, } from "../../../config/settings/provider-instance-fields.js";
-import { FlowError } from "../../../flow-error.js";
-import { exactKeys, optionalString, optionalStringRecord, } from "../../launch-snapshot/parse-helpers.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../../session.js";
-import { OPENCODE_SDK_PROVIDER } from "./session.js";
-import { opencodeSessionSchema } from "./session-schema.js";
-const startOpencode = async (prompt, cwd, options) => {
-    const { startOpencode: start } = await import("./adapter.js");
-    return start(prompt, cwd, options);
-};
-function admitResumeShape(schema, session, resumePath) {
-    const envelopeResult = subagentSessionEnvelopeSchema.safeParse(session);
-    if (!envelopeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session envelope.`);
-    }
-    if (session.provider !== OPENCODE_SDK_PROVIDER) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${OPENCODE_SDK_PROVIDER}'. Cross-provider resume is not supported.`);
-    }
-    if (session.version !== SUBAGENT_SESSION_VERSION) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' uses unsupported session version '${session.version}' for provider '${session.provider}'.`);
-    }
-    const shapeResult = schema.safeParse(session.handle);
-    if (!shapeResult.success) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' includes an invalid session handle for provider '${session.provider}'.`);
-    }
-    return shapeResult.data;
-}
-export const opencodeSdkRegistration = {
-    name: OPENCODE_SDK_PROVIDER,
-    start: startOpencode,
-    sessionSchema: opencodeSessionSchema,
-    effortField: "effort",
-    instanceSchema: z
-        .object({
-        kind: z.literal(OPENCODE_SDK_PROVIDER),
-        ...providerCommonFields,
-        executable: executableSchema.optional(),
-        env: providerEnvSchema,
-    })
-        .strict(),
-    builtinInstance: {
-        name: OPENCODE_SDK_PROVIDER,
-        source: "builtin",
-        instance: { kind: OPENCODE_SDK_PROVIDER, executable: "opencode" },
-    },
-    portablePolicy: {
-        access: new Set(),
-        network: new Set(),
-        webSearch: new Set(),
-    },
-    maxCaptureChars: (config) => config.opencode.execMaxCaptureChars,
-    sessionContinuationPromptPrefix: (body) => `[Akuma system prompt]\n${body}\n\n[Operator prompt]\n`,
-    buildCallTerms: ({ snapshot, baseTerms, replayPrompt }) => {
-        const provider = snapshot.provider;
-        return {
-            ...baseTerms,
-            prompt: replayPrompt,
-            provider: OPENCODE_SDK_PROVIDER,
-            ...(provider.model !== undefined ? { model: provider.model } : {}),
-            ...(provider.effort !== undefined ? { effort: provider.effort } : {}),
-            ...(provider.executable !== undefined ? { executable: provider.executable } : {}),
-            ...(provider.env !== undefined ? { env: provider.env } : {}),
-        };
-    },
-    resolveLaunchProvider: ({ common, instance, model, effort }) => {
-        if (instance.kind !== OPENCODE_SDK_PROVIDER) {
-            throw new Error(`resolveLaunchProvider expected ${OPENCODE_SDK_PROVIDER}`);
-        }
-        const opencodeInstance = instance;
-        return Object.freeze({
-            ...common,
-            kind: OPENCODE_SDK_PROVIDER,
-            ...(opencodeInstance.executable !== undefined ? { executable: opencodeInstance.executable } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(opencodeInstance.env !== undefined ? { env: opencodeInstance.env } : {}),
-        });
-    },
-    parseLaunchProvider: (provider, common) => {
-        exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort", "env"], "provider");
-        const executable = optionalString(provider, "executable", "provider");
-        const model = optionalString(provider, "model", "provider");
-        const effort = optionalString(provider, "effort", "provider");
-        const env = optionalStringRecord(provider, "env");
-        return Object.freeze({
-            ...common,
-            kind: OPENCODE_SDK_PROVIDER,
-            ...(executable !== undefined ? { executable } : {}),
-            ...(model !== undefined ? { model } : {}),
-            ...(effort !== undefined ? { effort } : {}),
-            ...(env !== undefined ? { env } : {}),
-        });
-    },
-    applyEffort: (provider, effort) => Object.freeze({ ...provider, effort }),
-    providerEffortAndModel: (provider) => {
-        const resolved = provider;
-        return { model: resolved.model, effort: resolved.effort };
-    },
-    attachLoader: (terms, ports) => {
-        if (terms.provider !== OPENCODE_SDK_PROVIDER)
-            return terms;
-        const loader = ports.opencodeSdk;
-        return loader ? { ...terms, loader } : terms;
-    },
-    nativePolicyOwnership: () => null,
-    tellReceiptCapabilities: { seen: "fence", consumed: "unavailable" },
-    startLive: async ({ terms, signal, reviveTerms, onSyncCheckpoint, onDeliveryOpportunity, onSessionAdmission, onIngress, launchTellIds, observer, }) => {
-        if (terms.provider !== OPENCODE_SDK_PROVIDER) {
-            throw new Error(`startLive expected ${OPENCODE_SDK_PROVIDER}`);
-        }
-        const opencodeTerms = terms;
-        const options = {
-            model: opencodeTerms.model,
-            effort: opencodeTerms.effort,
-            executable: opencodeTerms.executable,
-            env: opencodeTerms.env,
-            signal,
-            onSyncCheckpoint,
-            onDeliveryOpportunity,
-            onTellReceipt: observer ? (receipt) => {
-                try {
-                    observer.onTellReceipt(receipt);
-                }
-                catch { /* Receipt persistence cannot alter provider control. */ }
-            } : undefined,
-            launchTellIds,
-            onLaunchAdmission: observer ? (admission) => observer.onLaunchAdmission(admission) : undefined,
-            listLaunchAdmissions: observer ? () => observer.listLaunchAdmissions() : undefined,
-            onEvidence: opencodeTerms.onEvidence,
-            onSessionAdmission,
-            onIngress,
-            initialTurn: opencodeTerms.initialTurn,
-            loader: opencodeTerms.loader,
-        };
-        const { startOpencode: start } = await import("./adapter.js");
-        if (reviveTerms) {
-            const session = admitResumeShape(opencodeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-            return start(opencodeTerms.prompt, opencodeTerms.workdir, {
-                ...options,
-                sessionId: session.sessionId,
-            });
-        }
-        return start(opencodeTerms.prompt, opencodeTerms.workdir, options);
-    },
-};

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

@@ -1,2 +0,0 @@
-import { z } from "zod";
-export const opencodeSessionSchema = z.object({ sessionId: z.string().trim().min(1) });