@oh-my-pi/pi-ai 18.0.4 → 18.0.5

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [18.0.5] - 2026-08-25
+
+### Breaking Changes
+
+- Renamed the exported stream-retry helper from `withEmptyCompletionRetry` to `withReplaySafeStreamRetry` and added retry policy options for empty completions and provider errors. Consumers using the old helper must migrate.
+
+### Added
+
+- Added browser-based Sign in with OpenRouter using OAuth PKCE, while retaining support for pasted OpenRouter API keys and redirect URLs for remote sessions.
+- Added `/login` API-key authentication for DeepInfra and Yolo-Auto, including validation against each provider before the credentials are accepted.
+
+### Fixed
+
+- Fixed DeepSeek vision models from losing image input while keeping image parts stripped for text-only DeepSeek endpoints.
+- Fixed OpenAI-compatible gateways that report uppercase completion reasons such as `STOP` or `MAX_TOKENS`; these are now classified correctly, including mapping `MAX_TOKENS` to a length limit.
+- Fixed provider message-count limit errors being treated as unrecoverable payload errors instead of recoverable context overflows.
+- Improved Codex WebSocket continuations so rate limits, throttling, and compatible mode changes preserve valid response continuations instead of unnecessarily replaying the full context.
+- Fixed Codex WebSocket cleanup failures caused by already-closed sockets.
+- Added safe retries for transient mid-stream socket closures across OpenAI Responses, Chat Completions, Azure OpenAI Responses, and Codex SSE when no replay-unsafe output has been emitted.
+- Fixed usage and cost reporting for OpenAI-compatible gateways backed by Vertex AI or Gemini by recognizing cached prompt tokens reported through `cachedContentTokenCount`.
+
 ## [18.0.4] - 2026-08-24
 
 ### Fixed

package/README.md

@@ -60,6 +60,7 @@ Unified LLM API with automatic model discovery, provider configuration, token an
 - **NVIDIA** (requires `NVIDIA_API_KEY`)
 - **NanoGPT** (requires `NANO_GPT_API_KEY`)
 - **Novita** (requires `NOVITA_API_KEY`)
+- **DeepInfra** (requires `DEEPINFRA_API_KEY`)
 - **Hugging Face Inference**
 - **xAI**
 - **Venice** (requires `VENICE_API_KEY`)
@@ -943,6 +944,7 @@ In Node.js environments, you can set environment variables to avoid passing API
 | NVIDIA         | `NVIDIA_API_KEY`                                                             |
 | NanoGPT        | `NANO_GPT_API_KEY`                                                          |
 | Novita         | `NOVITA_API_KEY`                                                           |
+| DeepInfra      | `DEEPINFRA_API_KEY`                                                          |
 | Venice         | `VENICE_API_KEY`                                                             |
 | Moonshot       | `MOONSHOT_API_KEY`                                                           |
 | xAI            | `XAI_API_KEY`                                                                |
@@ -983,6 +985,7 @@ Provider endpoint defaults for the current OpenAI-compatible integrations:
 - NVIDIA: `https://integrate.api.nvidia.com/v1`
 - NanoGPT: `https://nano-gpt.com/api/v1`
 - Novita: `https://api.novita.ai/openai/v1`
+- DeepInfra: `https://api.deepinfra.com/v1/openai`
 - Hugging Face Inference: `https://router.huggingface.co/v1`
 - Venice: `https://api.venice.ai/api/v1`
 - Xiaomi MiMo: `https://api.xiaomimimo.com/anthropic`
@@ -1084,7 +1087,7 @@ Credentials are saved to `agent.db` in the agent directory. `/login qianfan` ope
 
 `login` supports OAuth providers (Anthropic, OpenAI Codex, GitHub Copilot, Gemini CLI, Antigravity) and API-key onboarding flows.
 
-For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
+For the current API-key onboarding flows, the library covers Together, Moonshot, Qianfan, NVIDIA, NanoGPT, Novita, DeepInfra, Hugging Face, Venice, Xiaomi, vLLM, LiteLLM, Cloudflare AI Gateway, Qwen Portal, and Ollama Cloud. Ollama remains the local runtime integration; set `OLLAMA_API_KEY` only when your local or self-hosted deployment enforces bearer auth.
 
 ### Programmatic OAuth
 

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

