@shivaedev/agent-codex 0.1.0 → 0.3.0

package/src/adapters/mapping.ts

@@ -0,0 +1,66 @@
+import { Option, Schema } from "effect";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { itemCompleted, itemStarted } from "#adapters/items.ts";
+import {
+	ItemNotification,
+	ModelReroutedNotification,
+	ThreadStatusNotification,
+	TokenUsageNotification,
+	TurnNotification,
+} from "#adapters/protocol.ts";
+import { RATE_LIMITS_METHOD, rateLimitEvents } from "#adapters/rateLimits.ts";
+import type { RpcNotification } from "#adapters/rpc.ts";
+export function rawOf(kind: string, payload: unknown) {
+	return { kind, payload: JSON.stringify(payload), source: "codex" };
+}
+function mapped<A, E>(schema: Schema.Codec<A, E>, notification: RpcNotification, project: (value: A) => RunEvent[]): RunEvent[] {
+	return Option.match(Schema.decodeUnknownOption(schema)(notification.params), {
+		onNone: () => [{ raw: rawOf(notification.method, notification.params), type: "raw" }],
+		onSome: project,
+	});
+}
+export function toAgentEvents(notification: RpcNotification, model: string): RunEvent[] {
+	const { method, params } = notification;
+	const raw = rawOf(method, params);
+	switch (method) {
+		case RATE_LIMITS_METHOD:
+			return rateLimitEvents(raw, params);
+		case "item/started":
+			return mapped(ItemNotification, notification, ({ item }) => itemStarted(raw, item));
+		case "item/completed":
+			return mapped(ItemNotification, notification, ({ item }) => itemCompleted(raw, item));
+		case "turn/started":
+			return mapped(TurnNotification, notification, () => [{ raw, state: "running", type: "execution" }]);
+		case "turn/completed":
+			return mapped(TurnNotification, notification, ({ turn }) => [
+				{ raw, state: turn.status === "inProgress" ? "running" : turn.status, type: "execution" },
+			]);
+		case "thread/status/changed":
+			return mapped(ThreadStatusNotification, notification, ({ status }) =>
+				status.type === "active"
+					? [{ raw, state: status.activeFlags.length > 0 ? "awaiting-input" : "running", type: "execution" }]
+					: [{ raw, type: "raw" }],
+			);
+		case "thread/tokenUsage/updated":
+			return mapped(TokenUsageNotification, notification, ({ tokenUsage }) => {
+				const tokens = tokenUsage.total;
+				return [
+					{
+						cacheReadTokens: tokens.cachedInputTokens,
+						inputTokens: tokens.inputTokens,
+						outputTokens: tokens.outputTokens,
+						scope: "cumulative",
+						type: "usage",
+						unit: "session",
+						...(model.length === 0 ? {} : { model }),
+						...(tokens.cacheWriteInputTokens === undefined ? {} : { cacheWriteTokens: tokens.cacheWriteInputTokens }),
+						raw,
+					},
+				];
+			});
+		case "model/rerouted":
+			return mapped(ModelReroutedNotification, notification, ({ toModel, reason }) => [{ model: toModel, raw, reason, type: "model.changed" }]);
+		default:
+			return [{ raw, type: "raw" }];
+	}
+}

