@astrosheep/keiyaku 2.9.12 → 4.0.0

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

@@ -1,187 +0,0 @@
-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;
-    observedActive = false;
-    terminalObserved = false;
-    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();
-    }
-    terminal() {
-        this.terminalObserved = true;
-    }
-    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;
-        this.observedActive = false;
-        this.terminalObserved = false;
-        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 (hadUnobservedIngress) {
-                this.scheduleTrailingQuery();
-            }
-            else if (Object.prototype.hasOwnProperty.call(active, this.sessionId)) {
-                this.observedActive = true;
-                const delayMs = this.fallbackDelayMs;
-                this.fallbackDelayMs = Math.min(delayMs * 2, OPENCODE_SILENT_FALLBACK_MAX_MS);
-                this.schedule(delayMs);
-            }
-            else if (this.observedActive ||
-                this.terminalObserved ||
-                this.ingressEpoch === this.settledIngressEpoch) {
-                this.finish();
-            }
-            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();
-            }
-        }
-    }
-}
-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, loader) {
-    if (loader)
-        return loader(cwd);
-    const sdk = await createOpencode({
-        executable,
-        directory: cwd,
-        env,
-        signal,
-    });
-    return {
-        client: sdk.client,
-        close: sdk.server?.close,
-    };
-}

package/build/agents/providers/pi/adapter.js