@@ -218,11 +218,8 @@ export declare function isInvalidThinkingSignatureError(message: string): boolea
  */
 export declare function maybeAddReplayUnsignedThinkingHint(model: Model<"anthropic-messages">, message: string): string;
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries (a benign terminal stop carrying no content/usage would otherwise
- * stall the agent loop). The inner attempt keeps its own provider-failure retry
- * loop; this layer only re-issues a fresh request on an empty success. Shared
- * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. The inner attempt owns Anthropic provider-failure retries.
  */
 export declare const streamAnthropic: StreamFunction<"anthropic-messages">;
 export type AnthropicSystemBlock = {

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

@@ -12,6 +12,9 @@ export interface AzureOpenAIResponsesOptions extends StreamOptions {
     disableReasoning?: boolean;
 }
 /**
- * Generate function for Azure OpenAI Responses API
+ * Retries transient Azure stream failures only before assistant output commits
+ * the attempt. The unsupported explicit prompt-cache config is rejected
+ * synchronously here — callers of the direct entrypoint get the immediate
+ * `ConfigurationError` rather than a stream whose `.result()` rejects later.
  */
 export declare const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses">;

package/dist/types/providers/openai-completions.d.ts

@@ -38,10 +38,8 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     promptCache?: OpenAIPromptCacheOptions;
 }
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries — flaky gateways occasionally 200 with `delta: {}` + `finish_reason:
- * "stop"` and no usage, which would otherwise stall the agent loop. Shared with
- * the Anthropic provider via `withEmptyCompletionRetry`.
+ * Retries benign empty completions and transient provider failures only before
+ * assistant output commits the attempt.
  */
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];

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

@@ -106,10 +106,9 @@ type OpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
     cache_ttl?: "5m" | "1h";
 };
 /**
- * Public entry: wrap the single-attempt Responses streamer with bounded
- * empty-completion retries — a `response.completed` carrying no content/usage
- * would otherwise stall the agent loop. Shared with the OpenAI-completions and
- * Anthropic providers via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. Transient stream failures are retried inside the attempt so stateful
+ * Responses request metadata remains stable.
  */
 export declare const streamOpenAIResponses: StreamFunction<"openai-responses">;
 export declare function buildParams(model: Model<"openai-responses">, context: Context, options: OpenAIResponsesOptions | undefined, providerSessionState: OpenAIResponsesProviderSessionState | undefined, strictToolsScope?: OpenAIStrictToolsScope, disableStrictToolsOverride?: boolean, statefulCacheBaseline?: ResponseInput): {

package/dist/types/providers/openai-shared.d.ts

@@ -234,6 +234,7 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
     preserve_thinking?: boolean;
     chat_template_kwargs?: {
         enable_thinking?: boolean;
+        thinking?: boolean;
         preserve_thinking?: boolean;
         reasoning_effort?: string;
     };
@@ -684,4 +685,4 @@ export declare function buildResponsesDeltaInput<TItem extends ResponseInputItem
     input?: TItem[];
 } | undefined, previousResponseItems: readonly TItem[] | undefined, current: {
     input?: TItem[];
-}): TItem[] | null;
+}, additionalTopLevelExcludeMap?: Readonly<Record<string, boolean>>): TItem[] | null;

package/dist/types/registry/deepinfra.d.ts

@@ -0,0 +1,6 @@
+export declare const loginDeepinfra: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const deepinfraProvider: {
+    id: "deepinfra";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+};