package/src/adapters/process.ts

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+
+export interface LineProcess {
+	readonly kill: () => void;
+	readonly onExit: (listener: (code: number | null) => void) => void;
+	readonly onLine: (listener: (line: string) => void) => void;
+	readonly onStderr: (listener: (text: string) => void) => void;
+	readonly write: (line: string) => void;
+}
+
+interface SpawnLineProcessOptions {
+	readonly args: readonly string[];
+	readonly command: string;
+	readonly cwd: string;
+}
+
+// Codex app-server uses newline-delimited JSON over stdio.
+export function spawnLineProcess(options: SpawnLineProcessOptions): LineProcess {
+	const child = spawn(options.command, [...options.args], {
+		cwd: options.cwd,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+	let lineListener: ((line: string) => void) | null = null;
+	let stderrListener: ((text: string) => void) | null = null;
+	const exitListeners: ((code: number | null) => void)[] = [];
+	function emitExit(code: number | null): void {
+		for (const listener of exitListeners) {
+			listener(code);
+		}
+	}
+	let buffer = "";
+	child.stdout.setEncoding("utf8");
+	child.stdout.on("data", (chunk: string) => {
+		buffer += chunk;
+		let newline = buffer.indexOf("\n");
+		while (newline >= 0) {
+			const line = buffer.slice(0, newline).trim();
+			buffer = buffer.slice(newline + 1);
+			if (line.length > 0) {
+				lineListener?.(line);
+			}
+			newline = buffer.indexOf("\n");
+		}
+	});
+	child.stderr.setEncoding("utf8");
+	child.stderr.on("data", (chunk: string) => stderrListener?.(chunk));
+	child.on("exit", (code) => emitExit(code));
+	child.on("error", () => emitExit(null));
+	child.stdin.on("error", () => emitExit(null));
+	return {
+		// Closing stdin lets app-server exit cleanly; SIGTERM handles a child that remains alive.
+		kill: () => {
+			child.stdin.end();
+			child.kill("SIGTERM");
+		},
+		onExit: (listener) => {
+			exitListeners.push(listener);
+		},
+		onLine: (listener) => {
+			lineListener = listener;
+		},
+		onStderr: (listener) => {
+			stderrListener = listener;
+		},
+		write: (line) => {
+			child.stdin.write(`${line}\n`);
+		},
+	};
+}

package/src/adapters/protocol.ts

@@ -0,0 +1,125 @@
+import { Schema } from "effect";
+
+export const PINNED_CLI_VERSION = "0.154.0-alpha.6.2";
+
+export const InitializeResponse = Schema.Struct({ userAgent: Schema.String });
+
+const ThreadRef = Schema.Struct({ id: Schema.String });
+
+export const ThreadResponse = Schema.Struct({ thread: ThreadRef });
+
+const ReasoningEffort = Schema.NonEmptyString;
+
+export const TurnStatus = Schema.Literals(["completed", "interrupted", "failed", "inProgress"]);
+
+export const TurnError = Schema.Struct({ message: Schema.String });
+
+export const Turn = Schema.Struct({
+	durationMs: Schema.optional(Schema.NullOr(Schema.Number)),
+	error: Schema.optional(Schema.NullOr(TurnError)),
+	id: Schema.String,
+	status: TurnStatus,
+});
+
+export const TurnResponse = Schema.Struct({ turn: Turn });
+
+export const ModelListResponse = Schema.Struct({
+	data: Schema.Array(
+		Schema.Struct({
+			defaultReasoningEffort: ReasoningEffort,
+			displayName: Schema.String,
+			isDefault: Schema.Boolean,
+			model: Schema.String,
+			supportedReasoningEfforts: Schema.Array(Schema.Struct({ reasoningEffort: ReasoningEffort })),
+		}),
+	),
+});
+
+export const DynamicToolCallParams = Schema.Struct({
+	arguments: Schema.Unknown,
+	callId: Schema.String,
+	threadId: Schema.String,
+	tool: Schema.String,
+});
+
+export const ItemNotification = Schema.Struct({
+	item: Schema.Unknown,
+	threadId: Schema.String,
+	turnId: Schema.String,
+});
+
+export const TurnNotification = Schema.Struct({
+	threadId: Schema.String,
+	turn: Turn,
+});
+
+const TokenBreakdown = Schema.Struct({
+	cachedInputTokens: Schema.Number,
+	cacheWriteInputTokens: Schema.optional(Schema.Number),
+	inputTokens: Schema.Number,
+	outputTokens: Schema.Number,
+});
+
+export const TokenUsageNotification = Schema.Struct({
+	threadId: Schema.String,
+	tokenUsage: Schema.Struct({ last: TokenBreakdown, total: TokenBreakdown }),
+	turnId: Schema.String,
+});
+
+export const ModelReroutedNotification = Schema.Struct({
+	fromModel: Schema.String,
+	reason: Schema.String,
+	threadId: Schema.String,
+	toModel: Schema.String,
+	turnId: Schema.String,
+});
+
+export const ThreadSettingsUpdatedNotification = Schema.Struct({
+	threadId: Schema.String,
+	threadSettings: Schema.Struct({ model: Schema.String }),
+});
+
+export const ThreadScoped = Schema.Struct({ threadId: Schema.String });
+
+const SpawnSource = Schema.Struct({
+	subAgent: Schema.Struct({
+		threadSpawn: Schema.Struct({
+			agentNickname: Schema.optional(Schema.NullOr(Schema.String)),
+			agentPath: Schema.optional(Schema.NullOr(Schema.String)),
+			agentRole: Schema.optional(Schema.NullOr(Schema.String)),
+			parentThreadId: Schema.String,
+		}).pipe(
+			Schema.encodeKeys({ agentNickname: "agent_nickname", agentPath: "agent_path", agentRole: "agent_role", parentThreadId: "parent_thread_id" }),
+		),
+	}).pipe(Schema.encodeKeys({ threadSpawn: "thread_spawn" })),
+});
+
+export const SpawnedThread = Schema.Struct({
+	thread: Schema.Struct({ id: Schema.String, source: SpawnSource }),
+});
+
+export const ThreadStatus = Schema.Union([
+	Schema.Struct({
+		activeFlags: Schema.Array(Schema.String),
+		type: Schema.Literal("active"),
+	}),
+	Schema.Struct({ type: Schema.Literal("idle") }),
+	Schema.Struct({ type: Schema.Literal("notLoaded") }),
+	Schema.Struct({ type: Schema.Literal("systemError") }),
+]);
+
+export const ThreadListResponse = Schema.Struct({
+	data: Schema.Array(
+		Schema.Struct({
+			id: Schema.String,
+			source: SpawnSource,
+			status: ThreadStatus,
+		}),
+	),
+	nextCursor: Schema.optional(Schema.NullOr(Schema.String)),
+});
+
+export const ThreadStatusNotification = Schema.Struct({
+	status: ThreadStatus,
+	threadId: Schema.String,
+});

package/src/adapters/protocolItems.ts

@@ -0,0 +1,113 @@
+import { Schema } from "effect";
+import { TurnError } from "#adapters/protocol.ts";
+import { UserMessageItem } from "#adapters/UserMessageItem.ts";
+
+const item = { id: Schema.String };
+
+export const ExecutionStatus = Schema.Literals(["inProgress", "completed", "failed", "declined"]);
+
+const AgentMessageItem = Schema.Struct({
+	...item,
+	text: Schema.String,
+	type: Schema.Literal("agentMessage"),
+});
+
+const ReasoningItem = Schema.Struct({
+	...item,
+	content: Schema.optional(Schema.Array(Schema.String)),
+	summary: Schema.optional(Schema.Array(Schema.String)),
+	type: Schema.Literal("reasoning"),
+});
+
+const CommandExecutionItem = Schema.Struct({
+	...item,
+	aggregatedOutput: Schema.optional(Schema.NullOr(Schema.String)),
+	command: Schema.String,
+	cwd: Schema.String,
+	exitCode: Schema.optional(Schema.NullOr(Schema.Number)),
+	status: ExecutionStatus,
+	type: Schema.Literal("commandExecution"),
+});
+
+const FileChangeItem = Schema.Struct({
+	...item,
+	changes: Schema.Array(Schema.Struct({ diff: Schema.String, path: Schema.String })),
+	status: ExecutionStatus,
+	type: Schema.Literal("fileChange"),
+});
+
+const McpToolCallItem = Schema.Struct({
+	...item,
+	arguments: Schema.Unknown,
+	error: Schema.optional(Schema.NullOr(TurnError)),
+	result: Schema.optional(Schema.Unknown),
+	server: Schema.String,
+	status: Schema.Literals(["inProgress", "completed", "failed"]),
+	tool: Schema.String,
+	type: Schema.Literal("mcpToolCall"),
+});
+
+const ContentPart = Schema.Struct({
+	text: Schema.optional(Schema.String),
+	type: Schema.String,
+});
+
+// Codex reports dynamic-tool outcomes through `success` in addition to status.
+const DynamicToolCallItem = Schema.Struct({
+	...item,
+	arguments: Schema.Unknown,
+	contentItems: Schema.optional(Schema.NullOr(Schema.Array(ContentPart))),
+	status: Schema.Literals(["inProgress", "completed", "failed"]),
+	success: Schema.optional(Schema.NullOr(Schema.Boolean)),
+	tool: Schema.String,
+	type: Schema.Literal("dynamicToolCall"),
+});
+
+const WebSearchItem = Schema.Struct({
+	...item,
+	query: Schema.String,
+	type: Schema.Literal("webSearch"),
+});
+
+const SubAgentActivityItem = Schema.Struct({
+	...item,
+	agentPath: Schema.String,
+	agentThreadId: Schema.String,
+	kind: Schema.Literals(["started", "interacted", "interrupted", "completed"]),
+	type: Schema.Literal("subAgentActivity"),
+});
+
+// Codex reports collaboration operations as dynamic-tool items.
+const CollabAgentToolCallItem = Schema.Struct({
+	...item,
+	prompt: Schema.optional(Schema.NullOr(Schema.String)),
+	receiverThreadIds: Schema.Array(Schema.String),
+	senderThreadId: Schema.String,
+	status: Schema.Literals(["inProgress", "completed", "failed", "interrupted"]),
+	tool: Schema.Literals([
+		"spawnAgent",
+		"sendInput",
+		"resumeAgent",
+		"wait",
+		"closeAgent",
+		"sendMessage",
+		"followupTask",
+		"interruptAgent",
+		"listAgents",
+	]),
+	type: Schema.Literal("collabAgentToolCall"),
+});
+
+export const KnownItem = Schema.Union([
+	AgentMessageItem,
+	UserMessageItem,
+	ReasoningItem,
+	CollabAgentToolCallItem,
+	CommandExecutionItem,
+	DynamicToolCallItem,
+	FileChangeItem,
+	McpToolCallItem,
+	SubAgentActivityItem,
+	WebSearchItem,
+]);
+export type KnownItem = typeof KnownItem.Type;

package/src/adapters/rateLimits.ts

@@ -0,0 +1,55 @@
+import type { Raw as RawSchema } from "@shivaedev/agent/eventData.ts";
+import type { RunEvent as AgentEvent } from "@shivaedev/agent/events.ts";
+
+type RawPayload = typeof RawSchema.Type;
+
+import { Option, Schema } from "effect";
+
+export const RATE_LIMITS_METHOD = "account/rateLimits/updated";
+
+const CodexWindow = Schema.Struct({
+	resetsAt: Schema.optional(Schema.NullOr(Schema.Number)),
+	usedPercent: Schema.Number,
+	windowDurationMins: Schema.optional(Schema.NullOr(Schema.Number)),
+});
+
+const RateLimitsNotification = Schema.Struct({
+	rateLimits: Schema.Struct({
+		primary: Schema.optional(Schema.NullOr(CodexWindow)),
+		rateLimitReachedType: Schema.optional(Schema.NullOr(Schema.String)),
+		secondary: Schema.optional(Schema.NullOr(CodexWindow)),
+	}),
+});
+
+type Snapshot = typeof RateLimitsNotification.Type.rateLimits;
+type Window = Extract<AgentEvent, { type: "rate.limit" }>["windows"][number];
+
+const decodeRateLimits = Schema.decodeUnknownOption(RateLimitsNotification);
+
+function present<T>(value: T | null | undefined): value is T {
+	return value !== null && value !== undefined;
+}
+
+function windowOf(window: typeof CodexWindow.Type): Window {
+	return {
+		...(present(window.windowDurationMins) ? { durationMinutes: window.windowDurationMins } : {}),
+		...(present(window.resetsAt) ? { resetsAt: window.resetsAt * 1000 } : {}),
+		usedPercent: window.usedPercent,
+	};
+}
+
+function event(raw: RawPayload, snapshot: Snapshot): AgentEvent {
+	return {
+		raw,
+		status: present(snapshot.rateLimitReachedType) ? "rejected" : "unknown",
+		type: "rate.limit",
+		windows: [snapshot.primary, snapshot.secondary].filter(present).map(windowOf),
+	};
+}
+
+export function rateLimitEvents(raw: RawPayload, params: unknown): AgentEvent[] {
+	return Option.match(decodeRateLimits(params), {
+		onNone: () => [{ raw, type: "raw" }],
+		onSome: ({ rateLimits }) => [event(raw, rateLimits)],
+	});
+}

package/src/adapters/reads.ts

@@ -0,0 +1,93 @@
+import { Effect, Schema } from "effect";
+import type { RunEvent } from "@shivaedev/agent/events.ts";
+import { ProtocolFailure, type ReadFailure } from "@shivaedev/agent/failures.ts";
+import type { Observation, Receipt } from "@shivaedev/agent/run.ts";
+import { itemCompleted, itemStarted } from "#adapters/items.ts";
+import { rawOf } from "#adapters/mapping.ts";
+import { AppServer } from "#adapters/server.ts";
+export const Item = Schema.Struct({ clientId: Schema.optional(Schema.NullOr(Schema.String)), id: Schema.String, type: Schema.String });
+export const Turn = Schema.Struct({
+	id: Schema.String,
+	items: Schema.Array(Schema.Unknown),
+	status: Schema.Literals(["inProgress", "completed", "failed", "interrupted"]),
+});
+const Turns = Schema.Struct({ data: Schema.Array(Turn), nextCursor: Schema.NullOr(Schema.String) });
+const Items = Schema.Struct({ data: Schema.Array(Schema.Struct({ item: Schema.Unknown })), nextCursor: Schema.NullOr(Schema.String) });
+export function decode<A, E>(schema: Schema.Codec<A, E>, value: unknown) {
+	return Schema.decodeUnknownEffect(schema)(value).pipe(
+		Effect.mapError(() => new ProtocolFailure({ backend: "codex", message: "Incompatible Codex response" })),
+	);
+}
+export const readRequest = Effect.fn("Codex.readRequest")(function* (method: string, params: unknown) {
+	const server = yield* AppServer;
+	return yield* server.request(method, params).pipe(
+		Effect.mapError(
+			(error): ReadFailure =>
+				error._tag === "BackendUnavailable" || error._tag === "ProtocolFailure"
+					? error
+					: new ProtocolFailure({
+							backend: "codex",
+							message: error.message,
+							...(error.providerCode === undefined ? {} : { providerCode: error.providerCode }),
+						}),
+		),
+	);
+});
+export const turns = Effect.fn("Codex.turns")(function* (threadId: string) {
+	const found: (typeof Turn.Type)[] = [];
+	const seen = new Set<string>();
+	let cursor: string | null = null;
+	do {
+		const page: typeof Turns.Type = yield* readRequest("thread/turns/list", {
+			cursor,
+			itemsView: "full",
+			limit: 100,
+			sortDirection: "desc",
+			threadId,
+		}).pipe(Effect.flatMap((value) => decode(Turns, value)));
+		found.push(...page.data);
+		cursor = page.nextCursor;
+		if (cursor !== null && seen.has(cursor)) {
+			return yield* new ProtocolFailure({ backend: "codex", message: "Repeated turn cursor" });
+		}
+		if (cursor !== null) {
+			seen.add(cursor);
+		}
+	} while (cursor !== null);
+	return found;
+});
+export function observe(receipt: Receipt) {
+	return turns(receipt.session?.value ?? "").pipe(
+		Effect.map((values): Observation => {
+			const turn = values.find((candidate) => candidate.id === receipt.reference.value);
+			return turn === undefined
+				? { reason: "The accepted turn is not observable; absence does not authorize replay", type: "missing" }
+				: { state: turn.status === "inProgress" ? "running" : turn.status, type: "known" };
+		}),
+	);
+}
+export const transcript = Effect.fn("Codex.transcript")(function* (receipt: Receipt) {
+	const events: RunEvent[] = [];
+	const seen = new Set<string>();
+	let cursor: string | null = null;
+	do {
+		const page: typeof Items.Type = yield* readRequest("thread/items/list", {
+			cursor,
+			limit: 100,
+			sortDirection: "asc",
+			threadId: receipt.session?.value,
+			turnId: receipt.reference.value,
+		}).pipe(Effect.flatMap((value) => decode(Items, value)));
+		for (const { item } of page.data) {
+			events.push(...itemStarted(rawOf("thread/items/list", item), item), ...itemCompleted(rawOf("thread/items/list", item), item));
+		}
+		cursor = page.nextCursor;
+		if (cursor !== null && seen.has(cursor)) {
+			return yield* new ProtocolFailure({ backend: "codex", message: "Repeated item cursor" });
+		}
+		if (cursor !== null) {
+			seen.add(cursor);
+		}
+	} while (cursor !== null);
+	return { completeness: events.some((event) => event.type === "raw") ? ("partial" as const) : ("complete" as const), events };
+});

package/src/adapters/recovery.ts

@@ -0,0 +1,44 @@
+import { Effect, Schema } from "effect";
+import type { ReadFailure } from "@shivaedev/agent/failures.ts";
+import type { Receipt, Reconciliation } from "@shivaedev/agent/run.ts";
+import { Item, turns } from "#adapters/reads.ts";
+import { AppServer } from "#adapters/server.ts";
+import type { Session } from "#adapters/session.ts";
+export function receiptOf(operationId: string, threadId: string, turnId: string): Receipt {
+	return { backend: "codex", operationId, reference: { value: turnId, version: 1 }, session: { value: threadId, version: 1 } };
+}
+export const recovery = Effect.fn("Codex.recovery")(function* (sessions: Map<string, Session>) {
+	const server = yield* AppServer;
+	const operations = new Map<string, string | undefined>();
+	const refusals = new Map<string, string>();
+	const reconcile = Effect.fn("Codex.reconcile")(function* (operationId: string): Effect.fn.Return<Reconciliation, ReadFailure, AppServer> {
+		const refusal = refusals.get(operationId);
+		if (refusal !== undefined) {
+			return { evidence: refusal, operationId, type: "not-accepted" };
+		}
+		const threadId = operations.get(operationId);
+		if (threadId === undefined) {
+			return { operationId, reason: "No local thread association; recover the session reference in the application", type: "uncertain" };
+		}
+		const matches = (yield* turns(threadId)).filter((turn) =>
+			turn.items.some((item) => {
+				const decoded = Schema.decodeUnknownOption(Item)(item);
+				return decoded._tag === "Some" && decoded.value.type === "userMessage" && decoded.value.clientId === operationId;
+			}),
+		);
+		const found = matches[0];
+		if (matches.length !== 1 || found === undefined) {
+			return {
+				operationId,
+				reason:
+					matches.length > 1
+						? "Multiple turns match this operation; preserve ownership"
+						: "No matching turn is observable; absence does not authorize replay",
+				type: "uncertain",
+			};
+		}
+		yield* sessions.get(threadId)?.driver.recovered(found.id, found.status === "inProgress") ?? Effect.void;
+		return { receipt: receiptOf(operationId, threadId, found.id), type: "accepted" };
+	});
+	return { operations, reconcile: (operationId: string) => reconcile(operationId).pipe(Effect.provideService(AppServer, server)), refusals };
+});

package/src/adapters/residualApproval.ts

@@ -0,0 +1,23 @@
+import { Option } from "effect";
+import type { RpcServerRequest } from "#adapters/rpc.ts";
+
+const DECLINED = "No approval consumer is configured";
+
+export function residualApproval(request: RpcServerRequest): Option.Option<unknown> {
+	switch (request.method) {
+		case "item/commandExecution/requestApproval":
+		case "item/fileChange/requestApproval":
+			return Option.some({ decision: "decline" });
+		case "item/permissions/requestApproval":
+			return Option.some({ permissions: {}, scope: "turn" });
+		case "item/tool/requestUserInput":
+			return Option.some({ answers: {} });
+		case "mcpServer/elicitation/request":
+			return Option.some({ "_meta": null, action: "decline", content: null });
+		case "execCommandApproval":
+		case "applyPatchApproval":
+			return Option.some({ decision: { denied: { rejection: DECLINED } } });
+		default:
+			return Option.none();
+	}
+}

package/src/adapters/rpc.ts

@@ -0,0 +1,8 @@
+export interface RpcNotification {
+	readonly method: string;
+	readonly params: unknown;
+}
+
+export interface RpcServerRequest extends RpcNotification {
+	readonly id: number | string;
+}

package/src/adapters/rpcProtocol.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import { ProtocolFailure, Rejected } from "@shivaedev/agent/failures.ts";
+export const Envelope = Schema.Struct({
+	error: Schema.optional(Schema.Unknown),
+	id: Schema.optional(Schema.Union([Schema.Number, Schema.String])),
+	method: Schema.optional(Schema.String),
+	params: Schema.optional(Schema.Unknown),
+	result: Schema.optional(Schema.Unknown),
+});
+const RpcError = Schema.Struct({
+	code: Schema.optional(Schema.Number),
+	data: Schema.optional(Schema.Struct({ codexErrorInfo: Schema.optional(Schema.Unknown) })),
+	message: Schema.String,
+});
+const Capacity = Schema.Literals(["rateLimitExceeded", "flexUnavailable", "serverOverloaded", "usageLimitExceeded"]);
+export function rejected(value: unknown) {
+	const error = Schema.decodeUnknownOption(RpcError)(value);
+	if (error._tag === "None") {
+		return new ProtocolFailure({ backend: "codex", message: "Invalid Codex rejection" });
+	}
+	const capacity = Schema.decodeUnknownOption(Capacity)(error.value.data?.codexErrorInfo);
+	const code = error.value.code === -32_001 ? "session-queue-full" : String(error.value.code ?? "rejected");
+	return new Rejected({
+		backend: "codex",
+		message: error.value.message,
+		providerCode: capacity._tag === "Some" ? capacity.value : code,
+	});
+}