@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/agents/harness/execution-handle.js

@@ -1,172 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createEventChannel, EXEC_EVENT_BUFFER_HARD_CAP, } from "./event-channel.js";
-import { toProviderTerminalError } from "./provider-adapter.js";
-import { createTruncationMarker, overflowMarkerFromDropped, serializeUnknownPayload, } from "./event-persistence.js";
-export { createTruncationMarker, overflowMarkerFromDropped, prepareAgentEventForPersistence, } from "./event-persistence.js";
-export function createProjectionDriver(input) {
-    if (input.initialTurn !== undefined
-        && (!Number.isSafeInteger(input.initialTurn) || input.initialTurn < 0)) {
-        throw new Error(`createProjectionDriver initialTurn must be a non-negative safe integer, got ${String(input.initialTurn)}`);
-    }
-    const id = input.id ?? randomUUID();
-    const abortController = new AbortController();
-    let gracefulAbort;
-    let forceAbort;
-    let finishStarted = false;
-    let nextSeq = 0;
-    let turn = input.initialTurn ?? 0;
-    let ordinaryAdmitted = 0;
-    let saturated = false;
-    let truncationPublished = false;
-    const nowMs = () => (input.now ?? Date.now)();
-    const nowIso = () => new Date(nowMs()).toISOString();
-    const admit = (body) => {
-        // Turn advance owns the builder ordinal for every submitted started body,
-        // including bodies that only produce the truncation marker or are dropped.
-        if (body.type === "turn" && body.phase === "started") {
-            if (turn >= Number.MAX_SAFE_INTEGER) {
-                throw new Error(`createProjectionDriver turn overflow: cannot advance past ${Number.MAX_SAFE_INTEGER}`);
-            }
-            turn += 1;
-        }
-        if (saturated) {
-            return undefined;
-        }
-        if (ordinaryAdmitted >= EXEC_EVENT_BUFFER_HARD_CAP) {
-            if (truncationPublished) {
-                saturated = true;
-                return undefined;
-            }
-            saturated = true;
-            truncationPublished = true;
-            const marker = createTruncationMarker({
-                seq: nextSeq,
-                at: nowIso(),
-                turn,
-            });
-            nextSeq += 1;
-            return marker;
-        }
-        const event = {
-            ...body,
-            seq: nextSeq,
-            at: nowIso(),
-            turn,
-        };
-        nextSeq += 1;
-        ordinaryAdmitted += 1;
-        return event;
-    };
-    const channel = createEventChannel({
-        createOverflowMarker: overflowMarkerFromDropped,
-    });
-    const publish = (event, meta) => {
-        channel.push(event, meta);
-    };
-    const emitBody = (body, meta) => {
-        if (meta?.coalesceKey) {
-            const prior = channel.peekCoalesced(meta.coalesceKey);
-            if (prior !== undefined) {
-                const updated = {
-                    ...body,
-                    seq: prior.seq,
-                    at: nowIso(),
-                    turn: prior.turn,
-                };
-                publish(updated, meta);
-                return;
-            }
-        }
-        const event = admit(body);
-        if (event === undefined)
-            return;
-        publish(event, event.type === "truncation" ? undefined : meta);
-    };
-    let resolveCompletion;
-    let rejectCompletion;
-    const completion = new Promise((resolve, reject) => {
-        resolveCompletion = resolve;
-        rejectCompletion = reject;
-    });
-    completion.catch(() => undefined);
-    const finish = (action) => {
-        if (finishStarted)
-            return;
-        finishStarted = true;
-        channel.close();
-        void channel.whenDrained().then(action, action);
-    };
-    const runPromise = (async () => {
-        try {
-            const outcome = await input.run({
-                emit(body, meta) {
-                    emitBody(body, meta);
-                },
-                ingress(provider, nativeType, payload, disposition, map) {
-                    input.onIngress?.();
-                    if (disposition === "unknown") {
-                        const bounded = serializeUnknownPayload(payload);
-                        emitBody({ type: "unknown", provider, nativeType, ...bounded });
-                        return;
-                    }
-                    map();
-                },
-                signal: abortController.signal,
-            });
-            const completed = {
-                kind: "completed",
-                finalMessage: outcome.finalMessage,
-                session: outcome.session,
-            };
-            finish(() => resolveCompletion({
-                finalMessage: completed.finalMessage,
-                session: completed.session,
-            }));
-        }
-        catch (error) {
-            // Boundary gate: adapter run throws become typed failed/aborted facts only.
-            finish(() => rejectCompletion(toProviderTerminalError(error)));
-        }
-    })();
-    void runPromise;
-    const enqueue = input.enqueue &&
-        (async (message) => {
-            return input.enqueue(message);
-        });
-    return {
-        id,
-        events: channel.iterable,
-        completion,
-        steerMode: input.steerMode,
-        mintEvent(body) {
-            return admit(body);
-        },
-        ...(enqueue ? { enqueue } : {}),
-        ...(input.clearQueue ? { clearQueue: input.clearQueue } : {}),
-        async abort(mode = "graceful") {
-            if (mode === "force") {
-                forceAbort ??= (async () => {
-                    if (!abortController.signal.aborted) {
-                        abortController.abort();
-                    }
-                    await input.abort?.("force");
-                    await runPromise;
-                })();
-                await forceAbort;
-                return;
-            }
-            gracefulAbort ??= (async () => {
-                try {
-                    await input.abort?.("graceful");
-                }
-                finally {
-                    if (!abortController.signal.aborted) {
-                        abortController.abort();
-                    }
-                }
-            })();
-            await gracefulAbort;
-        },
-        ...(input.probe ? { probe: input.probe } : {}),
-    };
-}