package/dist/types/registry/oauth/openrouter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Sign in with OpenRouter (OAuth PKCE).
+ *
+ * No client registration: the S256 PKCE challenge is the only proof of
+ * identity. The browser authorizes at `https://openrouter.ai/auth`, redirects
+ * back to the loopback callback with `?code=`, and the code + verifier
+ * exchange at `/api/v1/auth/keys` mints a durable `sk-or-…` API key.
+ *
+ * OpenRouter never echoes a `state` parameter (the redirect only appends
+ * `?code=` to the callback URL), so the flow runs with an empty expected
+ * state — callback-state validation is disabled and the PKCE verifier binds
+ * the exchange instead.
+ *
+ * The manual-input race doubles as the API-key paste path: pasted `sk-or-…`
+ * keys skip the PKCE exchange and are validated against `/api/v1/auth/key`
+ * (the canonical "who am I" endpoint — `/api/v1/models` returns 200 for any
+ * bearer), so one login entry covers both browser sign-in and key paste.
+ */
+import type { FetchImpl } from "../../types.js";
+import { OAuthCallbackFlow } from "./callback-server.js";
+import type { OAuthController, OAuthCredentials } from "./types.js";
+/** Exchange an authorization code + PKCE verifier for a durable OpenRouter API key. */
+export declare function exchangeOpenRouterCode(code: string, codeVerifier: string, fetchImpl?: FetchImpl): Promise<string>;
+export declare class OpenRouterOAuthFlow extends OAuthCallbackFlow {
+    #private;
+    constructor(ctrl: OAuthController);
+    /** OpenRouter never echoes `state`; empty state disables callback-state validation. */
+    generateState(): string;
+    generateAuthUrl(_state: string, redirectUri: string): Promise<{
+        url: string;
+        instructions?: string;
+    }>;
+    exchangeToken(code: string): Promise<OAuthCredentials>;
+}
+/** Log in with Sign in with OpenRouter (PKCE); mints a durable API key. */
+export declare function loginOpenRouterOAuth(ctrl: OAuthController): Promise<OAuthCredentials>;

package/dist/types/registry/openrouter.d.ts

@@ -1,13 +1,14 @@
 import type { OAuthLoginCallbacks } from "./oauth/types.js";
-/** OpenRouter login flow (API key paste, validated via /auth/key).
- *
- * `/api/v1/models` is public and returns 200 for any bearer (including bogus),
- * so it cannot validate auth. `/api/v1/auth/key` is the canonical "who am I"
- * endpoint — 200 for valid keys, 401 otherwise.
+/**
+ * OpenRouter login: Sign in with OpenRouter (OAuth PKCE) that mints a durable
+ * `sk-or-…` API key, with the manual-input race accepting a pasted existing
+ * key (validated via `/api/v1/auth/key`). Either path resolves to a plain API
+ * key string, stored as an `api_key` credential.
  */
-export declare const loginOpenRouter: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 export declare const openrouterProvider: {
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 };

package/dist/types/registry/registry.d.ts

