@astrosheep/keiyaku 2.9.3 → 2.9.5

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

@@ -1,52 +1,23 @@
-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 { 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, 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;
 }
-/** 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";
+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 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;
-}
+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)
@@ -83,6 +54,14 @@ function extractVersionFromInitialize(result) {
     }
     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";
@@ -91,6 +70,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
     const turnState = createCodexAppServerTurnState();
     let activeThreadId;
     let interruptRequested = false;
+    let activeTurnCompletion;
     let builderDiagnostic;
     let emitTurnStarted;
     const pendingTells = [];
@@ -193,10 +173,41 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
             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;
@@ -204,19 +215,29 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 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
+            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 server?.close("graceful");
+            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 });
@@ -239,6 +260,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 isDrainingTells: () => drainingTells,
                 setFinishAfterTellDrain: (finish) => { finishAfterTellDrain = finish; },
             });
+            activeTurnCompletion = turnCompleted;
             try {
                 const initResult = await server.request("initialize", {
                     clientInfo: {
@@ -255,7 +277,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 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);
+                    throw createProviderFailure(message);
                 }
                 const initRecord = (initResult && typeof initResult === "object" ? initResult : {});
                 const serverCodexHome = coerceString(initRecord.codexHome) ?? options.codexHome;
@@ -280,7 +302,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 if (!activeThreadId) {
                     const message = `${CODEX_APP_SERVER_PROVIDER} exec could not determine thread id`;
                     builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message);
                 }
                 if (options.onEvidence)
                     emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_APP_SERVER_PROVIDER, threadId: activeThreadId }, builderDiagnostic);
@@ -303,6 +325,8 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 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)
@@ -311,18 +335,20 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 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 message = `${CODEX_APP_SERVER_PROVIDER} turn failed`;
-                    builder.emit({ type: "fail", message });
-                    throw new Error(message);
+                    throw createProviderFailure(message, {
+                        ...(turnState.failureCause ? { publicCause: turnState.failureCause } : {}),
+                    });
                 }
                 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);
+                    throw createProviderFailure(message);
                 }
                 // Successful turn/completed is consumption evidence; interrupt ack alone is not terminal proof.
                 const session = {
@@ -338,6 +364,7 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
                 return { finalMessage, session };
             }
             finally {
+                activeTurnCompletion = undefined;
                 rejectPendingTells(new Error(`${CODEX_APP_SERVER_PROVIDER} execution ended before queued tell acceptance`));
                 await server?.close();
                 server = undefined;
@@ -345,3 +372,5 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
         },
     });
 }
+// Compiler-level binding to the named ProviderAdapter function contract.
+startCodexAppServer;

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

@@ -1,7 +1,8 @@
 import { boundActivityExcerpt, diffstatFromUnifiedPatch } from "../../harness/activity-values.js";
 import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../../harness/events.js";
+import { createProviderFailure } from "../../harness/provider-adapter.js";
 import { createAbortError, emitProviderEvidence, coerceString } from "../../harness/runtime.js";
-const CODEX_APP_SERVER_PROVIDER = "codex-app-server";
+import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 const CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED = new Set([
     "item/agentMessage/delta",
     "item/commandExecution/outputDelta",
@@ -16,11 +17,18 @@ const CODEX_APP_SERVER_NOTIFICATION_MAPPED = new Set([
     "turn/completed",
     "error",
 ]);
-export function codexAppServerNotificationDisposition(method) {
+export function codexAppServerNotificationDisposition(method, params) {
     if (CODEX_APP_SERVER_NOTIFICATION_ACKNOWLEDGED.has(method))
         return "acknowledged-unpersisted";
     if (CODEX_APP_SERVER_NOTIFICATION_MAPPED.has(method))
         return "mapped";
+    if (method === "item/started") {
+        const item = appServerRecord(appServerRecord(params)?.item);
+        if (item && typeof item.type === "string" && isCodexAppServerActivityItemType(item.type))
+            return "mapped";
+    }
+    if (method === "account/rateLimits/updated" && codexAppServerRateLimitCause(params))
+        return "mapped";
     return "unknown";
 }
 export function appServerRecord(value) {
@@ -37,6 +45,41 @@ const CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES = [
 function isCodexAppServerActivityItemType(value) {
     return CODEX_APP_SERVER_ACTIVITY_ITEM_TYPES.includes(value);
 }
+/** Map a native or legacy fileChange kind fact into the public op. */
+function appServerFileChangeOp(kind) {
+    if (kind === "add" || kind === "update" || kind === "delete")
+        return kind;
+    const record = appServerRecord(kind);
+    if (!record)
+        return undefined;
+    if (record.type === "add" || record.type === "update" || record.type === "delete")
+        return record.type;
+    return undefined;
+}
+/** Trustworthy provider patch text only: per-change native `diff`, else legacy `details.patch`. */
+function appServerFileChangeDiffstat(item) {
+    let additions = 0;
+    let deletions = 0;
+    let saw = false;
+    if (Array.isArray(item.changes)) {
+        for (const entry of item.changes) {
+            const change = appServerRecord(entry);
+            if (!change || typeof change.diff !== "string" || !change.diff)
+                continue;
+            const partial = diffstatFromUnifiedPatch(change.diff);
+            if (!partial)
+                continue;
+            saw = true;
+            additions += partial.additions;
+            deletions += partial.deletions;
+        }
+    }
+    if (saw)
+        return additions || deletions ? { additions, deletions } : undefined;
+    const details = appServerRecord(item.details);
+    const patch = typeof details?.patch === "string" ? details.patch : undefined;
+    return patch ? diffstatFromUnifiedPatch(patch) : undefined;
+}
 export function appServerActivityCall(itemType, item) {
     switch (itemType) {
         case "commandExecution":
@@ -53,9 +96,9 @@ export function appServerActivityCall(itemType, item) {
                     const change = appServerRecord(entry);
                     if (!change || typeof change.path !== "string")
                         return [];
-                    if (change.kind !== "add" && change.kind !== "update" && change.kind !== "delete")
+                    const op = appServerFileChangeOp(change.kind);
+                    if (!op)
                         return [];
-                    const op = change.kind;
                     return [{ op, path: change.path }];
                 })
                 : [];
@@ -80,11 +123,7 @@ export function appServerActivityResult(item) {
             : typeof item.error === "string" && item.error
                 ? boundActivityExcerpt(item.error)
                 : undefined;
-    const details = item.details !== null && typeof item.details === "object" && !Array.isArray(item.details)
-        ? item.details
-        : undefined;
-    const patch = typeof details?.patch === "string" ? details.patch : undefined;
-    const diffstat = patch ? diffstatFromUnifiedPatch(patch) : undefined;
+    const diffstat = appServerFileChangeDiffstat(item);
     return {
         status: item.status === "failed" || (exitCode !== undefined && exitCode !== 0) ? "error" : "ok",
         ...(message ? { message } : {}),
@@ -131,9 +170,23 @@ export function createCodexAppServerTurnState() {
         responseSeenTurnIds: new Set(),
         completedBeforeResponseTurnIds: new Set(),
         activeTurnAcceptingSteer: false,
+        turnInFlight: false,
         lastAgentMessage: "",
     };
 }
+/** Admit only positive native exhaustion evidence; no provider strings survive. */
+export function codexAppServerRateLimitCause(params) {
+    const rateLimits = appServerRecord(appServerRecord(params)?.rateLimits);
+    if (!rateLimits)
+        return undefined;
+    for (const value of Object.values(rateLimits)) {
+        const window = appServerRecord(value);
+        if (typeof window?.usedPercent === "number" && window.usedPercent >= 100) {
+            return { kind: "rate_limit_exhausted" };
+        }
+    }
+    return undefined;
+}
 export function recordActiveTurnId(state, candidate, source) {
     const turnId = coerceString(candidate);
     if (!turnId)
@@ -178,7 +231,7 @@ export function createCodexAppServerTurnMonitor(options) {
         const failServerRequest = (request) => {
             // Policy A forbids interactive server→client requests. Fail immediately with named diagnostic.
             const message = `${CODEX_APP_SERVER_PROVIDER} unexpected server request '${request.method}' (id=${String(request.id)}); non-interactive policy forbids server→client requests`;
-            failTurn(new Error(message));
+            failTurn(createProviderFailure(message));
         };
         const requestDeliveryOpportunity = () => {
             try {
@@ -200,7 +253,7 @@ export function createCodexAppServerTurnMonitor(options) {
         });
         unsubNotifications = server.onNotification((notification) => {
             try {
-                builder.ingress(CODEX_APP_SERVER_PROVIDER, notification.method, notification, codexAppServerNotificationDisposition(notification.method), () => {
+                builder.ingress(CODEX_APP_SERVER_PROVIDER, notification.method, notification, codexAppServerNotificationDisposition(notification.method, notification.params), () => {
                     if (notification.method === "item/agentMessage/delta") {
                         const delta = coerceString(notification.params?.delta);
                         if (delta) {
@@ -255,6 +308,24 @@ export function createCodexAppServerTurnMonitor(options) {
                             });
                         }
                     }
+                    if (notification.method === "item/started") {
+                        const item = notification.params?.item;
+                        if (!item)
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/started lacked required item`);
+                        const id = coerceString(item.id);
+                        const itemType = coerceString(item.type);
+                        if (!id || !itemType)
+                            throw new Error(`${CODEX_APP_SERVER_PROVIDER} item/started lacked required item id or type`);
+                        if (isCodexAppServerActivityItemType(itemType)) {
+                            builder.emit({
+                                type: "activity",
+                                phase: "started",
+                                id,
+                                tool: itemType,
+                                call: appServerActivityCall(itemType, item),
+                            });
+                        }
+                    }
                     if (notification.method === "turn/started") {
                         const turn = notification.params?.turn;
                         const turnId = recordActiveTurnId(state, turn?.id, "notification");
@@ -274,6 +345,14 @@ export function createCodexAppServerTurnMonitor(options) {
                         onSyncCheckpoint?.({ enqueue }, checkpoint);
                         void drainPendingTells();
                     }
+                    if (notification.method === "account/rateLimits/updated") {
+                        const cause = codexAppServerRateLimitCause(notification.params);
+                        if (cause) {
+                            builder.emit({ type: "warning", warning: { reason: "rate-limit", state: "exhausted" } });
+                            if (state.turnInFlight)
+                                state.failureCause ??= cause;
+                        }
+                    }
                     if (notification.method === "turn/completed") {
                         const turn = notification.params?.turn ?? {};
                         const status = coerceString(turn.status) ?? "unknown";

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

@@ -0,0 +1 @@
+export const CODEX_APP_SERVER_PROVIDER = "codex-app-server";

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

@@ -0,0 +1,29 @@
+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;
+}