@@ -1,285 +0,0 @@
-import { FlowError } from "../../../flow-error.js";
-import { appendDebugLog } from "../../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION, } from "../../session.js";
-import { createProjectionDriver } from "../../harness/execution-handle.js";
-import { createProviderFailure, toProviderTerminalError, } from "../../harness/provider-adapter.js";
-import { createAbortError, emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
-import { createPiCheckpointController, PI_PROVIDER, toPiSdkThinkingLevel, } from "./checkpoint.js";
-import { bindPiSessionEvents } from "./events.js";
-export { piSessionSchema } from "./session-schema.js";
-/** Exact model shape: `<provider>/<id>` (single slash separating non-empty sides). */
-const PI_MODEL_PATTERN = /^[^/]+\/[^/]+$/;
-const importPiSdk = new Function("specifier", "return import(specifier)");
-async function loadPiSdk(loader) {
-    if (loader) {
-        return loader();
-    }
-    return (await importPiSdk("@earendil-works/pi-coding-agent"));
-}
-export function parsePiModelRef(model) {
-    const trimmed = model.trim();
-    if (!PI_MODEL_PATTERN.test(trimmed)) {
-        throw new FlowError("INVALID_SETTINGS", `Invalid pi model '${model}'. Expected exact shape '<provider>/<id>'.`);
-    }
-    const slash = trimmed.indexOf("/");
-    return {
-        provider: trimmed.slice(0, slash),
-        id: trimmed.slice(slash + 1),
-    };
-}
-export async function startPi(prompt, cwd, options = {}) {
-    // Pre-driver awaits (sdk/session/model/resource/createAgentSession) sit outside
-    // createProjectionDriver's run gate; map every startup throw to the typed
-    // terminal boundary here. FlowError (settings shape) remains unnormalized.
-    try {
-        return await openPiProjectionDriver(prompt, cwd, options);
-    }
-    catch (error) {
-        if (error instanceof FlowError)
-            throw error;
-        throw toProviderTerminalError(error);
-    }
-}
-async function openPiProjectionDriver(prompt, cwd, options) {
-    // Pre-driver cancellation is immediately signal-cancellable — check before any SDK work.
-    if (options.signal?.aborted) {
-        throw createAbortError(`${PI_PROVIDER} exec cancelled by client`, options.signal.reason);
-    }
-    const resumeSessionFile = options.sessionFile?.trim();
-    appendDebugLog(`startPi: mode=${resumeSessionFile ? "resume" : "fresh"} model=${options.model ?? "default"}`, { cwd, section: PI_PROVIDER });
-    const sdk = await loadPiSdk(options.loader);
-    const sessionManagerApi = readSessionManager(sdk);
-    const sessionManager = resumeSessionFile
-        ? sessionManagerApi.open(resumeSessionFile)
-        : sessionManagerApi.create(cwd);
-    let model;
-    let modelRuntime;
-    if (options.model !== undefined && options.model.trim().length > 0) {
-        const original = options.model.trim();
-        const ref = parsePiModelRef(original);
-        modelRuntime = await sdk.ModelRuntime.create();
-        model = modelRuntime.getModel(ref.provider, ref.id);
-        if (!model) {
-            throw createProviderFailure(`${PI_PROVIDER} model '${original}' is not available`, { code: "SUBAGENT_PROVIDER_UNAVAILABLE" });
-        }
-    }
-    // With an Akuma body, retain the default loader's discovery and override only its append list.
-    // The override deliberately suppresses discovered APPEND_SYSTEM.md content.
-    if (options.appendSystemPromptOverride && (!sdk.DefaultResourceLoader || !sdk.getAgentDir)) {
-        throw createProviderFailure(`${PI_PROVIDER} SDK does not expose DefaultResourceLoader and getAgentDir`);
-    }
-    let emittedAppendEvidence = false;
-    let pendingEvidenceDiagnostics = 0;
-    let reportEvidenceDiagnostic = () => {
-        pendingEvidenceDiagnostics += 1;
-        appendDebugLog("provider evidence callback failed before Pi driver start", { cwd, section: PI_PROVIDER });
-    };
-    const observedAppendOverride = options.appendSystemPromptOverride && options.onEvidence
-        ? () => {
-            const body = options.appendSystemPromptOverride();
-            if (!emittedAppendEvidence) {
-                emittedAppendEvidence = true;
-                emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "system-prompt", ...sha256Utf8(body.join("\n")) }, reportEvidenceDiagnostic);
-            }
-            return body;
-        }
-        : options.appendSystemPromptOverride;
-    const resourceLoader = observedAppendOverride
-        ? new sdk.DefaultResourceLoader({
-            cwd,
-            agentDir: sdk.getAgentDir(),
-            appendSystemPromptOverride: observedAppendOverride,
-        })
-        : undefined;
-    await resourceLoader?.reload();
-    if (options.signal?.aborted) {
-        throw createAbortError(`${PI_PROVIDER} exec cancelled by client`, options.signal.reason);
-    }
-    // Empty bodies retain the SDK's default ResourceLoader path unchanged.
-    const created = await sdk.createAgentSession({
-        cwd,
-        sessionManager,
-        ...(options.thinkingLevel ? { thinkingLevel: toPiSdkThinkingLevel(options.thinkingLevel) } : {}),
-        ...(model ? { model, modelRuntime } : {}),
-        ...(resourceLoader ? { resourceLoader } : {}),
-    });
-    const session = created.session;
-    if (session.sessionFile) {
-        options.onSessionAdmission?.({
-            session: {
-                provider: PI_PROVIDER,
-                version: SUBAGENT_SESSION_VERSION,
-                handle: { sessionId: session.sessionId, sessionFile: session.sessionFile },
-            },
-        });
-    }
-    if (options.onEvidence)
-        emitProviderEvidence(options.onEvidence, { type: "session", provider: PI_PROVIDER, sessionId: session.sessionId, ...(session.sessionFile ? { sessionFile: session.sessionFile } : {}) }, reportEvidenceDiagnostic);
-    session.setSteeringMode("one-at-a-time");
-    const checkpointController = createPiCheckpointController(session, {
-        onEvidence: options.onEvidence,
-        diagnostic: () => reportEvidenceDiagnostic,
-        onSyncCheckpoint: options.onSyncCheckpoint,
-    });
-    let disposed = false;
-    let unsub;
-    const disposeSession = (propagate = false) => {
-        if (disposed)
-            return;
-        disposed = true;
-        unsub?.();
-        try {
-            session.dispose();
-        }
-        catch (error) {
-            if (propagate)
-                throw error;
-        }
-    };
-    let resolveRunSettled;
-    const runSettled = new Promise((resolve) => {
-        resolveRunSettled = resolve;
-    });
-    let activePrompt;
-    let activeState;
-    let abortRequested;
-    const requestAbort = async (state) => {
-        state.abortIntent = true;
-        if (abortRequested) {
-            await abortRequested;
-            return;
-        }
-        abortRequested = (async () => {
-            // Publish abortRequested before clearQueue can synchronously emit queue_update.
-            await Promise.resolve();
-            try {
-                session.clearQueue();
-                await session.abort();
-            }
-            finally {
-                if (state.settled) {
-                    disposeSession();
-                }
-            }
-        })();
-        await abortRequested;
-    };
-    return createProjectionDriver({
-        steerMode: "mid-execution",
-        initialTurn: options.initialTurn,
-        enqueue: checkpointController.enqueue,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            const state = activeState ?? { abortIntent: true, settled: false };
-            if (mode !== "force") {
-                await requestAbort(state);
-                return;
-            }
-            let failure;
-            try {
-                await requestAbort(state);
-            }
-            catch (error) {
-                failure = error;
-            }
-            try {
-                disposeSession(true);
-            }
-            catch (error) {
-                failure ??= error;
-            }
-            await activePrompt;
-            await runSettled;
-            if (failure !== undefined)
-                throw failure;
-        },
-        async run(builder) {
-            reportEvidenceDiagnostic = () => builder.emit({ type: "diagnostic", text: "provider evidence callback failed" });
-            checkpointController.setTurnStartedEmitter(() => builder.emit({ type: "turn", phase: "started" }));
-            while (pendingEvidenceDiagnostics > 0) {
-                pendingEvidenceDiagnostics -= 1;
-                reportEvidenceDiagnostic();
-            }
-            const state = {
-                abortIntent: false,
-                lastAssistantMessage: "",
-                settled: false,
-                thoughtTurnOrdinal: 0,
-                assistantMessageOrdinal: -1,
-                activityCalls: new Map(),
-            };
-            activeState = state;
-            let settleOutcome;
-            const outcome = new Promise((resolve, reject) => {
-                settleOutcome = {
-                    resolve(value) {
-                        if (state.settled)
-                            return;
-                        state.settled = true;
-                        resolve(value);
-                    },
-                    reject(error) {
-                        if (state.settled)
-                            return;
-                        state.settled = true;
-                        reject(error);
-                    },
-                };
-                unsub = bindPiSessionEvents(session, builder, checkpointController, state, settleOutcome);
-            });
-            outcome.catch(() => undefined);
-            const onAbort = () => {
-                void requestAbort(state)
-                    .catch((error) => {
-                    settleOutcome.reject(error);
-                })
-                    .finally(() => {
-                    if (!state.settled) {
-                        settleOutcome.reject(createAbortError(`${PI_PROVIDER} exec cancelled by client`));
-                    }
-                });
-            };
-            builder.signal.addEventListener("abort", onAbort, { once: true });
-            options.signal?.addEventListener("abort", onAbort, { once: true });
-            try {
-                if (builder.signal.aborted || options.signal?.aborted) {
-                    await requestAbort(state);
-                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
-                }
-                activePrompt = session.prompt(prompt).catch((error) => {
-                    if (state.settled) {
-                        return;
-                    }
-                    settleOutcome.reject(state.abortIntent ? createAbortError(`${PI_PROVIDER} exec cancelled by client`) : error);
-                });
-                const result = await outcome;
-                await activePrompt;
-                return result;
-            }
-            catch (error) {
-                if (state.abortIntent) {
-                    throw createAbortError(`${PI_PROVIDER} exec cancelled by client`);
-                }
-                throw error;
-            }
-            finally {
-                activeState = undefined;
-                builder.signal.removeEventListener("abort", onAbort);
-                options.signal?.removeEventListener("abort", onAbort);
-                await abortRequested?.catch(() => undefined);
-                try {
-                    disposeSession();
-                }
-                finally {
-                    resolveRunSettled();
-                }
-            }
-        },
-    });
-}
-// Compiler-level binding to the named ProviderAdapter function contract.
-startPi;
-function readSessionManager(sdk) {
-    const store = sdk[`Session${"Man"}${"ager"}`];
-    return store;
-}