@@ -82,6 +82,10 @@ declare const ALL: ({
     readonly name: "Cursor (Claude, GPT, etc.)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<import("./oauth/index.js").OAuthCredentials>;
     readonly refreshToken: (credentials: import("./oauth/index.js").OAuthCredentials) => Promise<import("./oauth/index.js").OAuthCredentials>;
+} | {
+    id: "deepinfra";
+    name: string;
+    login: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
 } | {
     readonly id: "deepseek";
     readonly name: "DeepSeek";
@@ -254,6 +258,8 @@ declare const ALL: ({
     readonly id: "openrouter";
     readonly name: "OpenRouter";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+    readonly callbackPort: 54549;
+    readonly pasteCodeFlow: true;
 } | {
     readonly id: "parallel";
     readonly name: "Parallel";
@@ -342,6 +348,10 @@ declare const ALL: ({
     readonly id: "xiaomi-token-plan-sgp";
     readonly name: "Xiaomi Token Plan (Singapore)";
     readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: import("./oauth/index.js").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "zai";
     readonly name: "Z.AI (GLM Coding Plan)";

package/dist/types/registry/yolo-auto.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthLoginCallbacks } from "./oauth/types.js";
+/**
+ * Yolo-Auto login flow (API key paste, validated via `/v1/models`).
+ *
+ * Yolo-Auto is a flat-rate OpenAI-compatible API. `GET /v1/models` 401s any
+ * missing or invalid bearer (verified against the live endpoint), so it doubles
+ * as the canonical "who am I" check — the same role OpenRouter's `/auth/key`
+ * plays there.
+ */
+export declare const loginYoloAuto: (options: import("./oauth/index.js").OAuthController) => Promise<string>;
+export declare const yoloAutoProvider: {
+    readonly id: "yolo-auto";
+    readonly name: "Yolo-Auto";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/utils/empty-completion-retry.d.ts

@@ -8,15 +8,24 @@ export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
  * — or one that only ever produced thinking — is the "empty response" failure.
  */
 export declare function hasVisibleAssistantContent(message: AssistantMessage): boolean;
-interface EmptyCompletionRetryOptions {
+interface StreamRetryOptions {
     signal?: AbortSignal;
     providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
     acceptEmptyResponse?: boolean;
 }
+/** Controls which replay-safe provider results may issue a fresh request. */
+export interface ReplaySafeStreamRetryPolicy {
+    /** Retry benign terminal stops that contain no visible output. */
+    retryEmptyCompletion?: boolean;
+    /** Retry transient provider errors before output is committed. */
+    retryProviderErrors?: boolean;
+    /** Maximum transient provider-error retries; empty completions keep their shared fixed budget. */
+    maxProviderErrorRetries?: number;
+}
 /**
- * Wrap a single-attempt provider stream with bounded empty-completion retries.
- * `attempt` MUST create a fresh request (and its own output message) on each
- * call so a retry never inherits stale metadata from an empty attempt.
+ * Re-issues a fresh provider request only while the current attempt remains
+ * replay-safe. Buffered pre-output events from discarded attempts never reach
+ * consumers.
  */
-export declare function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream): AssistantMessageEventStream;
+export declare function withReplaySafeStreamRetry<M, O extends StreamRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream, policy: ReplaySafeStreamRetryPolicy): AssistantMessageEventStream;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.0.4",
+	"version": "18.0.5",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,10 +37,10 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.0.4",
-		"@oh-my-pi/pi-catalog": "18.0.4",
-		"@oh-my-pi/pi-utils": "18.0.4",
-		"@oh-my-pi/pi-wire": "18.0.4"
+		"@oh-my-pi/omptype": "18.0.5",
+		"@oh-my-pi/pi-catalog": "18.0.5",
+		"@oh-my-pi/pi-utils": "18.0.5",
+		"@oh-my-pi/pi-wire": "18.0.5"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/error/flags.ts

@@ -99,6 +99,7 @@ const CONTEXT_OVERFLOW_EVIDENCE_PATTERNS = [
 	/model_context_window_exceeded/i, // z.ai non-standard finish_reason surfaced as error text
 	/prompt filled the context window/i, // Ollama OpenAI-compatible empty length completion
 	/exceeds the limit of \d+ tokens?\b/i,
+	/chat history exceeds the \d+-message limit/i, // Provider message-count cap
 ] as const;
 // Numeric limit pattern — also matches media budgets, so must never veto a payload flag (#9235).
 const GENERIC_LIMIT_OVERFLOW_PATTERN = /exceeds the limit of \d+/i;

package/src/providers/anthropic.ts

@@ -54,7 +54,7 @@ import {
 	kStreamingLastParseLen,
 	kStreamingPartialJson,
 } from "../utils/block-symbols";
-import { withEmptyCompletionRetry } from "../utils/empty-completion-retry";
+import { withReplaySafeStreamRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { isFoundryEnabled } from "../utils/foundry";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
@@ -2873,14 +2873,13 @@ const streamAnthropicOnce = (
 };
 
 /**
- * Public entry: wrap the single-attempt streamer with bounded empty-completion
- * retries (a benign terminal stop carrying no content/usage would otherwise
- * stall the agent loop). The inner attempt keeps its own provider-failure retry
- * loop; this layer only re-issues a fresh request on an empty success. Shared
- * with the OpenAI-completions provider via `withEmptyCompletionRetry`.
+ * Public entry: retry benign empty completions before they reach the agent
+ * loop. The inner attempt owns Anthropic provider-failure retries.
  */
 export const streamAnthropic: StreamFunction<"anthropic-messages"> = (model, context, options) =>
-	withEmptyCompletionRetry(model, context, options, streamAnthropicOnce);
+	withReplaySafeStreamRetry(model, context, options, streamAnthropicOnce, {
+		retryEmptyCompletion: true,
+	});
 
 export type AnthropicSystemBlock = {
 	type: "text";

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

@@ -13,6 +13,7 @@ import type {
 } from "../types";
 import { resolveCacheRetention } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
+import { withReplaySafeStreamRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import type { RawHttpRequestDump } from "../utils/http-inspector";
 import {
@@ -76,19 +77,12 @@ type AzureOpenAIResponsesSamplingParams = ResponseCreateParamsStreaming & {
 	repetition_penalty?: number;
 };
 
-/**
- * Generate function for Azure OpenAI Responses API
- */
-export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"> = (
+/** Runs one Azure OpenAI Responses request and decodes its event stream. */
+const streamAzureOpenAIResponsesOnce = (
 	model: Model<"azure-openai-responses">,
 	context: Context,
 	options?: AzureOpenAIResponsesOptions,
 ): AssistantMessageEventStream => {
-	if (options?.promptCache?.mode === "explicit" && resolveCacheRetention(options.cacheRetention) !== "none") {
-		throw new AIError.ConfigurationError(
-			`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; Azure Responses does not emit explicit cache controls.`,
-		);
-	}
 	const stream = new AssistantMessageEventStream();
 
 	// Start async processing
@@ -265,6 +259,24 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 	return stream;
 };
 
+/**
+ * Retries transient Azure stream failures only before assistant output commits
+ * the attempt. The unsupported explicit prompt-cache config is rejected
+ * synchronously here — callers of the direct entrypoint get the immediate
+ * `ConfigurationError` rather than a stream whose `.result()` rejects later.
+ */
+export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"> = (model, context, options) => {
+	if (options?.promptCache?.mode === "explicit" && resolveCacheRetention(options.cacheRetention) !== "none") {
+		throw new AIError.ConfigurationError(
+			`OpenAI explicit prompt caching is unsupported for ${model.provider}/${model.id}; Azure Responses does not emit explicit cache controls.`,
+		);
+	}
+	return withReplaySafeStreamRetry(model, context, options, streamAzureOpenAIResponsesOnce, {
+		retryProviderErrors: true,
+		maxProviderErrorRetries: 1,
+	});
+};
+
 function resolveAzureConfig(
 	model: Model<"azure-openai-responses">,
 	options?: AzureOpenAIResponsesOptions,

package/src/providers/ollama.ts

@@ -16,7 +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 { withReplaySafeStreamRetry } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import type { CapturedHttpErrorResponse, RawHttpRequestDump } from "../utils/http-inspector";
 import {
@@ -785,4 +785,6 @@ const streamOllamaOnce = (
 
 /** 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);
+	withReplaySafeStreamRetry(model, context, options, streamOllamaOnce, {
+		retryEmptyCompletion: true,
+	});

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

@@ -54,6 +54,7 @@ import {
 	stripOpenAIResponsesComputerLinkedReasoningIdsForReplay,
 } from "../utils";
 import { clearStreamingPartialJson, kStreamingLastParseLen, kStreamingPartialJson } from "../utils/block-symbols";
+import { hasVisibleAssistantContent } from "../utils/empty-completion-retry";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { escapeHarmonyControlTokens, isHarmonyDialectModel } from "../utils/harmony-leak";
 import type { RawHttpRequestDump } from "../utils/http-inspector";
@@ -458,6 +459,7 @@ export interface OpenAICodexWebSocketDebugStats {
 type CodexWebSocketSessionState = {
 	disableWebsocket: boolean;
 	lastRequest?: RequestBody;
+	/** Last completed response; an in-progress response cannot replace the retry baseline. */
 	lastResponseId?: string;
 	lastResponseItems?: InputItem[];
 	canAppend: boolean;
@@ -1019,14 +1021,6 @@ class CodexStreamRuntime {
 		const input = (rawEvent as { input?: string }).input;
 		if (typeof input === "string") finalizeCustomToolCallInputDone(entry.block, input);
 	}
-
-	handleResponseCreated(rawEvent: Record<string, unknown>): void {
-		const response = (rawEvent as { response?: { id?: string } }).response;
-		const state = this.websocketState;
-		if (state && this.transport === "websocket" && typeof response?.id === "string" && response.id.length > 0) {
-			state.lastResponseId = response.id;
-		}
-	}
 }
 
 interface CodexWhitespaceToolCallArgumentsDeltaState {
@@ -1047,6 +1041,7 @@ interface CodexStreamFailureContext {
 	output: AssistantMessage;
 	options: OpenAICodexResponsesOptions | undefined;
 	requestContext: CodexRequestContext;
+	runtime?: CodexStreamRuntime;
 	startTime: number;
 	firstTokenTime?: number;
 }
@@ -2000,6 +1995,11 @@ const CODEX_STALE_PREVIOUS_RESPONSE_CODES: Record<string, true> = {
 	codex_previous_response_stale: true,
 };
 
+const CODEX_APPEND_PRESERVING_REJECTION_CODES: Record<string, true> = {
+	rate_limit_exceeded: true,
+	slow_down: true,
+};
+
 function isCodexStalePreviousResponseError(error: unknown): boolean {
 	if (!(error instanceof Error)) return false;
 	if (
@@ -2021,9 +2021,22 @@ function isCodexStalePreviousResponseError(error: unknown): boolean {
 	);
 }
 
+function shouldPreserveCodexWebSocketAppendState(context: CodexStreamFailureContext, error: unknown): boolean {
+	if (!(error instanceof CodexProviderStreamError) || !error.code) return false;
+	const state = context.requestContext.websocketState;
+	return (
+		Object.hasOwn(CODEX_APPEND_PRESERVING_REJECTION_CODES, error.code.toLowerCase()) &&
+		context.runtime?.transport === "websocket" &&
+		state?.canAppend === true &&
+		state.lastRequest !== undefined &&
+		state.lastResponseId !== undefined &&
+		state.lastResponseItems !== undefined
+	);
+}
+
 async function handleCodexStreamFailure(context: CodexStreamFailureContext, error: unknown): Promise<AssistantMessage> {
 	const { output } = context;
-	if (context.requestContext.websocketState) {
+	if (context.requestContext.websocketState && !shouldPreserveCodexWebSocketAppendState(context, error)) {
 		resetCodexWebSocketAppendState(context.requestContext.websocketState);
 		context.requestContext.websocketState.modelsEtag = undefined;
 	}
@@ -2296,11 +2309,6 @@ class CodexStreamProcessor {
 			return firstTokenTime;
 		}
 
-		if (eventType === "response.created") {
-			this.runtime.handleResponseCreated(rawEvent);
-			return firstTokenTime;
-		}
-
 		if (eventType === "response.completed" || eventType === "response.done" || eventType === "response.incomplete") {
 			this.#handleResponseCompleted(rawEvent);
 			return firstTokenTime;
@@ -2779,16 +2787,67 @@ class CodexStreamProcessor {
 		return true;
 	}
 
+	/**
+	 * Emit balancing `*_end` events for every block that opened (pushed a
+	 * `*_start`) but never committed visible content, so a retry that resets
+	 * `output` and replays cannot leave the consumer with an orphaned
+	 * `text_start`/`thinking_start` from the abandoned attempt. Only reachable
+	 * blocks are empty text/reasoning ones — a committed tool/text block blocks
+	 * the retry upstream.
+	 */
+	#closeOpenBlocksForReplay(): void {
+		const { runtime, output, stream } = this;
+		const open = new Set<CodexOpenItem>(runtime.openItems.values());
+		for (const entry of runtime.openItemsByOutputIndex.values()) open.add(entry);
+		if (runtime.currentEntry) open.add(runtime.currentEntry);
+		for (const entry of open) {
+			const block = entry.block;
+			if (block?.type === "thinking") {
+				stream.push({
+					type: "thinking_end",
+					contentIndex: entry.contentIndex,
+					content: block.thinking,
+					partial: output,
+				});
+			} else if (block?.type === "text") {
+				stream.push({ type: "text_end", contentIndex: entry.contentIndex, content: block.text, partial: output });
+			}
+		}
+	}
+
 	async #tryRetryProviderError(error: unknown): Promise<boolean> {
+		const retryable =
+			error instanceof CodexProviderStreamError
+				? error.retryable
+				: AIError.isProviderRetryableError(error, { provider: this.model.provider });
+		// A leading `response.output_item.added` opens an empty block and emits only
+		// a `*_start` before any delta; that is replay-safe. But once any text or
+		// thinking delta has streamed — including a whitespace-only
+		// `output_text.delta`, which still reaches consumers as `text_delta` — or a
+		// visible tool/image block exists, replaying would duplicate/reorder those
+		// already-delivered events, so treat the attempt as committed. Emptiness is
+		// measured by the streamed block length (whitespace counts), not by visible
+		// final content.
+		const streamedContent = this.output.content.some(
+			block =>
+				(block.type === "text" && block.text.length > 0) ||
+				(block.type === "thinking" && block.thinking.length > 0),
+		);
 		if (
-			!(error instanceof CodexProviderStreamError && error.retryable) ||
-			this.output.content.length > 0 ||
+			!retryable ||
+			hasVisibleAssistantContent(this.output) ||
+			streamedContent ||
+			!this.runtime.canSafelyReplayWebsocketOverSse ||
 			this.runtime.providerRetryAttempt >= CODEX_MAX_RETRIES ||
 			this.options?.signal?.aborted
 		) {
 			return false;
 		}
 
+		// A leading `output_item.added` already pushed a `*_start` for the (empty)
+		// open block; balance it with the matching end before the reset+replay so
+		// consumers never see an orphaned start from the abandoned attempt.
+		this.#closeOpenBlocksForReplay();
 		this.runtime.providerRetryAttempt += 1;
 		const websocketState = this.requestContext.websocketState;
 		if (websocketState) {
@@ -3463,10 +3522,14 @@ function recordCodexTurnUsageDiagnostics(
 	CODEX_DEBUG && logger.debug("[codex] codex turn diagnostics", { diagnostics: state.stats.lastTurn });
 }
 
+const CODEX_CHAIN_TOP_LEVEL_EXCLUDE_MAP = {
+	service_tier: true,
+};
+
 /**
- * Shape the next websocket turn's request body: when the session's append
- * baseline is intact (same options, strict history prefix), chain via
- * `previous_response_id` + delta-only `input`; otherwise break the chain and
+ * Shape the next websocket turn's request body: when the session's strict
+ * history prefix is intact and request options other than the per-turn
+ * service_tier match, chain via previous_response_id + delta-only input;
  * replay the full transcript. SSE requests never chain — the HTTP endpoint's
  * request schema has no `previous_response_id` (codex-rs carries it only on
  * websocket `response.create` frames) and strict gateway validators 400 it
@@ -3478,7 +3541,12 @@ function buildCodexChainedRequestBody(
 ): RequestBody {
 	const chainable = state?.canAppend === true;
 	const appendInput = chainable
-		? buildResponsesDeltaInput(state.lastRequest, state.lastResponseItems, requestBody)
+		? buildResponsesDeltaInput(
+				state.lastRequest,
+				state.lastResponseItems,
+				requestBody,
+				CODEX_CHAIN_TOP_LEVEL_EXCLUDE_MAP,
+			)
 		: null;
 	if (appendInput && appendInput.length > 0 && state?.lastResponseId) {
 		return { ...requestBody, previous_response_id: state.lastResponseId, input: appendInput };
@@ -3599,14 +3667,19 @@ class CodexWebSocketConnection {
 	}
 
 	close(reason = "done"): void {
-		if (
-			this.#socket &&
-			(this.#socket.readyState === WebSocket.OPEN || this.#socket.readyState === WebSocket.CONNECTING)
-		) {
-			this.#socket.close(1000, reason);
-		}
+		const socket = this.#socket;
 		this.#socket = null;
 		this.#stopHeartbeat();
+		if (!socket || (socket.readyState !== WebSocket.OPEN && socket.readyState !== WebSocket.CONNECTING)) return;
+		try {
+			socket.close(1000, reason);
+		} catch (error) {
+			CODEX_DEBUG &&
+				logger.debug("[codex] codex websocket close failed", {
+					error: error instanceof Error ? error.message : String(error),
+					reason,
+				});
+		}
 	}
 
 	async connect(signal?: AbortSignal): Promise<void> {
@@ -3634,7 +3707,7 @@ class CodexWebSocketConnection {
 			if (signal) signal.removeEventListener("abort", onAbort);
 		};
 		const onAbort = () => {
-			socket.close(1000, "aborted");
+			this.close("aborted");
 			if (!settled) {
 				settled = true;
 				clearPending();
@@ -3650,7 +3723,7 @@ class CodexWebSocketConnection {
 		}
 		if (!settled) {
 			timeout = setTimeout(() => {
-				socket.close(1000, "connect-timeout");
+				this.close("connect-timeout");
 				if (!settled) {
 					settled = true;
 					clearPending();