package/build/agents/harness/index.js

@@ -1,11 +0,0 @@
-export { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
-export { EXEC_EVENT_BUFFER_HARD_CAP } from "./event-channel.js";
-export { createAbortError } from "./runtime.js";
-export { exactLaunchInputReceipts } from "./control-types.js";
-export { createProviderFailure, isProviderTerminalError, ProviderTerminalError, toProviderTerminalError, } from "./provider-adapter.js";
-export { restoreOutcome } from "./outcome.js";
-export { OutcomeErrorValidationError, parseCurrentOutcomeError, } from "./outcome-error.js";
-export { call, revive } from "./projection.js";
-export { isRecoverableSessionEnvelope } from "./session.js";
-export { OUTCOME_ERROR_VERSION, SubagentFailure } from "../types.js";
-export { SUBAGENT_SESSION_VERSION, subagentSessionEnvelopeSchema, } from "../session.js";

package/build/agents/harness/outcome-error.js

@@ -1,81 +0,0 @@
-import { OUTCOME_ERROR_VERSION, SUBAGENT_FAILURE_CODES, } from "../types.js";
-const OUTCOME_ERROR_CODES = new Set(SUBAGENT_FAILURE_CODES);
-const OUTCOME_ERROR_KEYS = new Set([
-    "version",
-    "code",
-    "message",
-    "timeoutMs",
-    "exitCode",
-    "publicCause",
-]);
-export class OutcomeErrorValidationError extends Error {
-    incompatible;
-    constructor(message, incompatible = false) {
-        super(message);
-        this.incompatible = incompatible;
-        this.name = "OutcomeErrorValidationError";
-    }
-}
-function isPlainObject(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function isJsonCompatible(value, ancestors) {
-    if (value === null || typeof value === "boolean" || typeof value === "string")
-        return true;
-    if (typeof value === "number")
-        return Number.isFinite(value);
-    if (typeof value !== "object")
-        return false;
-    if (ancestors.has(value))
-        return false;
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value))
-            return value.every((item) => isJsonCompatible(item, ancestors));
-        return isPlainObject(value) && Object.values(value).every((item) => isJsonCompatible(item, ancestors));
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-/** Parses the one current persisted OutcomeError schema at the harness boundary. */
-export function parseCurrentOutcomeError(value, location) {
-    const error = isPlainObject(value) ? value : undefined;
-    const version = error?.version;
-    if (!error || version !== OUTCOME_ERROR_VERSION) {
-        throw new OutcomeErrorValidationError(`${location} has incompatible version ${version === undefined ? "missing" : String(version)}; expected ${OUTCOME_ERROR_VERSION}`, true);
-    }
-    if (Object.keys(error).some((key) => !OUTCOME_ERROR_KEYS.has(key))) {
-        throw new OutcomeErrorValidationError(`${location} is not the current closed OutcomeError shape`);
-    }
-    if (typeof error.code !== "string" || !OUTCOME_ERROR_CODES.has(error.code)) {
-        throw new OutcomeErrorValidationError(`${location}.code is not a recognized subagent failure code`);
-    }
-    if (typeof error.message !== "string") {
-        throw new OutcomeErrorValidationError(`${location}.message must be a string`);
-    }
-    if (error.timeoutMs !== null && (typeof error.timeoutMs !== "number"
-        || !Number.isSafeInteger(error.timeoutMs)
-        || error.timeoutMs < 0)) {
-        throw new OutcomeErrorValidationError(`${location}.timeoutMs must be null or a non-negative safe integer`);
-    }
-    if (error.exitCode !== null && (typeof error.exitCode !== "number"
-        || !Number.isSafeInteger(error.exitCode))) {
-        throw new OutcomeErrorValidationError(`${location}.exitCode must be null or a safe integer`);
-    }
-    if (error.publicCause !== undefined && (!isPlainObject(error.publicCause)
-        || !isJsonCompatible(error.publicCause, new Set()))) {
-        throw new OutcomeErrorValidationError(`${location}.publicCause must be a JSON-compatible harness failure cause`);
-    }
-    return {
-        version: OUTCOME_ERROR_VERSION,
-        code: error.code,
-        message: error.message,
-        timeoutMs: error.timeoutMs,
-        exitCode: error.exitCode,
-        ...(error.publicCause === undefined ? {} : { publicCause: error.publicCause }),
-    };
-}

package/build/agents/harness/outcome.js

@@ -1,220 +0,0 @@
-import { StringTailBuffer } from "../string-tail-buffer.js";
-import { SUBAGENT_SESSION_VERSION, } from "../session.js";
-import { OUTCOME_ERROR_VERSION, SubagentFailure, } from "../types.js";
-import { isProviderTerminalError, } from "./provider-adapter.js";
-import { renderCapturedText } from "./runtime.js";
-export function createOutcomeState(maxCaptureChars, admittedSession) {
-    return {
-        outputBuffer: new StringTailBuffer(maxCaptureChars),
-        diagnosticsBuffer: new StringTailBuffer(maxCaptureChars),
-        warnings: [],
-        ...(admittedSession ? { session: admittedSession } : {}),
-    };
-}
-export function recordSessionAdmission(state, session) {
-    state.session = session;
-}
-function mintOutcome(draft) {
-    return draft;
-}
-export function restoreOutcome(record) {
-    return { ...record };
-}
-export 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;
-            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;
-    }
-}
-export 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);
-}
-export function classifyFailure(shared, state, error, idleTimedOut, transportFailure, policyBudgetExceeded = false) {
-    if (policyBudgetExceeded) {
-        return failWithError(shared, state, {
-            code: "SUBAGENT_POLICY_BUDGET",
-            message: `${shared.terms.provider} execution policy budget expired`,
-            timeoutMs: shared.terms.executionTimeoutMs,
-            exitCode: null,
-        }, state.finalMessageCandidate);
-    }
-    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 (shared.explicitlyAborted && isProviderTerminalError(error) && error.fact.kind === "aborted") {
-        return mintOutcome({
-            status: "interrupted",
-            finalMessage: state.finalMessageCandidate ?? "",
-            output: renderCapturedText(state.outputBuffer),
-            diagnostics: renderCapturedText(state.diagnosticsBuffer),
-            session: state.session ?? fallbackSession(shared),
-            warnings: [...state.warnings],
-        });
-    }
-    if (transportFailure) {
-        const message = transportFailure instanceof Error ? transportFailure.message : `${shared.terms.provider} session transport probe failed`;
-        const timeoutMs = isProviderTerminalError(transportFailure) && transportFailure.fact.kind === "failed"
-            ? transportFailure.fact.timeoutMs
-            : shared.terms.idleTimeoutMs;
-        return failWithError(shared, state, {
-            code: "SUBAGENT_TRANSPORT_ERROR",
-            message,
-            timeoutMs,
-            exitCode: null,
-        }, state.finalMessageCandidate);
-    }
-    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);
-    }
-    return classifyExecutionFailure(shared, state, error);
-}
-/**
- * A rejected graceful settlement is terminal evidence, not an outcome intent.
- * In particular, dismiss/external-cancel intent must not downgrade it to a
- * clean dismissed result.
- */
-export function classifySettlementFailure(shared, state, error) {
-    return classifyExecutionFailure(shared, state, error);
-}
-function classifyFromFailureFact(shared, state, fact) {
-    return failWithError(shared, state, {
-        code: fact.code,
-        message: fact.message,
-        timeoutMs: fact.timeoutMs,
-        exitCode: fact.exitCode,
-        ...(fact.publicCause ? { publicCause: fact.publicCause } : {}),
-    }, state.finalMessageCandidate ?? fact.message, fact.diagnostics || renderCapturedText(state.diagnosticsBuffer), fact.output || renderCapturedText(state.outputBuffer));
-}
-function classifyFromAbortFact(shared, state, fact) {
-    // Abort without dismiss/external-cancel remains failed truth (historical bytes).
-    appendThrownMessage(state.diagnosticsBuffer, fact.message);
-    return failWithError(shared, state, {
-        code: "SUBAGENT_EXEC_ERROR",
-        message: fact.message,
-        timeoutMs: null,
-        exitCode: null,
-    }, state.finalMessageCandidate ?? fact.message);
-}
-function classifyExecutionFailure(shared, state, error) {
-    if (isProviderTerminalError(error)) {
-        if (error.fact.kind === "aborted") {
-            return classifyFromAbortFact(shared, state, error.fact);
-        }
-        return classifyFromFailureFact(shared, state, error.fact);
-    }
-    if (error instanceof SubagentFailure) {
-        return classifyFromFailureFact(shared, state, {
-            kind: "failed",
-            code: error.code,
-            message: error.message,
-            timeoutMs: error.timeoutMs,
-            exitCode: error.exitCode,
-            diagnostics: error.diagnostics,
-            output: error.output,
-        });
-    }
-    if (error instanceof Error && error.name === "AbortError") {
-        return classifyFromAbortFact(shared, state, { kind: "aborted", message: error.message });
-    }
-    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);
-}
-export function failWithError(shared, state, error, finalMessage, diagnostics = renderCapturedText(state.diagnosticsBuffer), output = renderCapturedText(state.outputBuffer)) {
-    return mintOutcome({
-        status: "failed",
-        error: { version: OUTCOME_ERROR_VERSION, ...error },
-        finalMessage: finalMessage ?? error.message,
-        output,
-        diagnostics,
-        session: state.session ?? fallbackSession(shared),
-        warnings: [...state.warnings],
-    });
-}
-export function completeOutcome(state, finalMessage) {
-    if (!state.session) {
-        throw new Error("Cannot complete an outcome before session admission");
-    }
-    return mintOutcome({
-        status: "completed",
-        finalMessage,
-        output: renderCapturedText(state.outputBuffer),
-        diagnostics: renderCapturedText(state.diagnosticsBuffer),
-        session: state.session,
-        warnings: [...state.warnings],
-    });
-}
-export 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);
-}
-export function renderOutcomeCapturedText(buffer) {
-    return renderCapturedText(buffer);
-}