@astrosheep/keiyaku 2.8.4 → 2.9.0

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

@@ -0,0 +1,347 @@
+import { z } from "zod";
+import { appendDebugLog } from "../../../telemetry/debug-log.js";
+import { SUBAGENT_SESSION_VERSION } from "../../session.js";
+import { createProjectionDriver } from "../../harness/execution-handle.js";
+import { buildSubagentEnv, createAbortError, emitProviderEvidence, coerceString } from "../../harness/runtime.js";
+import { CodexAppServerProcess } from "./session.js";
+import { createCodexAppServerTurnMonitor, createCodexAppServerTurnState, recordTurnStartResponse, } from "./events.js";
+/** Identity-only opacity boundary for codex-app-server turn/start effort. */
+function toCodexAppServerEffort(effort) {
+    return effort;
+}
+/** Session handle for codex-app-server: thread id plus optional CODEX_HOME for cross-process resume. */
+export const codexAppServerSessionSchema = z.object({
+    threadId: z.string().trim().min(1),
+    codexHome: z.string().trim().min(1).optional(),
+});
+const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+const MINIMUM_CODEX_APP_SERVER_VERSION = { major: 0, minor: 143, patch: 0 };
+/** Non-interactive defaults for turn/start (faye #316 policy A). */
+export const CODEX_APP_SERVER_TURN_APPROVAL_POLICY = "never";
+export function buildCodexAppServerWorkspaceWriteSandboxPolicy(input) {
+    return {
+        type: "workspaceWrite",
+        writableRoots: [...input.writableRoots],
+        networkAccess: input.networkAccess,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false,
+    };
+}
+/** True when config.* already owns approval policy — omit turn-level approvalPolicy default. */
+export function configOwnsApprovalPolicy(config) {
+    if (!config)
+        return false;
+    return Object.prototype.hasOwnProperty.call(config, "approval_policy");
+}
+/**
+ * True when config.* already owns sandbox settings — omit turn-level sandboxPolicy default.
+ * Matches `sandbox_mode` or any `sandbox_workspace_write` / `sandbox_workspace_write.*` key.
+ */
+export function configOwnsSandboxPolicy(config) {
+    if (!config)
+        return false;
+    for (const key of Object.keys(config)) {
+        if (key === "sandbox_mode" || key === "sandbox_workspace_write" || key.startsWith("sandbox_workspace_write.")) {
+            return true;
+        }
+    }
+    return false;
+}
+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);
+}
+/** 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 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 delivered 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,
+            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();
+        });
+    };
+    return createProjectionDriver({
+        steerMode: "mid-execution",
+        initialTurn: options.initialTurn,
+        enqueue,
+        onIngress: options.onIngress,
+        async abort(mode) {
+            interruptRequested = true;
+            if (mode === "force") {
+                await server?.close("force");
+                return;
+            }
+            if (server && activeThreadId && turnState.activeTurnId) {
+                try {
+                    // RPC acknowledgement is NOT terminal proof; wait for turn/completed interrupted.
+                    await server.request("turn/interrupt", {
+                        threadId: activeThreadId,
+                        turnId: turnState.activeTurnId,
+                    });
+                }
+                catch {
+                    // idle interrupt may error; still rely on process teardown
+                }
+            }
+            await server?.close("graceful");
+        },
+        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, options.codexHome, options.onEvidence, (text) => builder.emit({ type: "diagnostic", text }));
+            const { turnCompleted } = createCodexAppServerTurnMonitor({
+                server,
+                builder,
+                state: turnState,
+                builderDiagnostic,
+                onEvidence: options.onEvidence,
+                onSyncCheckpoint: options.onSyncCheckpoint,
+                onDeliveryOpportunity: options.onDeliveryOpportunity,
+                enqueue,
+                drainPendingTells: () => { void drainPendingTells(); },
+                rejectPendingTells,
+                setFailActiveTurn: (fail) => { failActiveTurn = fail; },
+                pendingTellCount: () => pendingTells.length,
+                isDrainingTells: () => drainingTells,
+                setFinishAfterTellDrain: (finish) => { finishAfterTellDrain = finish; },
+            });
+            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 new Error(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 new Error(message);
+                }
+                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;
+                const turnStart = await server.request("turn/start", turnStartParams);
+                const turn = turnStart && typeof turnStart === "object"
+                    ? (turnStart.turn ?? undefined)
+                    : undefined;
+                const turnId = recordTurnStartResponse(turnState, turn?.id);
+                if (options.onEvidence)
+                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_APP_SERVER_PROVIDER, fence: { kind: "turn", turnId }, source: "response" }, builderDiagnostic);
+                const completed = await turnCompleted;
+                if (completed.status === "interrupted" || interruptRequested) {
+                    throw createAbortError(`${CODEX_APP_SERVER_PROVIDER} turn interrupted`);
+                }
+                if (completed.status === "failed") {
+                    const message = `${CODEX_APP_SERVER_PROVIDER} turn failed`;
+                    builder.emit({ type: "fail", message });
+                    throw new Error(message);
+                }
+                if (completed.status !== "completed") {
+                    const message = `${CODEX_APP_SERVER_PROVIDER} turn ended with status '${completed.status}'`;
+                    builder.emit({ type: "fail", message });
+                    throw new Error(message);
+                }
+                // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
+                const session = {
+                    provider: "codex-app-server",
+                    version: SUBAGENT_SESSION_VERSION,
+                    handle: {
+                        threadId: activeThreadId,
+                        ...(serverCodexHome ? { codexHome: serverCodexHome } : {}),
+                    },
+                };
+                const finalMessage = turnState.lastAgentMessage;
+                builder.emit({ type: "done", finalMessage, session });
+                return { finalMessage, session };
+            }
+            finally {
+                rejectPendingTells(new Error(`${CODEX_APP_SERVER_PROVIDER} execution ended before queued tell acceptance`));
+                await server?.close();
+                server = undefined;
+            }
+        },
+    });
+}