@prometheus-ai/ai 0.5.3 → 0.5.8

package/src/providers/openai-codex/request-transformer.ts

@@ -1,17 +1,25 @@
-import type { Effort } from "../../model-thinking";
-import { requireSupportedEffort } from "../../model-thinking";
+import type { Effort } from "@prometheus-ai/catalog/effort";
+import { requireSupportedEffort } from "@prometheus-ai/catalog/model-thinking";
 import type { Api, Model } from "../../types";
 
+/** Reasoning replay scope for the Codex Responses API (`reasoning.context`). */
+export type CodexReasoningContext = "auto" | "current_turn" | "all_turns";
+
 export interface ReasoningConfig {
 	effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	summary?: "auto" | "concise" | "detailed";
+	context?: CodexReasoningContext;
 }
 
 export interface CodexRequestOptions {
 	reasoningEffort?: ReasoningConfig["effort"];
 	reasoningSummary?: ReasoningConfig["summary"] | null;
+	/** Explicit `reasoning.context` override. Defaults to `all_turns` under {@link CodexRequestOptions.responsesLite}, otherwise omitted (server default is `current_turn`). */
+	reasoningContext?: CodexReasoningContext;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
+	/** Responses Lite transport contract: strips image detail and defaults `reasoning.context` to `all_turns`, mirroring codex-rs. */
+	responsesLite?: boolean;
 }
 
 export interface InputItem {
@@ -46,6 +54,7 @@ export interface RequestBody {
 	include?: string[];
 	prompt_cache_key?: string;
 	prompt_cache_retention?: "in_memory" | "24h";
+	client_metadata?: Record<string, string>;
 	max_output_tokens?: number;
 	max_completion_tokens?: number;
 	[key: string]: unknown;
@@ -76,6 +85,105 @@ function filterInput(input: InputItem[] | undefined): InputItem[] | undefined {
 		});
 }
 