package/build/agents/providers/pi/checkpoint.js

@@ -1,49 +0,0 @@
-import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
-export const PI_PROVIDER = "pi";
-export function toPiSdkThinkingLevel(effort) {
-    return effort; // opacity boundary
-}
-export function normalizeClearQueue(result) {
-    if (Array.isArray(result))
-        return result;
-    return [...(result.steering ?? []), ...(result.followUp ?? [])];
-}
-export function createPiCheckpointController(session, options) {
-    let submittedTurnOrdinal = 0;
-    let emitTurnStarted;
-    const enqueue = async (tell) => {
-        if (options.onEvidence)
-            emitProviderEvidence(options.onEvidence, { type: "outbound", provider: PI_PROVIDER, direction: "input", kind: "steer", ...sha256Utf8(tell.text) }, options.diagnostic());
-        if (tell.effort) {
-            if (!session.setThinkingLevel)
-                throw new Error(`${PI_PROVIDER} session does not support thinking level control`);
-            session.setThinkingLevel(toPiSdkThinkingLevel(tell.effort));
-        }
-        await session.steer(tell.text);
-        emitTurnStarted?.();
-        if (options.onEvidence)
-            emitProviderEvidence(options.onEvidence, { type: "ack", provider: PI_PROVIDER, fence: { kind: "ordinal", ordinal: submittedTurnOrdinal }, outbound: "steer" }, options.diagnostic());
-        return { fence: { kind: "ordinal", ordinal: submittedTurnOrdinal } };
-    };
-    const control = { enqueue };
-    return {
-        enqueue,
-        control,
-        setTurnStartedEmitter(emitter) { emitTurnStarted = emitter; },
-        beginTurn() {
-            const checkpoint = { fence: { kind: "ordinal", ordinal: submittedTurnOrdinal } };
-            options.onSyncCheckpoint?.(control, checkpoint);
-        },
-        modelInputVisible() {
-            // Pi's public event exposes an assistant start but no identity for the
-            // queued input accepted by that model call. Event order is not a receipt.
-        },
-        completeTurn() {
-            submittedTurnOrdinal += 1;
-            const checkpoint = { fence: { kind: "ordinal", ordinal: submittedTurnOrdinal } };
-            if (options.onEvidence)
-                emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: PI_PROVIDER, fence: checkpoint.fence, source: "notification" }, options.diagnostic());
-            options.onSyncCheckpoint?.(control, checkpoint);
-        },
-    };
-}