@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/agents/providers/codex-app-server/adapter.js

@@ -1,387 +0,0 @@
-import { appendDebugLog } from "../../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION } from "../../session.js";
-import { createProjectionDriver } from "../../harness/execution-handle.js";
-import { createProviderFailure } from "../../harness/provider-adapter.js";
-import { awaitProviderAbortSettlement, buildSubagentEnv, createAbortError, emitProviderEvidence, coerceString, } from "../../harness/runtime.js";
-import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
-import { CodexAppServerProcess } from "./session.js";
-import { createCodexAppServerTurnMonitor, createCodexAppServerTurnState, codexAppServerFailureMessage, codexAppServerTurnFailureCause, recordTurnStartResponse, } from "./events.js";
-export { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
-/** Identity-only opacity boundary for codex-app-server turn/start effort. */
-function toCodexAppServerEffort(effort) {
-    return effort;
-}
-export { codexAppServerSessionSchema } from "./session-schema.js";
-const MINIMUM_CODEX_APP_SERVER_VERSION = { major: 0, minor: 143, patch: 0 };
-const CODEX_APP_SERVER_PROBE_TIMEOUT_MS = 1_000;
-/** Non-interactive defaults for turn/start (faye #316 policy A). */
-export const CODEX_APP_SERVER_TURN_APPROVAL_POLICY = "never";
-export { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
-import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./policy.js";
-function parseSemver(version) {
-    const match = version.trim().match(/(\d+)\.(\d+)\.(\d+)/);
-    if (!match)
-        return undefined;
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-    };
-}
-export function isCodexAppServerVersionBelowMinimum(version) {
-    if (!version)
-        return false;
-    const parsed = parseSemver(version);
-    if (!parsed)
-        return false;
-    if (parsed.major !== MINIMUM_CODEX_APP_SERVER_VERSION.major) {
-        return parsed.major < MINIMUM_CODEX_APP_SERVER_VERSION.major;
-    }
-    if (parsed.minor !== MINIMUM_CODEX_APP_SERVER_VERSION.minor) {
-        return parsed.minor < MINIMUM_CODEX_APP_SERVER_VERSION.minor;
-    }
-    return parsed.patch < MINIMUM_CODEX_APP_SERVER_VERSION.patch;
-}
-function extractVersionFromInitialize(result) {
-    if (!result || typeof result !== "object")
-        return undefined;
-    const record = result;
-    const userAgent = coerceString(record.userAgent);
-    if (userAgent) {
-        const match = userAgent.match(/(\d+\.\d+\.\d+)/);
-        if (match)
-            return match[1];
-    }
-    return coerceString(record.version) ?? coerceString(record.cliVersion);
-}
-export async function settleCodexGracefulInterrupt(input) {
-    await input.requestInterrupt();
-    const terminal = await input.completion;
-    const terminalTurnId = coerceString(terminal.turn.id);
-    if (terminalTurnId !== input.turnId || terminal.status !== "interrupted") {
-        throw new Error(`${CODEX_APP_SERVER_PROVIDER} graceful abort expected interrupted turn '${input.turnId}', got '${terminalTurnId ?? "unknown"}' status '${terminal.status}'`);
-    }
-}
-/** Gate-facing production entry: the harness owns clocks, capture, classification, and outcome construction. */
-export async function startCodexAppServer(prompt, cwd, options = {}) {
-    const executable = options.executable?.trim() || "codex";
-    const resumeThreadId = options.threadId?.trim();
-    let server;
-    const turnState = createCodexAppServerTurnState();
-    let activeThreadId;
-    let interruptRequested = false;
-    let activeTurnCompletion;
-    let builderDiagnostic;
-    let emitTurnStarted;
-    const pendingTells = [];
-    let drainingTells = false;
-    let failActiveTurn;
-    let finishAfterTellDrain;
-    const rejectPendingTells = (error) => {
-        for (const pending of pendingTells.splice(0))
-            pending.reject(error);
-    };
-    appendDebugLog(`startCodexAppServer: executable=${executable} model=${options.model ?? "default"} mode=${resumeThreadId ? "resume" : "fresh"}`, { cwd, section: CODEX_APP_SERVER_PROVIDER });
-    const submitSteer = async (tell, turnId) => {
-        // turn/steer response {turnId} = enqueue acceptance (submitted), not consumption.
-        // clientUserMessageId = tell.id for later exact seen proof via userMessage item clientId.
-        // tell.text is already core-rendered; send byte-for-byte — never parse or rewrite.
-        const ack = await server.request("turn/steer", {
-            threadId: activeThreadId,
-            expectedTurnId: turnId,
-            clientUserMessageId: tell.id,
-            input: [{ type: "text", text: tell.text }],
-        });
-        const acknowledgedTurnId = coerceString(ack.turnId) ?? turnId;
-        if (acknowledgedTurnId !== turnId) {
-            throw new Error(`${CODEX_APP_SERVER_PROVIDER} turn/steer acknowledgement mismatched active turn: expected=${turnId}, actual=${acknowledgedTurnId}`);
-        }
-        // Accepted same-native-turn steer opens the next public conversation turn.
-        emitTurnStarted?.();
-        if (options.onEvidence) {
-            emitProviderEvidence(options.onEvidence, {
-                type: "ack",
-                provider: CODEX_APP_SERVER_PROVIDER,
-                fence: { kind: "turn", turnId: acknowledgedTurnId },
-                outbound: "steer",
-            }, builderDiagnostic);
-        }
-        return { fence: { kind: "turn", turnId: acknowledgedTurnId } };
-    };
-    const startTellTurn = async (tell) => {
-        const started = await server.request("turn/start", {
-            threadId: activeThreadId,
-            clientUserMessageId: tell.id,
-            input: [{ type: "text", text: tell.text }],
-            ...(options.model ? { model: options.model } : {}),
-            ...(tell.effort ? { effort: toCodexAppServerEffort(tell.effort) } : {}),
-            ...(!configOwnsApprovalPolicy(options.config) ? { approvalPolicy: options.approvalPolicy ?? CODEX_APP_SERVER_TURN_APPROVAL_POLICY } : {}),
-            ...(!configOwnsSandboxPolicy(options.config)
-                ? {
-                    sandboxPolicy: options.sandboxPolicy ?? buildCodexAppServerWorkspaceWriteSandboxPolicy({
-                        writableRoots: [cwd],
-                        networkAccess: false,
-                    }),
-                }
-                : {}),
-        });
-        const startedTurn = started && typeof started === "object"
-            ? (started.turn ?? undefined)
-            : undefined;
-        const newTurnId = recordTurnStartResponse(turnState, startedTurn?.id);
-        if (options.onEvidence)
-            emitProviderEvidence(options.onEvidence, { type: "ack", provider: CODEX_APP_SERVER_PROVIDER, fence: { kind: "turn", turnId: newTurnId }, outbound: "run" }, builderDiagnostic);
-        return { fence: { kind: "turn", turnId: newTurnId } };
-    };
-    const drainPendingTells = async () => {
-        if (drainingTells)
-            return;
-        drainingTells = true;
-        try {
-            while (pendingTells.length > 0 && server && activeThreadId) {
-                const pending = pendingTells[0];
-                if (pending.tell.effort && turnState.activeTurnId)
-                    return;
-                if (!pending.tell.effort && turnState.activeTurnId && !turnState.activeTurnAcceptingSteer)
-                    return;
-                pendingTells.shift();
-                try {
-                    const ack = turnState.activeTurnId
-                        ? await submitSteer(pending.tell, turnState.activeTurnId)
-                        : await startTellTurn(pending.tell);
-                    pending.resolve(ack);
-                }
-                catch (error) {
-                    pending.reject(error);
-                    failActiveTurn?.(error);
-                    return;
-                }
-            }
-        }
-        finally {
-            drainingTells = false;
-            const finish = finishAfterTellDrain;
-            finishAfterTellDrain = undefined;
-            finish?.();
-        }
-    };
-    const enqueue = async (tell) => {
-        if (!server || !activeThreadId) {
-            throw new Error(`${CODEX_APP_SERVER_PROVIDER} cannot steer: no active turn`);
-        }
-        return await new Promise((resolve, reject) => {
-            pendingTells.push({ tell, resolve, reject });
-            void drainPendingTells();
-        });
-    };
-    const probe = async () => {
-        if (!server || !activeThreadId) {
-            throw createProviderFailure(`${CODEX_APP_SERVER_PROVIDER} session probe has no active thread`, {
-                code: "SUBAGENT_TRANSPORT_ERROR",
-                timeoutMs: CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
-            });
-        }
-        let timer;
-        const deadline = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error("session probe timed out")), CODEX_APP_SERVER_PROBE_TIMEOUT_MS);
-            timer.unref?.();
-        });
-        try {
-            await Promise.race([
-                server.request("thread/read", { threadId: activeThreadId }),
-                deadline,
-            ]);
-        }
-        catch (error) {
-            throw createProviderFailure(`${CODEX_APP_SERVER_PROVIDER} session transport probe failed`, {
-                code: "SUBAGENT_TRANSPORT_ERROR",
-                timeoutMs: CODEX_APP_SERVER_PROBE_TIMEOUT_MS,
-                cause: error,
-            });
-        }
-        finally {
-            if (timer)
-                clearTimeout(timer);
-        }
-    };
-    return createProjectionDriver({
-        steerMode: "mid-execution",
-        initialTurn: options.initialTurn,
-        enqueue,
-        probe,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            interruptRequested = true;
-            if (mode === "force") {
-                await server?.close("force");
-                return;
-            }
-            if (!server)
-                return;
-            if (activeThreadId && turnState.activeTurnId) {
-                const turnId = turnState.activeTurnId;
-                const completion = activeTurnCompletion;
-                if (!completion) {
-                    throw new Error(`${CODEX_APP_SERVER_PROVIDER} graceful abort lacked an active turn monitor`);
-                }
-                await awaitProviderAbortSettlement(CODEX_APP_SERVER_PROVIDER, (async () => {
-                    // RPC acknowledgement is submission evidence only. Keep the monitor
-                    // and server alive until the matching terminal notification arrives.
-                    await settleCodexGracefulInterrupt({
-                        turnId,
-                        requestInterrupt: () => server.request("turn/interrupt", {
-                            threadId: activeThreadId,
-                            turnId,
-                        }),
-                        completion,
-                    });
-                })());
-                return;
-            }
-            await awaitProviderAbortSettlement(CODEX_APP_SERVER_PROVIDER, server.close("force"), "startup abort could not force-close owned server");
-        },
-        async run(builder) {
-            builderDiagnostic = (text) => builder.emit({ type: "diagnostic", text });
-            emitTurnStarted = () => builder.emit({ type: "turn", phase: "started" });
-            const env = buildSubagentEnv(options.env);
-            server = new CodexAppServerProcess(executable, env, {
-                cwd,
-                codexHome: options.codexHome,
-                onEvidence: options.onEvidence,
-                onEvidenceDiagnostic: (text) => builder.emit({ type: "diagnostic", text }),
-            });
-            const { turnCompleted, reconcileLaunchAdmissions } = createCodexAppServerTurnMonitor({
-                server,
-                builder,
-                state: turnState,
-                builderDiagnostic,
-                onEvidence: options.onEvidence,
-                onSyncCheckpoint: options.onSyncCheckpoint,
-                onDeliveryOpportunity: options.onDeliveryOpportunity,
-                onTellReceipt: options.onTellReceipt,
-                listLaunchAdmissions: options.listLaunchAdmissions,
-                enqueue,
-                drainPendingTells: () => { void drainPendingTells(); },
-                rejectPendingTells,
-                setFailActiveTurn: (fail) => { failActiveTurn = fail; },
-                pendingTellCount: () => pendingTells.length,
-                isDrainingTells: () => drainingTells,
-                setFinishAfterTellDrain: (finish) => { finishAfterTellDrain = finish; },
-            });
-            activeTurnCompletion = turnCompleted;
-            try {
-                const initResult = await server.request("initialize", {
-                    clientInfo: {
-                        name: "keiyaku",
-                        title: "keiyaku",
-                        version: "0.0.0",
-                    },
-                    capabilities: {
-                        experimentalApi: false,
-                        requestAttestation: false,
-                    },
-                });
-                const version = extractVersionFromInitialize(initResult);
-                if (isCodexAppServerVersionBelowMinimum(version)) {
-                    const message = `${CODEX_APP_SERVER_PROVIDER} refused: initialize version '${version}' is below minimum supported version 0.143.0`;
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                const initRecord = (initResult && typeof initResult === "object" ? initResult : {});
-                const serverCodexHome = coerceString(initRecord.codexHome) ?? options.codexHome;
-                server.notify("initialized");
-                const threadParams = {
-                    cwd,
-                    ...(options.model ? { model: options.model } : {}),
-                    ...(options.config ? { config: options.config } : {}),
-                    ...(options.developerInstructions ? { developerInstructions: options.developerInstructions } : {}),
-                };
-                const threadResult = resumeThreadId
-                    ? await server.request("thread/resume", {
-                        threadId: resumeThreadId,
-                        ...threadParams,
-                    })
-                    : await server.request("thread/start", threadParams);
-                const thread = threadResult && typeof threadResult === "object"
-                    ? (threadResult.thread ??
-                        threadResult)
-                    : undefined;
-                activeThreadId = coerceString(thread?.id) ?? resumeThreadId;
-                if (!activeThreadId) {
-                    const message = `${CODEX_APP_SERVER_PROVIDER} exec could not determine thread id`;
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                const admittedSession = {
-                    provider: "codex-app-server",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: {
-                        threadId: activeThreadId,
-                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
-                    },
-                };
-                options.onSessionAdmission?.({ session: admittedSession });
-                if (options.onEvidence)
-                    emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_APP_SERVER_PROVIDER, threadId: activeThreadId }, builderDiagnostic);
-                // Policy A defaults, but omit when config.* already owns that surface (thread/start config wins).
-                const turnStartParams = {
-                    threadId: activeThreadId,
-                    input: [{ type: "text", text: prompt }],
-                    ...(options.model ? { model: options.model } : {}),
-                    ...(options.effort ? { effort: toCodexAppServerEffort(options.effort) } : {}),
-                };
-                if (!configOwnsApprovalPolicy(options.config)) {
-                    turnStartParams.approvalPolicy = options.approvalPolicy ?? CODEX_APP_SERVER_TURN_APPROVAL_POLICY;
-                }
-                if (!configOwnsSandboxPolicy(options.config)) {
-                    turnStartParams.sandboxPolicy = options.sandboxPolicy ?? buildCodexAppServerWorkspaceWriteSandboxPolicy({
-                        writableRoots: [cwd],
-                        networkAccess: false,
-                    });
-                }
-                turnState.activeTurnId = undefined;
-                turnState.activeTurnSource = undefined;
-                turnState.activeTurnAcceptingSteer = false;
-                turnState.failureCause = undefined;
-                turnState.turnInFlight = true;
-                const turnStart = await server.request("turn/start", turnStartParams);
-                const turn = turnStart && typeof turnStart === "object"
-                    ? (turnStart.turn ?? undefined)
-                    : undefined;
-                const turnId = recordTurnStartResponse(turnState, turn?.id);
-                await options.onLaunchAdmission?.({ fence: { kind: "turn", turnId }, tellIds: options.launchTellIds ?? [] });
-                reconcileLaunchAdmissions();
-                if (options.onEvidence)
-                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_APP_SERVER_PROVIDER, fence: { kind: "turn", turnId }, source: "response" }, builderDiagnostic);
-                const completed = await turnCompleted;
-                turnState.turnInFlight = false;
-                if (completed.status === "interrupted" || interruptRequested) {
-                    throw createAbortError(`${CODEX_APP_SERVER_PROVIDER} turn interrupted`);
-                }
-                if (completed.status === "failed") {
-                    const publicCause = codexAppServerTurnFailureCause(completed.turn) ?? turnState.failureCause;
-                    throw createProviderFailure(codexAppServerFailureMessage(publicCause), {
-                        ...(publicCause ? { publicCause } : {}),
-                    });
-                }
-                if (completed.status !== "completed") {
-                    const message = `${CODEX_APP_SERVER_PROVIDER} turn ended with status '${completed.status}'`;
-                    builder.emit({ type: "fail", message });
-                    throw createProviderFailure(message);
-                }
-                // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
-                const finalMessage = turnState.lastAgentMessage;
-                builder.emit({ type: "done", finalMessage, session: admittedSession });
-                return { finalMessage, session: admittedSession };
-            }
-            finally {
-                activeTurnCompletion = undefined;
-                rejectPendingTells(new Error(`${CODEX_APP_SERVER_PROVIDER} execution ended before queued tell acceptance`));
-                await server?.close();
-                server = undefined;
-            }
-        },
-    });
-}
-// Compiler-level binding to the named ProviderAdapter function contract.
-startCodexAppServer;