+const CODEX_ORPHAN_OUTPUT_LIMIT = 16_000;
+/** Placeholder output for a tool call whose result never landed in the input. */
+const CODEX_INTERRUPTED_TOOL_OUTPUT =
+	"[No tool output recorded: the tool call was interrupted before it produced a result.]";
+
+function orphanFunctionOutputToMessage(item: InputItem, callId: string): InputItem {
+	const itemRecord = item as unknown as Record<string, unknown>;
+	const toolName = typeof itemRecord.name === "string" ? itemRecord.name : "tool";
+	let text = "";
+	try {
+		const output = itemRecord.output;
+		text = typeof output === "string" ? output : JSON.stringify(output);
+	} catch {
+		text = String(itemRecord.output ?? "");
+	}
+	if (text.length > CODEX_ORPHAN_OUTPUT_LIMIT) {
+		text = `${text.slice(0, CODEX_ORPHAN_OUTPUT_LIMIT)}\n...[truncated]`;
+	}
+	return {
+		type: "message",
+		role: "assistant",
+		content: `[Previous ${toolName} result; call_id=${callId}]: ${text}`,
+	} as InputItem;
+}
+
+/**
+ * Repair both halves of unpaired tool exchanges so the Responses input grammar
+ * stays valid — the API rejects either orphan with a 400:
+ *
+ * - `function_call_output` / `custom_tool_call_output` with no matching call →
+ *   folded into an assistant message (`400 No tool call found for … output`).
+ *   Regression of #472 / #1351.
+ * - `function_call` / `custom_tool_call` with no matching `*_output` → a
+ *   placeholder output is synthesized immediately after the call
+ *   (`400 No tool output found for function call …`). Hit when the user
+ *   branches/navigates the session tree to a node that ends on a tool call (the
+ *   tool-result child is dropped from the reconstructed history) or when a turn
+ *   is aborted/crashes after the call streamed but before its result persisted.
+ */
+function repairToolCallPairs(input: InputItem[]): InputItem[] {
+	const callIds = new Set<string>();
+	const outputCallIds = new Set<string>();
+	for (const item of input) {
+		const callId = typeof item.call_id === "string" ? item.call_id : undefined;
+		if (callId === undefined) continue;
+		if (item.type === "function_call" || item.type === "custom_tool_call") callIds.add(callId);
+		else if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+			outputCallIds.add(callId);
+		}
+	}
+
+	const repaired: InputItem[] = [];
+	for (const item of input) {
+		const callId = typeof item.call_id === "string" ? item.call_id : undefined;
+
+		if (
+			(item.type === "function_call_output" || item.type === "custom_tool_call_output") &&
+			callId !== undefined &&
+			!callIds.has(callId)
+		) {
+			repaired.push(orphanFunctionOutputToMessage(item, callId));
+			continue;
+		}
+
+		repaired.push(item);
+
+		if (
+			(item.type === "function_call" || item.type === "custom_tool_call") &&
+			callId !== undefined &&
+			!outputCallIds.has(callId)
+		) {
+			repaired.push({
+				type: item.type === "custom_tool_call" ? "custom_tool_call_output" : "function_call_output",
+				call_id: callId,
+				output: CODEX_INTERRUPTED_TOOL_OUTPUT,
+			} as InputItem);
+		}
+	}
+	return repaired;
+}
+
+/**
+ * Responses Lite requests must not pin image detail levels: codex-rs strips
+ * `detail` from every input image (message content and tool outputs) before
+ * sending, letting the server choose.
+ */
+function stripImageDetails(input: InputItem[]): void {
+	for (const item of input) {
+		for (const collection of [item.content, item.output]) {
+			if (!Array.isArray(collection)) continue;
+			for (const part of collection) {
+				if (part && typeof part === "object" && (part as { type?: unknown }).type === "input_image") {
+					delete (part as { detail?: unknown }).detail;
+				}
+			}
+		}
+	}
+}
+
 export async function transformRequestBody(
 	body: RequestBody,
 	model: Model<Api>,
@@ -87,39 +195,8 @@ export async function transformRequestBody(
 
 	if (body.input && Array.isArray(body.input)) {
 		body.input = filterInput(body.input);
-
 		if (body.input) {
-			const functionCallIds = new Set(
-				body.input
-					.filter(item => item.type === "function_call" && typeof item.call_id === "string")
-					.map(item => item.call_id as string),
-			);
-
-			body.input = body.input.map(item => {
-				if (item.type === "function_call_output" && typeof item.call_id === "string") {
-					const callId = item.call_id as string;
-					if (!functionCallIds.has(callId)) {
-						const itemRecord = item as unknown as Record<string, unknown>;
-						const toolName = typeof itemRecord.name === "string" ? itemRecord.name : "tool";
-						let text = "";
-						try {
-							const output = itemRecord.output;
-							text = typeof output === "string" ? output : JSON.stringify(output);
-						} catch {
-							text = String(itemRecord.output ?? "");
-						}
-						if (text.length > 16000) {
-							text = `${text.slice(0, 16000)}\n...[truncated]`;
-						}
-						return {
-							type: "message",
-							role: "assistant",
-							content: `[Previous ${toolName} result; call_id=${callId}]: ${text}`,
-						} as InputItem;
-					}
-				}
-				return item;
-			});
+			body.input = repairToolCallPairs(body.input);
 		}
 	}
 
@@ -135,12 +212,30 @@ export async function transformRequestBody(
 		body.input = [...developerMessages, ...body.input];
 	}
 
+	if (options.responsesLite) {
+		if (Array.isArray(body.input)) {
+			stripImageDetails(body.input);
+		}
+		// Responses Lite does not support parallel tool calling; codex-rs forces
+		// it off (`prompt.parallel_tool_calls && !use_responses_lite`).
+		if (body.tools !== undefined) {
+			body.parallel_tool_calls = false;
+		}
+	}
+
 	if (options.reasoningEffort !== undefined) {
 		const reasoningConfig = getReasoningConfig(model, options);
 		body.reasoning = {
 			...body.reasoning,
 			...reasoningConfig,
 		};
+		// Responses Lite keeps reasoning replay server-side; codex-rs requests
+		// `all_turns` there and otherwise omits context so the server default
+		// (currently `current_turn`) applies.
+		const reasoningContext = options.reasoningContext ?? (options.responsesLite ? "all_turns" : undefined);
+		if (reasoningContext !== undefined) {
+			body.reasoning.context = reasoningContext;
+		}
 	} else {
 		delete body.reasoning;
 	}

package/src/providers/openai-codex/response-handler.ts

@@ -1,4 +1,5 @@
-import { toNumber } from "../../utils";
+import { toNumber } from "@prometheus-ai/catalog/utils";
+import { ProviderHttpError } from "../../errors";
 
 export type CodexRateLimit = {
 	used_percent?: number;
@@ -14,16 +15,34 @@ export type CodexRateLimits = {
 export type CodexErrorInfo = {
 	message: string;
 	status: number;
+	/** Machine-readable error code (`error.code` or `error.type` from the response body), when present. */
+	code?: string;
 	friendlyMessage?: string;
 	rateLimits?: CodexRateLimits;
 	raw?: string;
 };
 
+/** Non-2xx response from the Codex backend, with the parsed body retained. */
+export class CodexApiError extends ProviderHttpError {
+	readonly info: CodexErrorInfo;
+
+	constructor(info: CodexErrorInfo, headers?: Headers) {
+		super(info.friendlyMessage || info.message, info.status, { headers, code: info.code });
+		this.name = "CodexApiError";
+		this.info = info;
+	}
+
+	static async fromResponse(response: Response): Promise<CodexApiError> {
+		return new CodexApiError(await parseCodexError(response), response.headers);
+	}
+}
+
 export async function parseCodexError(response: Response): Promise<CodexErrorInfo> {
 	const raw = await response.text();
 	let message = raw || response.statusText || "Request failed";
 	let friendlyMessage: string | undefined;
 	let rateLimits: CodexRateLimits | undefined;
+	let errorCode: string | undefined;
 
 	try {
 		const parsed = JSON.parse(raw) as { error?: Record<string, unknown> };
@@ -46,6 +65,7 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 				: undefined;
 
 		const code = String((err as { code?: string; type?: string }).code ?? (err as { type?: string }).type ?? "");
+		errorCode = code || undefined;
 		const resetsAt = (err as { resets_at?: number }).resets_at ?? primary.resets_at ?? secondary.resets_at;
 		const mins = resetsAt ? Math.max(0, Math.round((resetsAt * 1000 - Date.now()) / 60000)) : undefined;
 
@@ -68,6 +88,7 @@ export async function parseCodexError(response: Response): Promise<CodexErrorInf
 	return {
 		message,
 		status: response.status,
+		code: errorCode,
 		friendlyMessage,
 		rateLimits,
 		raw: raw,