@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/agents/harness/index.js

@@ -1,608 +1,7 @@
-import { randomUUID } from "node:crypto";
-import { FlowError } from "../../flow-error.js";
-import { StringTailBuffer } from "../string-tail-buffer.js";
-import { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";
-import { startClaudeAgentSdk, claudeSessionSchema, } from "../providers/claude-agent-sdk.js";
-import { startCodexAppServer, codexAppServerSessionSchema, } from "../providers/codex-app-server.js";
-import { startCodexSdk, codexThreadSchema, } from "../providers/codex-sdk.js";
-import { startOpencode, opencodeSessionSchema, } from "../providers/opencode-sdk.js";
-import { startPi, piSessionSchema, } from "../providers/pi.js";
-import { SubagentFailure, } from "../types.js";
-import { createEventChannel } from "./event-channel.js";
-import { overflowMarkerFromDropped } from "./execution-handle.js";
-import { buildSyncCheckpointCallback, createReplayRunStartGate, markReplayCompleted, pumpSupervisor, snapshotReplayPrompt } from "./pump.js";
-import { createAbortError, renderCapturedText } from "./runtime.js";
-import { demoteSubmittedTellsForReplay, listTellIds, markTellSubmitted } from "../../core/projection-core.js";
 export { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
-export function call(terms) {
-    return createProjection(terms);
-}
-export function revive(terms) {
-    return createProjection(terms, terms);
-}
-function mintOutcome(draft) {
-    return draft;
-}
-export function restoreOutcome(record) {
-    return { ...record };
-}
-function createProjection(terms, reviveTerms) {
-    switch (terms.provider) {
-        case "pi":
-        case "claude-agent-sdk":
-        case "codex-app-server":
-            return createSteerableProjection(terms, reviveTerms);
-        case "codex-sdk":
-        case "opencode-sdk":
-            return createReplayProjection(terms, reviveTerms);
-        default:
-            return assertNever(terms);
-    }
-}
-function createSteerableProjection(terms, reviveTerms) {
-    const shared = createProjectionState(terms, reviveTerms);
-    const pendingTells = [];
-    let flushActive = false;
-    const flushPendingTells = async () => {
-        const initialEnqueue = shared.live?.enqueue;
-        if (flushActive || shared.terminal || !initialEnqueue)
-            return;
-        flushActive = true;
-        try {
-            while (!shared.terminal && pendingTells.length > 0) {
-                const enqueue = shared.live?.enqueue;
-                if (!enqueue)
-                    break;
-                const nextTell = pendingTells.shift();
-                if (!nextTell)
-                    break;
-                await enqueue(nextTell);
-            }
-        }
-        finally {
-            flushActive = false;
-            if (!shared.terminal && pendingTells.length > 0 && shared.live?.enqueue) {
-                void flushPendingTells();
-            }
-        }
-    };
-    shared.onLive = (live) => {
-        shared.live = live;
-        void flushPendingTells();
-    };
-    const outcome = settleProjection(shared);
-    return {
-        mode: "steerable",
-        get id() {
-            return shared.id;
-        },
-        get events() {
-            return shared.publicEvents.iterable;
-        },
-        get outcome() {
-            return outcome;
-        },
-        tell(tell) {
-            if (shared.terminal)
-                return;
-            pendingTells.push(tell);
-            void flushPendingTells();
-        },
-        recallTells() {
-            return pendingTells.splice(0, pendingTells.length);
-        },
-        dismiss() {
-            dismissProjection(shared);
-        },
-    };
-}
-function createReplayProjection(terms, reviveTerms) {
-    const shared = createProjectionState(terms, reviveTerms);
-    shared.onLive = (live) => {
-        shared.live = live;
-    };
-    const outcome = settleProjection(shared);
-    return {
-        mode: "replay",
-        get id() {
-            return shared.id;
-        },
-        get events() {
-            return shared.publicEvents.iterable;
-        },
-        get outcome() {
-            return outcome;
-        },
-        dismiss() {
-            dismissProjection(shared);
-        },
-    };
-}
-function createProjectionState(terms, reviveTerms) {
-    const shared = {
-        id: randomUUID(),
-        terms,
-        reviveTerms,
-        publicEvents: createEventChannel({
-            createOverflowMarker: overflowMarkerFromDropped,
-        }),
-        lifecycleAbort: new AbortController(),
-        dismissed: false,
-        externallyAborted: false,
-        terminal: false,
-        onLive() { },
-    };
-    if (terms.signal) {
-        const listener = () => {
-            shared.externallyAborted = true;
-            if (!shared.lifecycleAbort.signal.aborted) {
-                shared.lifecycleAbort.abort(terms.signal?.reason);
-            }
-        };
-        terms.signal.addEventListener("abort", listener, { once: true });
-        if (terms.signal.aborted) {
-            listener();
-        }
-    }
-    return shared;
-}
-function dismissProjection(shared) {
-    if (shared.dismissed || shared.terminal)
-        return;
-    shared.dismissed = true;
-    if (!shared.lifecycleAbort.signal.aborted) {
-        shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec dismissed`));
-    }
-    requestAbort(shared.live);
-}
-function requestAbort(live) {
-    if (!live)
-        return;
-    void Promise.resolve()
-        .then(() => live.abort())
-        .catch(() => undefined);
-}
-async function settleProjection(shared) {
-    const state = {
-        outputBuffer: new StringTailBuffer(shared.terms.maxCaptureChars),
-        diagnosticsBuffer: new StringTailBuffer(shared.terms.maxCaptureChars),
-        warnings: [],
-    };
-    let idleTimedOut = false;
-    let abortRequested = false;
-    let idleTimeout;
-    const refreshIdleTimeout = () => {
-        if (idleTimeout)
-            clearTimeout(idleTimeout);
-        idleTimeout = setTimeout(() => {
-            idleTimedOut = true;
-            shared.lifecycleAbort.abort(createAbortError(`${shared.terms.provider} exec idle timed out`));
-        }, shared.terms.idleTimeoutMs);
-        idleTimeout.unref?.();
-    };
-    refreshIdleTimeout();
-    const requestLiveAbort = () => {
-        if (abortRequested)
-            return;
-        abortRequested = true;
-        requestAbort(shared.live);
-    };
-    shared.lifecycleAbort.signal.addEventListener("abort", requestLiveAbort, { once: true });
-    try {
-        if (shared.terms.projectionDir) {
-            const executionId = shared.terms.projectionExecutionId;
-            if (!executionId)
-                throw new FlowError("INTERNAL_STATE", "projection execution id is required in supervisor mode");
-            demoteSubmittedTellsForReplay(shared.terms.projectionDir, executionId);
-        }
-        const launchTellFence = shared.terms.projectionTellFence;
-        const tellFence = launchTellFence === undefined
-            ? []
-            : Array.isArray(launchTellFence) && launchTellFence.every((tellId) => typeof tellId === "string")
-                ? launchTellFence
-                : (() => { throw new FlowError("INTERNAL_STATE", "generation launch has an invalid tellFence"); })();
-        const launchSnapshot = shared.terms.projectionDir && shared.terms.projectionExecutionId
-            ? snapshotReplayPrompt(shared.terms.projectionDir, shared.terms.prompt, tellFence, shared.terms.projectionExecutionId, 
-            // Session resume already holds launch history. Only fenced tells are
-            // new operator input; re-blasting the original prompt reasserts stale
-            // allowlists and breaks resting continuation.
-            { sessionContinuation: shared.reviveTerms !== undefined })
-            : undefined;
-        const launchTerms = launchSnapshot
-            ? shared.terms.provider === "codex-sdk" && launchSnapshot.effort
-                ? { ...shared.terms, prompt: launchSnapshot.prompt, threadOptions: { ...shared.terms.threadOptions, modelReasoningEffort: launchSnapshot.effort } }
-                : { ...shared.terms, prompt: launchSnapshot.prompt }
-            : shared.terms;
-        // A constructed driver is not an SDK run acknowledgement. Tier-2 has no
-        // live steer surface, so the first provider event is the earliest harness
-        // observable start; a successful no-event completion is the only fallback.
-        const replayStartGate = launchSnapshot && shared.terms.provider !== "codex-app-server" && shared.terms.projectionDir && shared.terms.projectionExecutionId
-            ? createReplayRunStartGate(shared.terms.projectionDir, shared.terms.projectionExecutionId, launchSnapshot.tellIds)
-            : undefined;
-        const live = await startLiveProjection(launchTerms, shared.lifecycleAbort.signal, shared.reviveTerms, launchSnapshot?.tellIds, refreshIdleTimeout);
-        shared.onLive(live);
-        if (shared.lifecycleAbort.signal.aborted) {
-            requestLiveAbort();
-        }
-        const projectionDir = shared.terms.projectionDir;
-        if (projectionDir) {
-            const executionId = shared.terms.projectionExecutionId;
-            if (!executionId) {
-                throw new Error("projection execution id is required in supervisor mode");
-            }
-            // Supervisor mode: persist events, checkpoint, and claim heart-backed tells.
-            await pumpSupervisor(live, projectionDir, executionId, shared.publicEvents, {
-                onEvent: (event) => {
-                    replayStartGate?.observeProviderEvent();
-                    refreshIdleTimeout();
-                    processEvent(state, event);
-                },
-            });
-        }
-        else {
-            // Legacy mode: direct event loop without supervisor pump.
-            for await (const event of live.events) {
-                replayStartGate?.observeProviderEvent();
-                refreshIdleTimeout();
-                shared.publicEvents.push(event);
-                processEvent(state, event);
-            }
-        }
-        const completionResult = await live.completion.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
-        const completionOutcome = completionResult.ok ? completionResult.value : undefined;
-        if (state.failEvent) {
-            return failFromFailEvent(shared, state, state.failEvent);
-        }
-        if (!completionResult.ok) {
-            return classifyFailure(shared, state, completionResult.error, idleTimedOut);
-        }
-        if (shared.lifecycleAbort.signal.aborted) {
-            return classifyFailure(shared, state, shared.lifecycleAbort.signal.reason, idleTimedOut);
-        }
-        if (!state.doneEvent && !completionOutcome) {
-            return failWithError(shared, state, {
-                code: "SUBAGENT_EXEC_ERROR",
-                message: `${shared.terms.provider} exec ended before completion`,
-                timeoutMs: null,
-                exitCode: null,
-            }, state.finalMessageCandidate);
-        }
-        const finalMessage = state.doneEvent?.finalMessage ??
-            completionOutcome?.finalMessage ??
-            state.finalMessageCandidate ??
-            renderCapturedText(state.outputBuffer).trim();
-        const session = state.doneEvent?.session ?? completionOutcome?.session;
-        if (!session) {
-            return failWithError(shared, state, {
-                code: "SUBAGENT_EXEC_ERROR",
-                message: `${shared.terms.provider} exec ended without a session handle`,
-                timeoutMs: null,
-                exitCode: null,
-            }, finalMessage);
-        }
-        // A provider may complete successfully without emitting any observable
-        // events. Its successful completion is still a real run start.
-        replayStartGate?.observeSuccessfulCompletion();
-        if (launchSnapshot && shared.terms.projectionDir && shared.terms.projectionExecutionId) {
-            markReplayCompleted(shared.terms.projectionDir, shared.terms.projectionExecutionId);
-        }
-        return mintOutcome({
-            status: "completed",
-            finalMessage,
-            output: renderCapturedText(state.outputBuffer),
-            diagnostics: renderCapturedText(state.diagnosticsBuffer),
-            session,
-            warnings: [...state.warnings],
-        });
-    }
-    catch (error) {
-        if (error instanceof FlowError) {
-            throw error;
-        }
-        return classifyFailure(shared, state, error, idleTimedOut);
-    }
-    finally {
-        if (idleTimeout)
-            clearTimeout(idleTimeout);
-        shared.lifecycleAbort.signal.removeEventListener("abort", requestLiveAbort);
-        shared.terminal = true;
-        shared.publicEvents.close();
-    }
-}
-function processEvent(state, event) {
-    switch (event.type) {
-        case "diagnostic":
-            state.diagnosticsBuffer.append(event.text);
-            return;
-        case "message":
-            state.finalMessageCandidate = event.text;
-            return;
-        case "warning":
-            state.warnings.push(event.warning);
-            return;
-        case "done":
-            state.doneEvent = event;
-            state.session = event.session;
-            if (event.finalMessage !== undefined) {
-                state.finalMessageCandidate = event.finalMessage;
-            }
-            return;
-        case "fail":
-            state.failEvent = event;
-            if (event.diagnostics) {
-                state.diagnosticsBuffer.append(event.diagnostics);
-            }
-            return;
-        case "activity":
-        case "unknown":
-        case "turn":
-        case "usage":
-        case "thought":
-        case "plan":
-        case "truncation":
-            return;
-    }
-}
-function failFromFailEvent(shared, state, failEvent) {
-    const code = failEvent.code === "PROJECTION_STATE_ERROR" || failEvent.code === undefined
-        ? "SUBAGENT_EXEC_ERROR"
-        : failEvent.code;
-    const diagnostics = failEvent.code === "PROJECTION_STATE_ERROR"
-        ? [renderCapturedText(state.diagnosticsBuffer), "PROJECTION_STATE_ERROR"].filter(Boolean).join("\n")
-        : renderCapturedText(state.diagnosticsBuffer);
-    return failWithError(shared, state, {
-        code,
-        message: failEvent.message,
-        timeoutMs: null,
-        exitCode: failEvent.exitCode ?? null,
-    }, state.finalMessageCandidate, failEvent.diagnostics ?? diagnostics);
-}
-function classifyFailure(shared, state, error, idleTimedOut) {
-    if (shared.dismissed || shared.externallyAborted) {
-        return mintOutcome({
-            status: "dismissed",
-            finalMessage: state.finalMessageCandidate ?? "",
-            output: renderCapturedText(state.outputBuffer),
-            diagnostics: renderCapturedText(state.diagnosticsBuffer),
-            session: state.session ?? fallbackSession(shared),
-            warnings: [...state.warnings],
-        });
-    }
-    if (idleTimedOut) {
-        return failWithError(shared, state, {
-            code: "SUBAGENT_TIMEOUT",
-            message: `${shared.terms.provider} exec idle timed out`,
-            timeoutMs: shared.terms.idleTimeoutMs,
-            exitCode: null,
-        }, state.finalMessageCandidate);
-    }
-    if (error instanceof SubagentFailure) {
-        return failWithError(shared, state, {
-            code: error.code,
-            message: error.message,
-            timeoutMs: error.timeoutMs,
-            exitCode: error.exitCode,
-        }, state.finalMessageCandidate ?? error.message, error.diagnostics || renderCapturedText(state.diagnosticsBuffer), error.output || renderCapturedText(state.outputBuffer));
-    }
-    const message = error instanceof Error ? error.message : `Unknown ${shared.terms.provider} exec error`;
-    appendThrownMessage(state.diagnosticsBuffer, message);
-    return failWithError(shared, state, {
-        code: "SUBAGENT_EXEC_ERROR",
-        message,
-        timeoutMs: null,
-        exitCode: null,
-    }, state.finalMessageCandidate ?? message);
-}
-function failWithError(shared, state, error, finalMessage, diagnostics = renderCapturedText(state.diagnosticsBuffer), output = renderCapturedText(state.outputBuffer)) {
-    return mintOutcome({
-        status: "failed",
-        error,
-        finalMessage: finalMessage ?? error.message,
-        output,
-        diagnostics,
-        session: state.session ?? fallbackSession(shared),
-        warnings: [...state.warnings],
-    });
-}
-function fallbackSession(shared) {
-    return shared.reviveTerms?.session ?? {
-        provider: shared.terms.provider,
-        version: SUBAGENT_SESSION_VERSION,
-        handle: null,
-    };
-}
-function appendThrownMessage(buffer, message) {
-    if (message.length === 0)
-        return;
-    const snapshot = buffer.snapshot().text;
-    if (snapshot.length > 0 && !snapshot.endsWith("\n")) {
-        buffer.append("\n");
-    }
-    buffer.append(message);
-}
-function admitResumeShape(provider, 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 !== provider) {
-        throw new FlowError("INVALID_RESPONSE_PATH", `Resume path file '${resumePath}' was created with provider '${session.provider}', but the selected subagent resolves to '${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;
-}
-async function startLiveProjection(terms, signal, reviveTerms, initialTellIds = [], onIngress) {
-    const projectionCheckpoint = terms.projectionDir && terms.projectionExecutionId
-        ? buildSyncCheckpointCallback(terms.projectionDir, terms.projectionExecutionId)
-        : undefined;
-    let appServerInitialFencePending = terms.provider === "codex-app-server" && initialTellIds.length > 0;
-    const onSyncCheckpoint = terms.projectionDir
-        ? (control, checkpoint) => {
-            if (appServerInitialFencePending && terms.projectionExecutionId) {
-                for (const tellId of initialTellIds) {
-                    if (listTellIds(terms.projectionDir, "inflight").includes(tellId)) {
-                        markTellSubmitted(terms.projectionDir, tellId, { executionId: terms.projectionExecutionId, fence: checkpoint.fence });
-                    }
-                }
-                appServerInitialFencePending = false;
-                return;
-            }
-            projectionCheckpoint?.(control, checkpoint);
-        }
-        : "onCheckpoint" in terms
-            ? terms.onCheckpoint
-            : undefined;
-    switch (terms.provider) {
-        case "pi": {
-            if (reviveTerms) {
-                const session = admitResumeShape("pi", piSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startPi(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    thinkingLevel: terms.thinkingLevel,
-                    signal,
-                    sessionFile: session.sessionFile,
-                    appendSystemPromptOverride: terms.appendSystemPromptOverride,
-                    onSyncCheckpoint,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startPi(terms.prompt, terms.workdir, {
-                model: terms.model,
-                thinkingLevel: terms.thinkingLevel,
-                signal,
-                appendSystemPromptOverride: terms.appendSystemPromptOverride,
-                onSyncCheckpoint,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        case "claude-agent-sdk": {
-            const claudeOptions = {
-                model: terms.model,
-                executable: terms.executable,
-                effort: terms.effort,
-                signal,
-                permissionMode: terms.permissionMode,
-                settingSources: terms.settingSources,
-                allowDangerouslySkipPermissions: terms.allowDangerouslySkipPermissions,
-                disallowedTools: terms.disallowedTools,
-                systemPrompt: terms.systemPrompt,
-                onSyncCheckpoint,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            };
-            if (reviveTerms) {
-                const session = admitResumeShape("claude-agent-sdk", claudeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startClaudeAgentSdk(terms.prompt, terms.workdir, {
-                    ...claudeOptions,
-                    sessionId: session.sessionId,
-                });
-            }
-            return startClaudeAgentSdk(terms.prompt, terms.workdir, claudeOptions);
-        }
-        case "codex-app-server": {
-            if (reviveTerms) {
-                const session = admitResumeShape("codex-app-server", codexAppServerSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startCodexAppServer(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    effort: terms.effort,
-                    profile: terms.profile,
-                    config: terms.config,
-                    sandboxPolicy: terms.sandboxPolicy,
-                    approvalPolicy: terms.approvalPolicy,
-                    executable: terms.executable,
-                    signal,
-                    threadId: session.threadId,
-                    codexHome: session.codexHome,
-                    developerInstructions: terms.developerInstructions,
-                    onSyncCheckpoint,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startCodexAppServer(terms.prompt, terms.workdir, {
-                model: terms.model,
-                effort: terms.effort,
-                profile: terms.profile,
-                config: terms.config,
-                sandboxPolicy: terms.sandboxPolicy,
-                approvalPolicy: terms.approvalPolicy,
-                executable: terms.executable,
-                signal,
-                developerInstructions: terms.developerInstructions,
-                onSyncCheckpoint,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        case "codex-sdk": {
-            if (reviveTerms) {
-                const session = admitResumeShape("codex-sdk", codexThreadSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startCodexSdk(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    profile: terms.profile,
-                    config: terms.config,
-                    threadOptions: terms.threadOptions,
-                    executable: terms.executable,
-                    signal,
-                    threadId: session.threadId,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startCodexSdk(terms.prompt, terms.workdir, {
-                model: terms.model,
-                profile: terms.profile,
-                config: terms.config,
-                threadOptions: terms.threadOptions,
-                executable: terms.executable,
-                signal,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        case "opencode-sdk": {
-            if (reviveTerms) {
-                const session = admitResumeShape("opencode-sdk", opencodeSessionSchema, reviveTerms.session, reviveTerms.resumePath);
-                return startOpencode(terms.prompt, terms.workdir, {
-                    model: terms.model,
-                    effort: terms.effort,
-                    executable: terms.executable,
-                    signal,
-                    sessionId: session.sessionId,
-                    onEvidence: terms.onEvidence,
-                    onIngress,
-                    initialTurn: terms.initialTurn,
-                });
-            }
-            return startOpencode(terms.prompt, terms.workdir, {
-                model: terms.model,
-                effort: terms.effort,
-                executable: terms.executable,
-                signal,
-                onEvidence: terms.onEvidence,
-                onIngress,
-                initialTurn: terms.initialTurn,
-            });
-        }
-        default:
-            return assertNever(terms);
-    }
-}
-function assertNever(_value) {
-    throw new Error("Unhandled provider");
-}
+export { EXEC_EVENT_BUFFER_HARD_CAP } from "./event-channel.js";
+export { createAbortError } from "./runtime.js";
+export { restoreOutcome } from "./outcome.js";
+export { call, revive } from "./projection.js";
+export { SubagentFailure } from "../types.js";
+export { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";