@oh-my-pi/pi-ai 16.3.9 → 16.3.11

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [16.3.11] - 2026-07-06
+
+### Fixed
+
+- Fixed `openai-codex-responses` fresh plan execution requests that contained only system/developer guidance by mirroring the final instruction as user input so Codex accepts the first turn. ([#4714](https://github.com/can1357/oh-my-pi/issues/4714))
+- Fixed Codex WebSocket compact/resume delta diagnostics to record request shape and raw-vs-displayed usage buckets, so persistent server-reported uncached suffixes without `orchestration_*` fields are visible in debug stats. ([#4707](https://github.com/can1357/oh-my-pi/issues/4707))
+
+## [16.3.10] - 2026-07-06
+
+### Fixed
+
+- Fixed Ollama/Ollama Cloud EOS-only completions to retry empty stops with a single output token before the agent loop can halt silently. ([#4659](https://github.com/can1357/oh-my-pi/issues/4659))
+- Fixed Claude Sonnet 5 failing every request on feature-gated gateways (Azure Foundry, OpenAI-compatible relays) that reject strict tools with "structured_outputs not supported" — the rejection is now classified as a strict-tool rejection, so the request retries without strict tools and the session remembers the downgrade.
+
 ## [16.3.7] - 2026-07-05
 
 ### Fixed

package/dist/types/error/flags.d.ts

@@ -13,7 +13,7 @@ export declare const Flag: {
     readonly SilentAbort: 33554432;
     readonly UserInterrupt: 67108864;
     readonly Abort: 134217728;
-    /** Anthropic strict-tool grammar too large / schema too complex to compile (400). */
+    /** Strict-tool rejection (400): grammar too large, schema too complex, or structured outputs unsupported by the model/endpoint. */
     readonly Grammar: 268435456;
     /** Anthropic model/account does not support fast mode / the `speed` parameter. */
     readonly FastModeUnsupported: 536870912;
@@ -48,7 +48,8 @@ export declare function classify(error: unknown, api?: Api): number;
  */
 export declare function isUsageLimit(error: unknown, api?: Api): boolean;
 /**
- * Anthropic strict-tool grammar too large / schema too complex to compile.
+ * Strict-tool rejection: grammar too large, schema too complex, or structured
+ * outputs unsupported by the model/endpoint.
  * Accessor for {@link Flag.Grammar}.
  */
 export declare function isGrammarError(error: unknown): boolean;

package/dist/types/providers/ollama.d.ts

@@ -4,4 +4,5 @@ export interface OllamaChatOptions extends StreamOptions {
     disableReasoning?: boolean;
     toolChoice?: ToolChoice;
 }
+/** Retry EOS-only Ollama completions before the agent loop sees an empty stop. */
 export declare const streamOllama: StreamFunction<"ollama-chat">;

package/dist/types/providers/openai-codex-responses.d.ts

@@ -35,10 +35,46 @@ export interface OpenAICodexResponsesOptions extends StreamOptions {
     onModerationMetadata?: (metadata: unknown) => void;
 }
 type CodexTransport = "sse" | "websocket";
+/** Shape of the Codex request sent on the latest provider turn. */
+export interface OpenAICodexTurnRequestDiagnostics {
+    transport: "sse" | "websocket";
+    previousResponseIdPresent: boolean;
+    inputItemCount: number;
+    inputItemTypes: string[];
+    firstInputItemType?: string;
+    inputJsonBytes: number;
+    promptCacheKey?: string;
+    toolsHash?: string;
+    optionsHash: string;
+    canAppendBeforeRequest: boolean;
+}
+/** Raw provider usage plus the normalized buckets OMP displays for the latest Codex turn. */
+export interface OpenAICodexTurnUsageDiagnostics {
+    rawInputTokens: number;
+    rawCachedTokens: number;
+    rawUncachedTokens: number;
+    rawOutputTokens: number;
+    rawTotalTokens?: number;
+    rawOrchestrationInputTokens?: number;
+    rawOrchestrationCachedTokens?: number;
+    rawOrchestrationOutputTokens?: number;
+    displayedInputTokens: number;
+    displayedOutputTokens: number;
+    displayedCacheReadTokens: number;
+    displayedCacheWriteTokens: number;
+    displayedTotalTokens: number;
+    displayedOrchestrationInputTokens: number;
+    displayedOrchestrationCacheReadTokens: number;
+    displayedOrchestrationOutputTokens: number;
+}
+/** Latest Codex turn request/usage diagnostics exposed to debug UIs and tests. */
+export interface OpenAICodexTurnDiagnostics {
+    request: OpenAICodexTurnRequestDiagnostics;
+    usage?: OpenAICodexTurnUsageDiagnostics;
+}
 /**
- * Per-session request-shape counters. Despite the name, these cover both
- * transports: once stateful SSE chaining is enabled, SSE requests are counted
- * too (the shared chained-request builder records every request it shapes).
+ * Per-session request-shape counters and latest turn diagnostics. Despite the
+ * name, these cover both transports.
  */
 export interface OpenAICodexWebSocketDebugStats {
     fullContextRequests: number;
@@ -46,6 +82,7 @@ export interface OpenAICodexWebSocketDebugStats {
     lastInputItems: number;
     lastDeltaInputItems?: number;
     lastPreviousResponseId?: string;
+    lastTurn?: OpenAICodexTurnDiagnostics;
 }
 /** @internal Exported for tests. */
 export declare function normalizeCodexToolChoice(choice: ToolChoice | undefined, tools?: Tool[], model?: Model<"openai-codex-responses">): string | Record<string, unknown> | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.3.9",
+	"version": "16.3.11",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.3.9",
-		"@oh-my-pi/pi-utils": "16.3.9",
-		"@oh-my-pi/pi-wire": "16.3.9",
+		"@oh-my-pi/pi-catalog": "16.3.11",
+		"@oh-my-pi/pi-utils": "16.3.11",
+		"@oh-my-pi/pi-wire": "16.3.11",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/error/flags.ts

@@ -22,7 +22,7 @@ export const Flag = {
 	SilentAbort: 0x0200_0000,
 	UserInterrupt: 0x0400_0000,
 	Abort: 0x0800_0000,
-	/** Anthropic strict-tool grammar too large / schema too complex to compile (400). */
+	/** Strict-tool rejection (400): grammar too large, schema too complex, or structured outputs unsupported by the model/endpoint. */
 	Grammar: 0x1000_0000,
 	/** Anthropic model/account does not support fast mode / the `speed` parameter. */
 	FastModeUnsupported: 0x2000_0000,
@@ -108,12 +108,17 @@ export const LLAMA_CPP_TOOL_CALL_PARSE_PATTERN =
 // on a backend that has the model.
 const COPILOT_MODEL_NOT_SUPPORTED_PATTERN = /model_not_supported/i;
 // Anthropic strict-tool grammar too large / schema too complex (400 invalid_request_error).
+// Feature-gated deployments (Azure Foundry, Baseten, …) reject `strict: true`
+// tools outright when the hosted model lacks structured outputs, e.g.
+// "structured_outputs not supported" — without an invalid_request_error wrapper.
 const GRAMMAR_TOO_LARGE_PATTERN = /compiled grammar/i;
 const GRAMMAR_TOO_LARGE_DETAIL_PATTERN = /too large/i;
 const SCHEMA_TOO_COMPLEX_PATTERN = /schema/i;
 const SCHEMA_TOO_COMPLEX_DETAIL_PATTERN = /too complex/i;
 const SCHEMA_COMPILE_PATTERN = /compil/i;
 const INVALID_REQUEST_PATTERN = /invalid_request_error/i;
+const STRUCTURED_OUTPUTS_PATTERN = /structured[_ -]?outputs?/i;
+const FEATURE_NOT_SUPPORTED_PATTERN = /not (?:supported|available|enabled)|unsupported|does(?: not|n'?t) support/i;
 // Anthropic fast-mode unsupported: 400 rejecting `speed`, or 429 rate_limit_error
 // because the account lacks the extra-usage entitlement fast mode requires.
 const FAST_MODE_SPEED_PARAM_PATTERN = /\bspeed\b/i;
@@ -127,8 +132,9 @@ const OAUTH_TRANSIENT_FAILURE_PATTERN =
 	/timeout|network|fetch failed|ECONN(?:REFUSED|RESET)|ETIMEDOUT|EAI_AGAIN|socket hang up|\b(?:408|425|429|5\d{2})\b|rate.?limit|too many requests|temporar|unavailable|forbidden|permission_denied|cloudflare|captcha/i;
 const OAUTH_HTTP_AUTH_PATTERN = /\b401\b/;
 
-function matchesGrammarTooLarge(message: string, errorStatus: number | undefined): boolean {
+function matchesStrictToolsRejection(message: string, errorStatus: number | undefined): boolean {
 	if (errorStatus !== 400) return false;
+	if (STRUCTURED_OUTPUTS_PATTERN.test(message) && FEATURE_NOT_SUPPORTED_PATTERN.test(message)) return true;
 	if (!INVALID_REQUEST_PATTERN.test(message)) return false;
 	const grammarTooLarge = GRAMMAR_TOO_LARGE_PATTERN.test(message) && GRAMMAR_TOO_LARGE_DETAIL_PATTERN.test(message);
 	const schemaTooComplex =
@@ -317,7 +323,7 @@ function classifyText(errorMessage: string | undefined, errorStatus: number | un
 
 		// Copilot per-client routing flap is transient.
 		if (statusClean === 400 && COPILOT_MODEL_NOT_SUPPORTED_PATTERN.test(cleanMessage)) kinds |= Flag.Transient;
-		if (matchesGrammarTooLarge(cleanMessage, statusClean)) kinds |= Flag.Grammar;
+		if (matchesStrictToolsRejection(cleanMessage, statusClean)) kinds |= Flag.Grammar;
 		if (matchesFastModeUnsupported(cleanMessage, statusClean)) kinds |= Flag.FastModeUnsupported;
 	}
 	if (kinds !== 0) return create(kinds);
@@ -411,7 +417,8 @@ export function isUsageLimit(error: unknown, api?: Api): boolean {
 }
 
 /**
- * Anthropic strict-tool grammar too large / schema too complex to compile.
+ * Strict-tool rejection: grammar too large, schema too complex, or structured
+ * outputs unsupported by the model/endpoint.
  * Accessor for {@link Flag.Grammar}.
  */
 export function isGrammarError(error: unknown): boolean {

package/src/providers/anthropic.ts

@@ -2396,7 +2396,7 @@ const streamAnthropicOnce = (
 					) {
 						// Log-only: the retried turn must not carry an errorMessage on
 						// success (consumers treat its presence as failure).
-						logger.warn("anthropic: strict tool grammar rejected, retrying without strict tools", {
+						logger.warn("anthropic: strict tools rejected, retrying without strict tools", {
 							model: model.id,
 							error: await finalizeErrorMessage(streamFailure, rawRequestDump),
 						});

package/src/providers/ollama.ts

@@ -16,6 +16,7 @@ import type {
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { clearStreamingPartialJson, kStreamingPartialJson } from "../utils/block-symbols";
+import { withEmptyCompletionRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import type { CapturedHttpErrorResponse, RawHttpRequestDump } from "../utils/http-inspector";
 import {
@@ -449,10 +450,10 @@ function hasVisibleAssistantContent(output: AssistantMessage): boolean {
 
 const OLLAMA_RETRY_DELAYS_MS = [2_000, 5_000, 10_000];
 
-export const streamOllama: StreamFunction<"ollama-chat"> = (
+const streamOllamaOnce = (
 	model: Model<"ollama-chat">,
 	context: Context,
-	options: OllamaChatOptions,
+	options: OllamaChatOptions = {},
 ): AssistantMessageEventStream => {
 	const stream = new AssistantMessageEventStream();
 	void (async () => {
@@ -771,3 +772,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 	})();
 	return stream;
 };
+
+/** Retry EOS-only Ollama completions before the agent loop sees an empty stop. */
+export const streamOllama: StreamFunction<"ollama-chat"> = (model, context, options) =>
+	withEmptyCompletionRetry(model, context, options, streamOllamaOnce);

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

@@ -230,16 +230,61 @@ export async function transformRequestBody(
 		}
 	}
 
-	if (prompt?.developerMessages && prompt.developerMessages.length > 0 && Array.isArray(body.input)) {
-		const developerMessages = prompt.developerMessages.map(
-			text =>
-				({
+	if (prompt?.developerMessages && prompt.developerMessages.length > 0) {
+		const developerMessages: InputItem[] = prompt.developerMessages.map(text => ({
+			type: "message",
+			role: "developer",
+			content: [{ type: "input_text", text }],
+		}));
+		const input = Array.isArray(body.input) ? body.input : [];
+		body.input = [...developerMessages, ...input];
+	}
+
+	let finalInstruction = prompt?.developerMessages.findLast(text => text.trim().length > 0);
+	if (finalInstruction === undefined && Array.isArray(body.input)) {
+		for (let itemIndex = body.input.length - 1; itemIndex >= 0; itemIndex -= 1) {
+			const item = body.input[itemIndex];
+			if (item.role !== "developer" || !Array.isArray(item.content)) continue;
+			for (let partIndex = item.content.length - 1; partIndex >= 0; partIndex -= 1) {
+				const part = item.content[partIndex];
+				if (
+					part &&
+					typeof part === "object" &&
+					"type" in part &&
+					part.type === "input_text" &&
+					"text" in part &&
+					typeof part.text === "string" &&
+					part.text.trim().length > 0
+				) {
+					finalInstruction = part.text;
+					break;
+				}
+			}
+			if (finalInstruction !== undefined) break;
+		}
+	}
+	if (finalInstruction === undefined && typeof body.instructions === "string" && body.instructions.trim().length > 0) {
+		finalInstruction = body.instructions;
+	}
+	if (finalInstruction !== undefined) {
+		const input = Array.isArray(body.input) ? body.input : [];
+		let hasVisibleInput = false;
+		for (const item of input) {
+			if (item.role !== "developer") {
+				hasVisibleInput = true;
+				break;
+			}
+		}
+		if (!hasVisibleInput) {
+			body.input = [
+				...input,
+				{
 					type: "message",
-					role: "developer",
-					content: [{ type: "input_text", text }],
-				}) as InputItem,
-		);
-		body.input = [...developerMessages, ...body.input];
+					role: "user",
+					content: [{ type: "input_text", text: finalInstruction }],
+				},
+			];
+		}
 	}
 
 	const responsesLite = shouldUseCodexResponsesLite(body, options.responsesLite);

package/src/providers/openai-codex-responses.ts

@@ -37,6 +37,7 @@ import type {
 	Tool,
 	ToolCall,
 	ToolChoice,
+	Usage,
 } from "../types";
 import {
 	createOpenAIResponsesHistoryPayload,
@@ -246,10 +247,66 @@ type CodexOutputBlock =
 	| TextContent
 	| (ToolCall & { [kStreamingPartialJson]: string; [kStreamingLastParseLen]?: number });
 
+interface CodexResponseUsage {
+	input_tokens?: number;
+	output_tokens?: number;
+	total_tokens?: number;
+	prompt_cache_hit_tokens?: number;
+	input_tokens_details?: {
+		cached_tokens?: number;
+		cache_write_tokens?: number;
+		orchestration_input_tokens?: number;
+		orchestration_input_cached_tokens?: number;
+	};
+	output_tokens_details?: {
+		reasoning_tokens?: number;
+		orchestration_output_tokens?: number;
+	};
+}
+
+/** Shape of the Codex request sent on the latest provider turn. */
+export interface OpenAICodexTurnRequestDiagnostics {
+	transport: "sse" | "websocket";
+	previousResponseIdPresent: boolean;
+	inputItemCount: number;
+	inputItemTypes: string[];
+	firstInputItemType?: string;
+	inputJsonBytes: number;
+	promptCacheKey?: string;
+	toolsHash?: string;
+	optionsHash: string;
+	canAppendBeforeRequest: boolean;
+}
+
+/** Raw provider usage plus the normalized buckets OMP displays for the latest Codex turn. */
+export interface OpenAICodexTurnUsageDiagnostics {
+	rawInputTokens: number;
+	rawCachedTokens: number;
+	rawUncachedTokens: number;
+	rawOutputTokens: number;
+	rawTotalTokens?: number;
+	rawOrchestrationInputTokens?: number;
+	rawOrchestrationCachedTokens?: number;
+	rawOrchestrationOutputTokens?: number;
+	displayedInputTokens: number;
+	displayedOutputTokens: number;
+	displayedCacheReadTokens: number;
+	displayedCacheWriteTokens: number;
+	displayedTotalTokens: number;
+	displayedOrchestrationInputTokens: number;
+	displayedOrchestrationCacheReadTokens: number;
+	displayedOrchestrationOutputTokens: number;
+}
+
+/** Latest Codex turn request/usage diagnostics exposed to debug UIs and tests. */
+export interface OpenAICodexTurnDiagnostics {
+	request: OpenAICodexTurnRequestDiagnostics;
+	usage?: OpenAICodexTurnUsageDiagnostics;
+}
+
 /**
- * Per-session request-shape counters. Despite the name, these cover both
- * transports: once stateful SSE chaining is enabled, SSE requests are counted
- * too (the shared chained-request builder records every request it shapes).
+ * Per-session request-shape counters and latest turn diagnostics. Despite the
+ * name, these cover both transports.
  */
 export interface OpenAICodexWebSocketDebugStats {
 	fullContextRequests: number;
@@ -257,6 +314,7 @@ export interface OpenAICodexWebSocketDebugStats {
 	lastInputItems: number;
 	lastDeltaInputItems?: number;
 	lastPreviousResponseId?: string;
+	lastTurn?: OpenAICodexTurnDiagnostics;
 }
 
 /**
@@ -1002,6 +1060,7 @@ async function openCodexWebSocketTransport(
 	requestBodyForState: RequestBody;
 	transport: CodexTransport;
 }> {
+	const canAppendBeforeRequest = websocketState.canAppend === true;
 	const chainedBody = buildCodexChainedRequestBody(requestContext.transformedBody, websocketState);
 	// WebSocket frames cannot carry per-request HTTP headers, so the Responses
 	// Lite marker rides in `client_metadata` on every `response.create`.
@@ -1021,6 +1080,7 @@ async function openCodexWebSocketTransport(
 	if (replacementWebsocketRequest !== undefined) {
 		websocketRequest = replacementWebsocketRequest as typeof websocketRequest;
 	}
+	recordCodexTurnRequestDiagnostics(websocketState, websocketRequest, "websocket", canAppendBeforeRequest);
 	const websocketHeaders = createCodexHeaders(
 		requestContext.requestHeaders,
 		requestContext.accountId,
@@ -1113,12 +1173,13 @@ async function openCodexSseTransport(
 			),
 		);
 	};
+	const canAppendBeforeRequest = state?.canAppend === true;
 	let wireBody = body;
 	const replacementWireBody = await options?.onPayload?.(wireBody, model);
 	if (replacementWireBody !== undefined) {
 		wireBody = replacementWireBody as RequestBody;
 	}
-	recordCodexWebSocketRequestStats(state, wireBody);
+	recordCodexTurnRequestDiagnostics(state, wireBody, "sse", canAppendBeforeRequest);
 	return { eventStream: await open(wireBody), requestBodyForState: structuredCloneJSON(wireBody), transport: "sse" };
 }
 
@@ -1525,34 +1586,19 @@ class CodexStreamProcessor {
 	#handleResponseCompleted(rawEvent: Record<string, unknown>): void {
 		const { runtime, model, output } = this;
 		runtime.sawTerminalEvent = true;
-		const response = (
-			rawEvent as {
-				response?: {
-					id?: string;
-					usage?: {
-						input_tokens?: number;
-						output_tokens?: number;
-						total_tokens?: number;
-						input_tokens_details?: {
-							cached_tokens?: number;
-							orchestration_input_tokens?: number;
-							orchestration_input_cached_tokens?: number;
-						};
-						output_tokens_details?: {
-							reasoning_tokens?: number;
-							orchestration_output_tokens?: number;
-						};
-					};
-					status?: string;
-					service_tier?: ServiceTier | "default";
-					end_turn?: boolean;
-				};
-			}
-		).response;
+		const rawResponse = rawEvent.response;
+		const response = rawResponse && typeof rawResponse === "object" ? rawResponse : undefined;
+		const responseId = response && "id" in response && typeof response.id === "string" ? response.id : undefined;
+		const usage = response && "usage" in response ? parseCodexResponseUsage(response.usage) : undefined;
+		const serviceTier =
+			response && "service_tier" in response ? parseCodexServiceTier(response.service_tier) : undefined;
+		const status = response && "status" in response ? parseCodexResponseStatus(response.status) : undefined;
+		const endTurn = response && "end_turn" in response ? response.end_turn : undefined;
 
-		populateResponsesUsageFromResponse(output, response?.usage);
-		if (typeof response?.id === "string" && response.id.length > 0) {
-			output.responseId = response.id;
+		populateResponsesUsageFromResponse(output, usage);
+		recordCodexTurnUsageDiagnostics(runtime.websocketState, usage, output.usage);
+		if (responseId) {
+			output.responseId = responseId;
 		}
 
 		const state = runtime.websocketState;
@@ -1564,8 +1610,8 @@ class CodexStreamProcessor {
 				resetCodexWebSocketAppendState(state);
 			} else {
 				state.lastRequest = structuredCloneJSON(runtime.requestBodyForState);
-				if (typeof response?.id === "string" && response.id.length > 0) {
-					state.lastResponseId = response.id;
+				if (responseId) {
+					state.lastResponseId = responseId;
 					state.lastResponseItems = stripInputItemIds(structuredCloneJSON(runtime.nativeOutputItems));
 					state.canAppend = rawEvent.type === "response.done" || rawEvent.type === "response.completed";
 				} else {
@@ -1578,14 +1624,9 @@ class CodexStreamProcessor {
 		finalizePendingResponsesToolCalls(output);
 
 		calculateCost(model, output.usage);
-		applyCodexServiceTierPricing(
-			model,
-			output.usage,
-			response?.service_tier,
-			runtime.requestBodyForState.service_tier,
-		);
-		output.stopReason = mapOpenAIResponsesStopReason(response?.status as ResponseStatus | undefined);
-		promoteResponsesToolUseStopReason(output, response?.end_turn);
+		applyCodexServiceTierPricing(model, output.usage, serviceTier, runtime.requestBodyForState.service_tier);
+		output.stopReason = mapOpenAIResponsesStopReason(status);
+		promoteResponsesToolUseStopReason(output, endTurn === true ? true : endTurn === false ? false : undefined);
 	}
 
 	async #recoverStreamError(error: unknown): Promise<boolean> {
@@ -2270,22 +2311,230 @@ function stripInputItemIds(items: Array<Record<string, unknown>>): InputItem[] {
 	});
 }
 
-function recordCodexWebSocketRequestStats(
+const codexDiagnosticsTextEncoder = new TextEncoder();
+
+function jsonByteLength(value: unknown): number {
+	const json = JSON.stringify(value);
+	return codexDiagnosticsTextEncoder.encode(json === undefined ? "undefined" : json).byteLength;
+}
+
+function hashJson(value: unknown): string {
+	const json = JSON.stringify(value);
+	return String(Bun.hash(json === undefined ? "undefined" : json));
+}
+
+function parseCodexServiceTier(value: unknown): ServiceTier | undefined {
+	switch (value) {
+		case "auto":
+		case "default":
+		case "flex":
+		case "scale":
+		case "priority":
+			return value;
+		default:
+			return undefined;
+	}
+}
+
+function parseCodexResponseStatus(value: unknown): ResponseStatus | undefined {
+	switch (value) {
+		case "completed":
+		case "failed":
+		case "in_progress":
+		case "cancelled":
+		case "queued":
+		case "incomplete":
+			return value;
+		default:
+			return undefined;
+	}
+}
+
+function parseCodexResponseUsage(value: unknown): CodexResponseUsage | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const usage: CodexResponseUsage = {};
+	let hasUsage = false;
+	if ("input_tokens" in value && typeof value.input_tokens === "number") {
+		usage.input_tokens = value.input_tokens;
+		hasUsage = true;
+	}
+	if ("output_tokens" in value && typeof value.output_tokens === "number") {
+		usage.output_tokens = value.output_tokens;
+		hasUsage = true;
+	}
+	if ("total_tokens" in value && typeof value.total_tokens === "number") {
+		usage.total_tokens = value.total_tokens;
+		hasUsage = true;
+	}
+	if ("prompt_cache_hit_tokens" in value && typeof value.prompt_cache_hit_tokens === "number") {
+		usage.prompt_cache_hit_tokens = value.prompt_cache_hit_tokens;
+		hasUsage = true;
+	}
+	if (
+		"input_tokens_details" in value &&
+		value.input_tokens_details &&
+		typeof value.input_tokens_details === "object"
+	) {
+		const details = value.input_tokens_details;
+		const parsedDetails: NonNullable<CodexResponseUsage["input_tokens_details"]> = {};
+		let hasDetails = false;
+		if ("cached_tokens" in details && typeof details.cached_tokens === "number") {
+			parsedDetails.cached_tokens = details.cached_tokens;
+			hasDetails = true;
+		}
+		if ("cache_write_tokens" in details && typeof details.cache_write_tokens === "number") {
+			parsedDetails.cache_write_tokens = details.cache_write_tokens;
+			hasDetails = true;
+		}
+		if ("orchestration_input_tokens" in details && typeof details.orchestration_input_tokens === "number") {
+			parsedDetails.orchestration_input_tokens = details.orchestration_input_tokens;
+			hasDetails = true;
+		}
+		if (
+			"orchestration_input_cached_tokens" in details &&
+			typeof details.orchestration_input_cached_tokens === "number"
+		) {
+			parsedDetails.orchestration_input_cached_tokens = details.orchestration_input_cached_tokens;
+			hasDetails = true;
+		}
+		if (hasDetails) {
+			usage.input_tokens_details = parsedDetails;
+			hasUsage = true;
+		}
+	}
+	if (
+		"output_tokens_details" in value &&
+		value.output_tokens_details &&
+		typeof value.output_tokens_details === "object"
+	) {
+		const details = value.output_tokens_details;
+		const parsedDetails: NonNullable<CodexResponseUsage["output_tokens_details"]> = {};
+		let hasDetails = false;
+		if ("reasoning_tokens" in details && typeof details.reasoning_tokens === "number") {
+			parsedDetails.reasoning_tokens = details.reasoning_tokens;
+			hasDetails = true;
+		}
+		if ("orchestration_output_tokens" in details && typeof details.orchestration_output_tokens === "number") {
+			parsedDetails.orchestration_output_tokens = details.orchestration_output_tokens;
+			hasDetails = true;
+		}
+		if (hasDetails) {
+			usage.output_tokens_details = parsedDetails;
+			hasUsage = true;
+		}
+	}
+	return hasUsage ? usage : undefined;
+}
+
+function describeCodexInputItemType(item: unknown): string {
+	if (item && typeof item === "object") {
+		if ("type" in item && typeof item.type === "string") return item.type;
+		if ("role" in item && typeof item.role === "string") return item.role;
+	}
+	return typeof item;
+}
+
+function createCodexOptionsHash(request: Record<string, unknown>): string {
+	const options: Record<string, unknown> = {};
+	for (const key in request) {
+		if (key === "input" || key === "previous_response_id" || key === "type" || key === "client_metadata") {
+			continue;
+		}
+		options[key] = request[key];
+	}
+	return hashJson(options);
+}
+
+function buildCodexTurnRequestDiagnostics(
+	request: Record<string, unknown>,
+	transport: CodexTransport,
+	canAppendBeforeRequest: boolean,
+): OpenAICodexTurnRequestDiagnostics {
+	const input = request.input;
+	const inputItems = Array.isArray(input) ? input : [];
+	const inputItemTypes = inputItems.map(describeCodexInputItemType);
+	const promptCacheKey = typeof request.prompt_cache_key === "string" ? request.prompt_cache_key : undefined;
+	const toolsHash = request.tools === undefined ? undefined : hashJson(request.tools);
+	return {
+		transport,
+		previousResponseIdPresent:
+			typeof request.previous_response_id === "string" && request.previous_response_id.length > 0,
+		inputItemCount: inputItems.length,
+		inputItemTypes,
+		...(inputItemTypes[0] ? { firstInputItemType: inputItemTypes[0] } : {}),
+		inputJsonBytes: jsonByteLength(inputItems),
+		...(promptCacheKey !== undefined ? { promptCacheKey } : {}),
+		...(toolsHash !== undefined ? { toolsHash } : {}),
+		optionsHash: createCodexOptionsHash(request),
+		canAppendBeforeRequest,
+	};
+}
+
+function recordCodexTurnRequestDiagnostics(
 	state: CodexWebSocketSessionState | undefined,
 	request: Record<string, unknown>,
+	transport: CodexTransport,
+	canAppendBeforeRequest: boolean,
 ): void {
 	if (!state) return;
 	const input = request.input;
 	state.stats.lastInputItems = Array.isArray(input) ? input.length : 0;
-	if (typeof request.previous_response_id === "string" && request.previous_response_id.length > 0) {
+	const previousResponseId =
+		typeof request.previous_response_id === "string" ? request.previous_response_id : undefined;
+	if (previousResponseId && previousResponseId.length > 0) {
 		state.stats.deltaRequests += 1;
 		state.stats.lastDeltaInputItems = state.stats.lastInputItems;
-		state.stats.lastPreviousResponseId = request.previous_response_id;
-		return;
+		state.stats.lastPreviousResponseId = previousResponseId;
+	} else {
+		state.stats.fullContextRequests += 1;
+		state.stats.lastDeltaInputItems = undefined;
+		state.stats.lastPreviousResponseId = undefined;
 	}
-	state.stats.fullContextRequests += 1;
-	state.stats.lastDeltaInputItems = undefined;
-	state.stats.lastPreviousResponseId = undefined;
+	state.stats.lastTurn = {
+		request: buildCodexTurnRequestDiagnostics(request, transport, canAppendBeforeRequest),
+	};
+	CODEX_DEBUG && logger.debug("[codex] codex turn request diagnostics", { diagnostics: state.stats.lastTurn.request });
+}
+
+function recordCodexTurnUsageDiagnostics(
+	state: CodexWebSocketSessionState | undefined,
+	rawUsage: CodexResponseUsage | undefined,
+	displayedUsage: Usage,
+): void {
+	if (!state?.stats.lastTurn || !rawUsage) return;
+	const details = rawUsage.input_tokens_details;
+	const outputDetails = rawUsage.output_tokens_details;
+	const rawInputTokens = rawUsage.input_tokens ?? 0;
+	const rawCachedTokens = details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+	const usageDiagnostics: OpenAICodexTurnUsageDiagnostics = {
+		rawInputTokens,
+		rawCachedTokens,
+		rawUncachedTokens: Math.max(0, rawInputTokens - rawCachedTokens),
+		rawOutputTokens: rawUsage.output_tokens ?? 0,
+		...(typeof rawUsage.total_tokens === "number" ? { rawTotalTokens: rawUsage.total_tokens } : {}),
+		...(typeof details?.orchestration_input_tokens === "number"
+			? { rawOrchestrationInputTokens: details.orchestration_input_tokens }
+			: {}),
+		...(typeof details?.orchestration_input_cached_tokens === "number"
+			? { rawOrchestrationCachedTokens: details.orchestration_input_cached_tokens }
+			: {}),
+		...(typeof outputDetails?.orchestration_output_tokens === "number"
+			? { rawOrchestrationOutputTokens: outputDetails.orchestration_output_tokens }
+			: {}),
+		displayedInputTokens: displayedUsage.input,
+		displayedOutputTokens: displayedUsage.output,
+		displayedCacheReadTokens: displayedUsage.cacheRead,
+		displayedCacheWriteTokens: displayedUsage.cacheWrite,
+		displayedTotalTokens: displayedUsage.totalTokens,
+		displayedOrchestrationInputTokens: displayedUsage.orchestration?.input ?? 0,
+		displayedOrchestrationCacheReadTokens: displayedUsage.orchestration?.cacheRead ?? 0,
+		displayedOrchestrationOutputTokens: displayedUsage.orchestration?.output ?? 0,
+	};
+	state.stats.lastTurn = {
+		...state.stats.lastTurn,
+		usage: usageDiagnostics,
+	};
+	CODEX_DEBUG && logger.debug("[codex] codex turn diagnostics", { diagnostics: state.stats.lastTurn });
 }
 
 /**
@@ -2306,9 +2555,7 @@ function buildCodexChainedRequestBody(
 		? buildResponsesDeltaInput(state.lastRequest, state.lastResponseItems, requestBody)
 		: null;
 	if (appendInput && appendInput.length > 0 && state?.lastResponseId) {
-		const body: RequestBody = { ...requestBody, previous_response_id: state.lastResponseId, input: appendInput };
-		recordCodexWebSocketRequestStats(state, body);
-		return body;
+		return { ...requestBody, previous_response_id: state.lastResponseId, input: appendInput };
 	}
 	if (chainable && state) {
 		// Chaining was eligible but the prefix/options check failed: history
@@ -2322,7 +2569,6 @@ function buildCodexChainedRequestBody(
 		state.turnState = undefined;
 		state.modelsEtag = undefined;
 	}
-	recordCodexWebSocketRequestStats(state, requestBody);
 	return requestBody;
 }
 

package/src/providers/openai-shared.ts

@@ -1041,7 +1041,7 @@ export function shouldRetryWithoutStrictTools(
 	const messageParts = [error instanceof Error ? error.message : undefined, capturedErrorResponse?.bodyText]
 		.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
 		.join("\n");
-	return /wrong_api_format|mixed values for 'strict'|tool[s]?\b.*strict|\bstrict\b.*tool|tool parameters? schema|invalid schema for function/i.test(
+	return /wrong_api_format|mixed values for 'strict'|tool[s]?\b.*strict|\bstrict\b.*tool|tool parameters? schema|invalid schema for function|structured[_ -]?outputs?\b[^\n]*(?:not (?:supported|available|enabled)|unsupported)|(?:not support|unsupported)[^\n]*structured[_ -]?outputs?\b/i.test(
 		messageParts,
 	);
 }

package/src/utils/empty-completion-retry.ts

@@ -109,17 +109,16 @@ export function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOption
 			}
 
 			// Retry only a genuinely degenerate completion: a normal stop that
-			// produced no visible content AND billed no output tokens (the flaky
-			// gateway signature — charged nothing, returned nothing). A stop that
-			// reports output tokens spent its budget somewhere (e.g. thinking) and
-			// is left alone.
+			// produced no visible content and reported no generated content tokens.
+			// Some providers count the terminal EOS as one output token, so a
+			// one-token invisible stop is still the same empty-completion failure.
 			const message = terminal?.type === "done" ? terminal.message : undefined;
 			const isRetryableEmpty =
 				!committed &&
 				message !== undefined &&
 				message.stopReason === "stop" &&
 				!message.errorMessage &&
-				(message.usage?.output ?? 0) <= 0 &&
+				(message.usage?.output ?? 0) <= 1 &&
 				!hasVisibleAssistantContent(message);
 
 			if (isRetryableEmpty && emptyAttempt < MAX_EMPTY_COMPLETION_RETRIES && !signal?.aborted) {