@oh-my-pi/pi-ai 16.3.14 → 16.4.0

package/src/providers/openai-chat-server-schema.ts

@@ -209,7 +209,7 @@ export const openaiChatRequestSchema = type({
 	"frequency_penalty?": "number",
 	"logit_bias?": type({ "[string]": "number" }),
 	"user?": "string",
-	"reasoning_effort?": "'minimal' | 'low' | 'medium' | 'high' | 'xhigh'",
+	"reasoning_effort?": "'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max'",
 	"parallel_tool_calls?": "boolean",
 	"service_tier?": "'auto' | 'default' | 'flex' | 'scale' | 'priority'",
 	"metadata?": type({ "[string]": "unknown" }),

package/src/providers/openai-chat-server.ts

@@ -35,7 +35,14 @@ export type { ParsedRequest };
 type ReasoningEffort = NonNullable<ParsedRequest["options"]["reasoning"]>;
 
 function isReasoningEffort(value: unknown): value is ReasoningEffort {
-	return value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+	return (
+		value === "minimal" ||
+		value === "low" ||
+		value === "medium" ||
+		value === "high" ||
+		value === "xhigh" ||
+		value === "max"
+	);
 }
 
 function isServiceTier(value: unknown): value is ServiceTier {

package/src/providers/openai-chat-wire.ts

@@ -116,7 +116,7 @@ export type Metadata = {
 };
 
 /** Constrains effort on reasoning for reasoning models. */
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | null;
+export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | null;
 
 /** JSON object response format (older JSON mode). */
 export interface ResponseFormatJSONObject {

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

@@ -8,7 +8,7 @@ import { mapOpenAIReasoningEffort } from "../openai-shared";
 export type CodexReasoningContext = "auto" | "current_turn" | "all_turns";
 
 /** User-facing effort levels accepted by Codex request options. */
-type CodexCallerEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+type CodexCallerEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 
 /** Caller literal → catalog `Effort` bridge (the enum is nominal). */
 const EFFORT_BY_NAME: Record<CodexCallerEffort, Effort> = {
@@ -17,23 +17,31 @@ const EFFORT_BY_NAME: Record<CodexCallerEffort, Effort> = {
 	medium: Effort.Medium,
 	high: Effort.High,
 	xhigh: Effort.XHigh,
+	max: Effort.Max,
 };
 
 export interface ReasoningConfig {
 	effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 	summary?: "auto" | "concise" | "detailed";
 	context?: CodexReasoningContext;
+	/** Pro reasoning serving mode (gpt-5.6+ catalog pro aliases). */
+	mode?: "pro";
 }
 
 export interface CodexRequestOptions {
-	/** User-facing effort; the wire-only `max` tier is reached via the model's effort map. */
+	/** User-facing effort; maps 1:1 onto the wire tier of the same name. */
 	reasoningEffort?: CodexCallerEffort | "none";
 	reasoningSummary?: ReasoningConfig["summary"] | null;
 	/** Explicit `reasoning.context` override; defaults to `all_turns` when unset. The `all_turns` value is gated to gpt-5.4+ Codex models — older ids reject it, so it is suppressed and `context` omitted. */
 	reasoningContext?: CodexReasoningContext;
 	textVerbosity?: "low" | "medium" | "high";
 	include?: string[];
-	/** Responses Lite transport contract: strips image detail and disables parallel tool calling, mirroring codex-rs. */
+	/**
+	 * Responses Lite transport override; defaults to the model's
+	 * `useResponsesLite`. Lite moves instructions/tools into input items,
+	 * strips image detail, and disables parallel tool calling (codex-rs
+	 * `use_responses_lite`).
+	 */
 	responsesLite?: boolean;
 }
 
@@ -46,6 +54,8 @@ export interface InputItem {
 	name?: string;
 	output?: unknown;
 	arguments?: unknown;
+	/** `additional_tools` developer item payload (Responses Lite). */
+	tools?: unknown;
 }
 
 export interface RequestBody {
@@ -56,6 +66,8 @@ export interface RequestBody {
 	input?: InputItem[];
 	tools?: unknown;
 	tool_choice?: unknown;
+	/** Concurrent reasoning-summary delivery (codex-rs `StreamOptions`). */
+	stream_options?: { reasoning_summary_delivery: "sequential_cutoff" };
 	// Sampling controls (temperature/top_p/top_k/min_p/presence_penalty/
 	// repetition_penalty/frequency_penalty/stop) are intentionally absent: the
 	// Codex backend rejects every one with a 400 `Unsupported parameter`, so
@@ -74,29 +86,22 @@ export interface RequestBody {
 	[key: string]: unknown;
 }
 
-function containsInputImage(value: unknown): boolean {
-	if (!value || typeof value !== "object") return false;
-	if ((value as { type?: unknown }).type === "input_image") return true;
-	if (Array.isArray(value)) {
-		for (const item of value) {
-			if (containsInputImage(item)) return true;
-		}
-		return false;
-	}
-	for (const item of Object.values(value)) {
-		if (containsInputImage(item)) return true;
-	}
-	return false;
-}
-
-/** Returns whether a Codex request can use the text-only Responses Lite transport. */
-export function shouldUseCodexResponsesLite(body: RequestBody, requested: boolean | undefined): boolean {
-	return requested === true && !containsInputImage(body.input);
+/**
+ * Resolve whether a Codex request uses the Responses Lite transport: an
+ * explicit option wins, otherwise the model's catalog flag (codex-rs
+ * `model_info.use_responses_lite`) decides.
+ */
+export function resolveCodexResponsesLite(
+	model: Model<"openai-codex-responses">,
+	requested: boolean | undefined,
+): boolean {
+	return requested ?? model.useResponsesLite === true;
 }
 
 /**
  * Clamp a user-facing effort to the model's ladder, then remap to the wire
- * tier (e.g. GPT-5.6's shifted five-tier scale sends `max` for user `xhigh`).
+ * tier. User efforts map 1:1 onto wire tiers; the effort map only covers
+ * host quirks where a wire tier genuinely does not exist (e.g. `minimal→none`).
  * A mapped value outside the Codex wire vocabulary is a broken compat/model
  * effort map — fail loudly rather than silently sending a different tier.
  */
@@ -240,24 +245,62 @@ function repairToolCallPairs(input: InputItem[]): InputItem[] {
  * `detail` from every input image (message content and tool outputs) before
  * sending, letting the server choose.
  */
-function stripImageDetails(input: InputItem[]): void {
+function stripImageDetails(input: unknown[]): void {
 	for (const item of input) {
-		for (const collection of [item.content, item.output]) {
+		if (!item || typeof item !== "object") continue;
+		const content = "content" in item ? item.content : undefined;
+		const output = "output" in item ? item.output : undefined;
+		for (const collection of [content, output]) {
 			if (!Array.isArray(collection)) continue;
 			for (const part of collection) {
-				if (
-					part &&
-					typeof part === "object" &&
-					(part as { type?: unknown }).type === "input_image" &&
-					"detail" in part
-				) {
-					part.detail = undefined;
-				}
+				if (!part || typeof part !== "object") continue;
+				if (!("type" in part) || part.type !== "input_image") continue;
+				if ("detail" in part) part.detail = undefined;
 			}
 		}
 	}
 }
 
+/**
+ * Structural view of a Responses-style body mutated by the Lite rewrite.
+ * Loose (`unknown`) property types let the turn transformer (`RequestBody`)
+ * and the agent's remote-compaction payloads reuse one shaper.
+ */
+export interface CodexLiteShapedBody {
+	instructions?: unknown;
+	tools?: unknown;
+	input?: unknown;
+	parallel_tool_calls?: unknown;
+}
+
+/**
+ * Applies the Responses Lite body contract in place (codex-rs
+ * `build_responses_request` with `use_responses_lite`): strips pinned image
+ * detail, forces parallel tool calling off, moves tools into a leading
+ * `additional_tools` developer item and the base instructions into a
+ * developer message, then omits top-level `instructions`/`tools`. Shared by
+ * normal turns and both remote-compaction paths — codex-rs routes
+ * `/responses/compact` through the same builder.
+ */
+export function applyCodexResponsesLiteShape(body: CodexLiteShapedBody): void {
+	const input = Array.isArray(body.input) ? body.input : [];
+	stripImageDetails(input);
+	body.parallel_tool_calls = false;
+	const prefix: InputItem[] = [
+		{ type: "additional_tools", role: "developer", tools: Array.isArray(body.tools) ? body.tools : [] },
+	];
+	if (typeof body.instructions === "string" && body.instructions.length > 0) {
+		prefix.push({
+			type: "message",
+			role: "developer",
+			content: [{ type: "input_text", text: body.instructions }],
+		});
+	}
+	body.input = [...prefix, ...input];
+	delete body.instructions;
+	delete body.tools;
+}
+
 export async function transformRequestBody(
 	body: RequestBody,
 	model: Model<"openai-codex-responses">,
@@ -331,16 +374,9 @@ export async function transformRequestBody(
 		}
 	}
 
-	const responsesLite = shouldUseCodexResponsesLite(body, options.responsesLite);
+	const responsesLite = resolveCodexResponsesLite(model, options.responsesLite);
 	if (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;
-		}
+		applyCodexResponsesLiteShape(body);
 	}
 
 	if (options.reasoningEffort !== undefined) {
@@ -367,6 +403,23 @@ export async function transformRequestBody(
 	} else {
 		delete body.reasoning;
 	}
+	// Catalog pro aliases (`gpt-5.6-*-pro`): applied after the effort branch so
+	// the mode is sent even when no effort is set (the branch above deletes
+	// `body.reasoning` in that case) — mode and effort are independent fields.
+	if (model.reasoningMode) {
+		body.reasoning = { ...body.reasoning, mode: model.reasoningMode };
+	}
+
+	// Concurrent reasoning summaries (codex-rs `concurrent_reasoning_summaries`
+	// feature): `sequential_cutoff` lets the server stream output without
+	// blocking on summary generation. Only meaningful when a summary is
+	// requested; codex-rs additionally gates on its OpenAI provider check,
+	// which is inherent here.
+	if (body.reasoning?.summary !== undefined) {
+		body.stream_options = { reasoning_summary_delivery: "sequential_cutoff" };
+	} else {
+		delete body.stream_options;
+	}
 
 	body.text = {
 		...body.text,