@oh-my-pi/pi-ai 18.8.6 → 18.8.8

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [18.8.8] - 2026-10-10
+
+### Fixed
+
+- Fixed OpenAI Responses and Codex tool calls running with empty `{}` arguments when a compatible host or proxy ends the call with an empty arguments payload after streaming the real ones ([#15099](https://github.com/can1357/oh-my-pi/pull/15099) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed truncated Factory Droid Gemini responses ending as a hard error or a half-received tool call instead of being retried ([#15103](https://github.com/can1357/oh-my-pi/pull/15103) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed Factory Droid Gemini ignoring an error the server reports mid-response, which hid its status and retried errors that cannot succeed ([#15103](https://github.com/can1357/oh-my-pi/pull/15103) by [@will-bogusz](https://github.com/will-bogusz))
+- Fixed resumed OpenAI Responses sessions (xAI, Factory Droid, OpenAI and other hosts) dropping all earlier encrypted reasoning on their first request; GitHub Copilot still rebuilds history until its first response ([#15148](https://github.com/can1357/oh-my-pi/pull/15148) by [@will-bogusz](https://github.com/will-bogusz))
+
+## [18.8.7] - 2026-10-09
+
+### Added
+
+- Added routing-session cleanup for OpenAI Responses and Codex while preserving shared provider fallbacks ([#14334](https://github.com/can1357/oh-my-pi/pull/14334) by [@iliaal](https://github.com/iliaal)).
+
+### Fixed
+
+- Fixed Claude Haiku 5.5 requests silently enabling adaptive thinking when reasoning is off, on native Bedrock (main and helper calls) and the Anthropic API; conversations whose earlier effort controls rule out disabled thinking fall back to lowest-effort adaptive thinking instead of failing ([#14996](https://github.com/can1357/oh-my-pi/pull/14996) by [@bse-ai](https://github.com/bse-ai)).
+- Fixed `/session pin` being ignored when every stored account is quota-blocked, which routed the next request to a different exhausted account instead of the pinned one ([#14997](https://github.com/can1357/oh-my-pi/issues/14997)).
+- Fixed `minimax-code-cn` sessions staying pinned to a key whose Token Plan quota is exhausted (`用量上限` 429) instead of rotating to a sibling credential ([#15053](https://github.com/can1357/oh-my-pi/issues/15053)).
+
 ## [18.8.6] - 2026-10-08
 
 ### Fixed

package/dist/types/auth/select.d.ts

@@ -71,9 +71,9 @@ export declare class CredentialSelector {
      * 1. strict: unblocked credentials only, usage limits respected, plan
      *    filter enforced (when any account is confirmed eligible);
      * 2. plan-fitting last resort: same plan filter, but blocked/exhausted
-     *    accounts are allowed (blocked candidates rank earliest-unblocking
-     *    first) so the caller gets real usage-limit semantics from the wire
-     *    instead of a missing key;
+     *    accounts are allowed (an explicit session pin first, then blocked
+     *    candidates earliest-unblocking first) so the caller gets real
+     *    usage-limit semantics from the wire instead of a missing key;
      * 3. unfiltered last resort: the plan filter matched nothing usable —
      *    skip it and try every account once; the server is the final arbiter
      *    of model access.

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

@@ -153,6 +153,13 @@ export declare function pushToolCallEvents(toolCall: ToolCall, contentIndex: num
 export declare function startTextOrThinkingBlock(isThinking: true, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): ThinkingContent;
 export declare function startTextOrThinkingBlock(isThinking: false, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent;
 export declare function startTextOrThinkingBlock(isThinking: boolean, output: AssistantMessage, stream: AssistantMessageEventStream, onBeforeStartEvent?: () => void): TextContent | ThinkingContent;
+/**
+ * Error for an in-band `error` frame in a 200 generateContent stream. Keeps the
+ * RPC status alongside the message: an in-band quota failure is classified
+ * from this text, and `RESOURCE_EXHAUSTED` is the only account-exhaustion
+ * signal some of these chunks carry (#13090).
+ */
+export declare function googleStreamChunkError(error: NonNullable<GenerateContentResponse["error"]>, provider: string): Error;
 /**
  * Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
  * the corresponding `AssistantMessageEventStream`. Shared between `streamGoogle` and

package/dist/types/providers/openai-configuration-update.d.ts

@@ -35,16 +35,19 @@ interface EffortTransition<TEffort extends string> {
 }
 /** Per-conversation effort baseline and recorded transitions. */
 export interface OpenAIEffortControlState<TEffort extends string = string> {
+    sessionId: string;
     baseEffort?: TEffort;
     currentEffort?: TEffort;
     transitions: EffortTransition<TEffort>[];
 }
-export declare function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort>;
+export declare function createOpenAIEffortControlState<TEffort extends string>(sessionId: string): OpenAIEffortControlState<TEffort>;
 /**
  * Fetch (or create) the control state for one conversation from a provider's
  * bounded per-session map, refreshing its LRU slot.
  */
-export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string): OpenAIEffortControlState<TEffort>;
+export declare function getOpenAIEffortControlState<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, key: string, sessionId: string): OpenAIEffortControlState<TEffort>;
+/** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
+export declare function releaseOpenAIEffortControlSession<TEffort extends string>(states: Map<string, OpenAIEffortControlState<TEffort>>, sessionId: string): void;
 interface AnchorableItem {
     type?: string | null;
     role?: string;

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

@@ -82,7 +82,14 @@ export declare function pollOpenAIResponsesResultForCompletion(args: {
     wait?: (ms: number, signal?: AbortSignal) => Promise<void>;
 }): Promise<Record<string, unknown> | undefined>;
 interface OpenAIResponsesProviderSessionState extends ProviderSessionState, OpenAIStrictToolsState, OpenAIReasoningEffortFallbackState {
+    /**
+     * Replay native history items. Starts false only on connection-bound hosts;
+     * `close()` clears it so the next request rebuilds history from message
+     * content; the first successful response sets it.
+     */
     nativeHistoryReplayWarmed: boolean;
+    /** Bumped by `close()`; a response warms the state only if no close happened since its request started. */
+    closeCount: number;
     /** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
     chains: Map<string, OpenAIResponsesChainState>;
     /** `configuration_update` effort baselines, keyed by baseUrl/model/session. */
@@ -91,6 +98,7 @@ interface OpenAIResponsesProviderSessionState extends ProviderSessionState, Open
 /** Wire efforts a `configuration_update` can carry: every real tier, never `none`/null. */
 type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 interface OpenAIResponsesChainState {
+    sessionId: string;
     /**
      * Wire params of the last successful turn; never carries
      * `previous_response_id`.

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

@@ -622,7 +622,8 @@ export declare function accumulateToolCallArgumentsDelta(block: ResponsesToolCal
  * Finalize streamed function-call arguments from the authoritative `.done`
  * payload. The caller owns the `argumentsDone` flag (generic Responses sets it;
  * Codex's block shape has no such field), so this only rewrites `arguments` and
- * drops the transient accumulation fields.
+ * drops the transient accumulation fields. A blank payload is not authoritative:
+ * it parses the buffered deltas and keeps them so the final item can still win.
  */
 export declare function finalizeToolCallArgumentsDone(block: ResponsesToolCallBlock, args: string): void;
 export declare function accumulateCustomToolCallInputDelta(block: ResponsesToolCallBlock, delta: string, stream: AssistantMessageEventStream, output: AssistantMessage, contentIndex: number): void;

package/dist/types/types.d.ts

@@ -191,6 +191,8 @@ export declare function parseServiceTier(value: unknown): ServiceTier | undefine
 export declare function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily | undefined;
 export interface ProviderSessionState {
     close(): void;
+    /** Release one routing session after its final request, preserving shared provider fallbacks. */
+    releaseSession?(sessionId: string): void;
 }
 export interface ProviderResponseMetadata {
     status: number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.8.6",
+	"version": "18.8.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -155,11 +155,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.8.6",
-		"@oh-my-pi/pi-catalog": "18.8.6",
-		"@oh-my-pi/pi-natives": "18.8.6",
-		"@oh-my-pi/pi-utils": "18.8.6",
-		"@oh-my-pi/pi-wire": "18.8.6"
+		"@oh-my-pi/omptype": "18.8.8",
+		"@oh-my-pi/pi-catalog": "18.8.8",
+		"@oh-my-pi/pi-natives": "18.8.8",
+		"@oh-my-pi/pi-utils": "18.8.8",
+		"@oh-my-pi/pi-wire": "18.8.8"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth/select.ts

@@ -505,9 +505,9 @@ export class CredentialSelector {
 	 * 1. strict: unblocked credentials only, usage limits respected, plan
 	 *    filter enforced (when any account is confirmed eligible);
 	 * 2. plan-fitting last resort: same plan filter, but blocked/exhausted
-	 *    accounts are allowed (blocked candidates rank earliest-unblocking
-	 *    first) so the caller gets real usage-limit semantics from the wire
-	 *    instead of a missing key;
+	 *    accounts are allowed (an explicit session pin first, then blocked
+	 *    candidates earliest-unblocking first) so the caller gets real
+	 *    usage-limit semantics from the wire instead of a missing key;
 	 * 3. unfiltered last resort: the plan filter matched nothing usable —
 	 *    skip it and try every account once; the server is the final arbiter
 	 *    of model access.
@@ -535,6 +535,9 @@ export class CredentialSelector {
 		const credentials = stored.filter(entry => this.#deps.affinity.allows(provider, sessionId, entry.credential));
 
 		if (credentials.length === 0) return undefined;
+		// Ranking and preflight both await provider work; preserve the row each
+		// selection started with even if a peer reorders the live pool.
+		const credentialIds = this.#deps.pool.entries(provider).map(entry => entry.id);
 		this.#deps.policies.validateUsageCapability(provider, this.#deps.usage.canFetchOAuthUsage(provider));
 
 		const providerKey = providerTypeKey(provider, "oauth");
@@ -659,6 +662,11 @@ export class CredentialSelector {
 							? { selection, usage: sessionPreferredUsage, usageChecked: true }
 							: { selection, usage: null, usageChecked: false },
 					);
+		// Keep the candidate object: preflight may rebind its positional index
+		// after a peer changes the credential pool.
+		const explicitPin = sessionPinIsExplicit
+			? candidates.find(candidate => candidate.selection.index === sessionPreferredIndex)
+			: undefined;
 		const preflightFailures = new Set<OAuthCandidate>();
 		// The last retryable refresh error (network, timeout, 5xx) that removed a candidate.
 		// When no candidate resolves, it is rethrown so callers retry instead of reporting
@@ -714,21 +722,24 @@ export class CredentialSelector {
 		const forceRefreshIndex = options?.forceRefresh
 			? (sessionPreferredIndex ?? candidates[0]?.selection.index)
 			: undefined;
-		// Each candidate's synchronous prefix below runs back to back inside `map`,
-		// before any await, so one provider re-list serves every initial rebind.
-		// Resyncs after an await (refresh, disable) re-read the store.
+		// Candidate IDs were captured before ranking. Their synchronous rebinds
+		// share one provider re-list; resyncs after refresh await re-read the store.
 		let preflightRows: StoredAuthCredential[] | undefined;
 		await Promise.all(
 			candidates.map(async candidate => {
 				const force = forceRefreshIndex !== undefined && candidate.selection.index === forceRefreshIndex;
-				const initialCredentialId = this.#deps.pool.entries(provider)[candidate.selection.index]?.id;
-				let syncedPeerCredential = false;
-				if (initialCredentialId !== undefined) {
-					const beforeSync = candidate.selection.credential;
-					preflightRows ??= this.#reloadProviderRows(provider);
-					if (!this.#rebindOAuthSelection(preflightRows, candidate.selection, initialCredentialId)) return;
-					syncedPeerCredential = !authCredentialEquals(beforeSync, candidate.selection.credential);
+				const initialCredentialId = credentialIds[candidate.selection.index];
+				if (initialCredentialId === undefined) {
+					preflightFailures.add(candidate);
+					return;
+				}
+				const beforeSync = candidate.selection.credential;
+				preflightRows ??= this.#reloadProviderRows(provider);
+				if (!this.#rebindOAuthSelection(preflightRows, candidate.selection, initialCredentialId)) {
+					preflightFailures.add(candidate);
+					return;
 				}
+				const syncedPeerCredential = !authCredentialEquals(beforeSync, candidate.selection.credential);
 				const hasFreshAccess = Date.now() + OAUTH_REFRESH_SKEW_MS < candidate.selection.credential.expires;
 				if ((!force || syncedPeerCredential) && hasFreshAccess) return;
 				const latestCredential = this.#deps.pool.credentials(provider)[candidate.selection.index];
@@ -884,9 +895,15 @@ export class CredentialSelector {
 		];
 		if (enforcePlanRequirement) passes.push({ allowBlocked: true, enforcePlanRequirement: false, enforceAccounts });
 		if (enforceAccounts) passes.push({ allowBlocked: true, enforcePlanRequirement: false, enforceAccounts: false });
+		// Blocked candidates rank earliest-unblock first, which would route a
+		// blocked explicit pin to an equally blocked sibling. Once the strict
+		// pass finds no unblocked account, the user's pin goes first.
+		const lastResortCandidates = explicitPin
+			? [explicitPin, ...candidates.filter(candidate => candidate !== explicitPin)]
+			: candidates;
 
 		for (const pass of passes) {
-			for (const candidate of candidates) {
+			for (const candidate of pass.allowBlocked ? lastResortCandidates : candidates) {
 				if (preflightFailures.has(candidate)) continue;
 				const candidateAccountKey = oauthAccountKey(candidate.selection.credential);
 				if (pass.enforceAccounts && (candidateAccountKey === undefined || !accountIds?.has(candidateAccountKey)))

package/src/error/rate-limit.ts

@@ -78,15 +78,17 @@ const ACCOUNT_SCOPED_403_PATTERN =
 	/\b(?:overall|account|organization|team|workspace)\b[^\n]{0,40}\b(?:message |request )?rate.?limit\b|\byour\b[^\n]{0,30}\b(?:limit )?will reset\b/i;
 // Simplified Chinese account-quota exhaustion phrasing. Zhipu Coding Plan
 // returns e.g. "429 已达到 5 小时的使用上限。您的限额将在 2026-08-06 20:06:00 重置。"
-// (type=1308) when the 5h window is spent; other CN providers use 额度已用完 /
+// (type=1308) when the 5h window is spent; MiniMax CN returns
+// "当前已达到 Token Plan 用量上限。…" (2067); other CN providers use 额度已用完 /
 // 配额已耗尽 / 余额不足. These are persistent account-local caps that must
 // rotate to a sibling credential, not transient rate limits, so they are
 // matched before the RATE_LIMIT_EXCEEDED branch. The 上限 arm is anchored on
-// the 使用 token: a rate/concurrency cap phrased as 每分钟请求数已达上限 /
-// 并发请求数已达上限 / 速率达到上限 (no 使用) must NOT match, or it would burn a
-// healthy sibling credential as a false quota. "速率限制" is absent for the
-// same reason.
-const CN_QUOTA_EXHAUSTED_PATTERN = /使用.{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
+// the 使用 / 用量 tokens: a rate/concurrency cap phrased as 每分钟请求数已达上限 /
+// 并发请求数已达上限 / 速率达到上限 (neither token) must NOT match, or it would
+// burn a healthy sibling credential as a false quota. "速率限制" is absent for
+// the same reason.
+const CN_QUOTA_EXHAUSTED_PATTERN =
+	/(?:使用|用量).{0,30}?上限|(?:额度|配额)已?(?:用|耗)(?:完|尽)|限额.{0,30}重置|余额不足/;
 // Simplified Chinese rate/concurrency caps can contain both 使用 and 上限, but
 // remain transient rather than account quota exhaustion.
 const CN_TRANSIENT_CAP_PATTERN =

package/src/providers/amazon-bedrock.ts

@@ -450,16 +450,20 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			let toolConfig = toolPlan.toolConfig;
 			const sentinelInjected = toolPlan.sentinelInjected;
 			let additionalModelRequestFields = buildAdditionalModelRequestFields(model, options);
-			const prefixMismatchBehavior = model.thinking?.prefixBinding
-				? (options.anthropicPrefixMismatchBehavior ?? "drop_block")
-				: undefined;
+			const thinkingDisabled =
+				isRecord(additionalModelRequestFields?.thinking) &&
+				additionalModelRequestFields.thinking.type === "disabled";
+			const prefixMismatchBehavior =
+				!thinkingDisabled && model.thinking?.prefixBinding
+					? (options.anthropicPrefixMismatchBehavior ?? "drop_block")
+					: undefined;
 
 			// Some models (Opus/Sonnet 5.5) reject forced tool use outright; keep the
 			// tools offered under `auto` and leave thinking intact.
 			const forcedChoice = toolConfig?.toolChoice?.any || toolConfig?.toolChoice?.tool;
 			if (toolConfig && forcedChoice && !model.compat.supportsForcedToolChoice) {
 				toolConfig = { ...toolConfig, toolChoice: { auto: {} } };
-			} else if (toolConfig && forcedChoice && additionalModelRequestFields) {
+			} else if (toolConfig && forcedChoice && additionalModelRequestFields && !thinkingDisabled) {
 				// Bedrock rejects thinking + forced tool_choice. Fable's adaptive
 				// thinking cannot be disabled, so downgrade its forced choice instead.
 				if (prefixMismatchBehavior) toolConfig = { ...toolConfig, toolChoice: { auto: {} } };
@@ -1335,7 +1339,13 @@ function buildAdditionalModelRequestFields(
 	options: BedrockOptions,
 ): Record<string, unknown> | undefined {
 	const reasoning = options.reasoning;
-	if (!reasoning || !model.reasoning) return undefined;
+	if (!model.reasoning) return undefined;
+	if (!reasoning) {
+		if (model.compat.disabledThinking === "disabled") {
+			return { thinking: { type: "disabled" }, output_config: { effort: "low" } };
+		}
+		return undefined;
+	}
 
 	const mode = model.thinking?.mode;
 	if (mode === "anthropic-adaptive") {

package/src/providers/anthropic.ts

@@ -4514,6 +4514,23 @@ export function resolveAnthropicCompactionEffort(
 	);
 }
 
+/**
+ * Whether effort controls earlier requests left in `messages` rule out
+ * `thinking: {type: "disabled"}`: Anthropic rejects a per-message effort
+ * control with thinking off, and `disabled` above `high` effort. Both stay in
+ * force across a thinking toggle, so such a request falls back to the
+ * adaptive-only off path (lowest effort) instead of a 400.
+ */
+function effortControlsBlockDisabledThinking(
+	model: Model<"anthropic-messages">,
+	messages: readonly Message[],
+	records: readonly AnthropicControlRecord[],
+): boolean {
+	if (model.compat.supportsPerMessageEffort !== true) return false;
+	const plan = planAnthropicEffortControls(undefined, messages, records, true, undefined, false);
+	return plan.inserts.length > 0 || plan.topLevel === "xhigh" || plan.topLevel === "max";
+}
+
 /**
  * Splice control markers into `messages`. Inserts sharing an index come from
  * one request and merge into one control: tool changes first, then the effort.
@@ -4732,7 +4749,11 @@ function buildParams(
 	let outputConfigEffort: AnthropicOutputEffort | undefined;
 	if (model.reasoning) {
 		const disabledThinking = model.compat.disabledThinking;
-		if (options?.thinkingEnabled === false && disabledThinking !== undefined) {
+		if (
+			options?.thinkingEnabled === false &&
+			disabledThinking !== undefined &&
+			!(disabledThinking === "disabled" && effortControlsBlockDisabledThinking(model, context.messages, records))
+		) {
 			if (disabledThinking !== "omit") {
 				thinking =
 					disabledThinking === "adaptive"

package/src/providers/factory-droid/gemini.ts

@@ -15,6 +15,7 @@ import { notifyProviderResponse } from "../../utils/provider-response";
 import { dereferenceJsonSchema, normalizeSchemaForFactoryDroid, toolWireSchema } from "../../utils/schema";
 import {
 	extractGoogleErrorMessage,
+	googleStreamChunkError,
 	mapGoogleUsage,
 	mapStopReasonString,
 	nextToolCallId,
@@ -87,22 +88,22 @@ const FACTORY_DROID_BLOCK_REASONS: Record<string, true> = {
  * "unknown" bucket has no StopReason equivalent, so unknown terminators
  * surface as errors instead of masquerading as a clean stop.
  */
-function mapFactoryDroidFinishReason(reason: string | undefined): {
+function mapFactoryDroidFinishReason(reason: string): {
 	stopReason: "stop" | "length" | "error";
 	errorMessage?: string;
 } {
 	// mapStopReasonString already implements the CLI's outcome table
 	// (STOP→stop, MAX_TOKENS→length, everything else→error); the cast narrows
 	// its wide StopReason return to the three values it ever produces.
-	const stopReason = mapStopReasonString(reason ?? "") as "stop" | "length" | "error";
+	const stopReason = mapStopReasonString(reason) as "stop" | "length" | "error";
 	if (stopReason !== "error") return { stopReason };
-	if (reason && FACTORY_DROID_BLOCK_REASONS[reason]) {
+	if (FACTORY_DROID_BLOCK_REASONS[reason]) {
 		return { stopReason: "error", errorMessage: `Generation was blocked by content filters (${reason})` };
 	}
 	if (reason === "MALFORMED_FUNCTION_CALL") {
 		return { stopReason: "error", errorMessage: `Generation failed with finish reason: ${reason}` };
 	}
-	return { stopReason: "error", errorMessage: `Unknown finish reason: ${reason ?? "none"}` };
+	return { stopReason: "error", errorMessage: `Unknown finish reason: ${reason}` };
 }
 
 /** Transports whose outputs carry Gemini-verifiable signatures (Factory's own outputs are stamped google-generative-ai). */
@@ -414,6 +415,9 @@ export function streamFactoryDroidGemini(
 				},
 			);
 			for await (const chunk of chunks) {
+				// A server-declared error keeps its status and the same classification
+				// as the Google provider; only a stream that just stops is a premature close.
+				if (chunk.error) throw googleStreamChunkError(chunk.error, model.provider);
 				if (firstTokenTime === undefined && chunk.candidates?.[0]?.content?.parts?.some(part => part.text)) {
 					firstTokenTime = performance.now();
 				}
@@ -484,6 +488,20 @@ export function streamFactoryDroidGemini(
 			if (firstTokenTime !== undefined) output.ttft = firstTokenTime - startTime;
 
 			closeBlock();
+			// A stream that reaches EOF without a finishReason (and without a
+			// promptFeedback block) was truncated, even when it already carried
+			// functionCall parts; fail it as retryable instead of finishing the turn.
+			if (finishReason === undefined && !blockReason) {
+				// Worded like the other incomplete-stream errors so turn recovery
+				// continues a stream that already rendered text.
+				throw new AIError.ProviderResponseError(
+					"Factory Droid Gemini stream closed before a finish_reason was received",
+					{
+						provider: model.provider,
+						kind: "incomplete-stream",
+					},
+				);
+			}
 			for (const contentIndex of toolCallIndices) {
 				const toolCall = output.content[contentIndex] as ToolCall;
 				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
@@ -499,12 +517,12 @@ export function streamFactoryDroidGemini(
 				output.errorMessage = `Generation was blocked by content filters (${blockReason})`;
 				output.stopDetails = { type: "content_filter", category: blockReason };
 				stream.push({ type: "error", reason: "error", error: output });
-			} else {
+			} else if (finishReason !== undefined) {
 				const mapped = mapFactoryDroidFinishReason(finishReason);
 				output.stopReason = mapped.stopReason;
 				if (mapped.errorMessage) {
 					output.errorMessage = mapped.errorMessage;
-					if (mapped.stopReason === "error" && finishReason && FACTORY_DROID_BLOCK_REASONS[finishReason]) {
+					if (mapped.stopReason === "error" && FACTORY_DROID_BLOCK_REASONS[finishReason]) {
 						output.stopDetails = { type: "content_filter", category: finishReason };
 					}
 				}

package/src/providers/google-shared.ts

@@ -595,6 +595,23 @@ export function startTextOrThinkingBlock(
 	return block;
 }
 
+/**
+ * Error for an in-band `error` frame in a 200 generateContent stream. Keeps the
+ * RPC status alongside the message: an in-band quota failure is classified
+ * from this text, and `RESOURCE_EXHAUSTED` is the only account-exhaustion
+ * signal some of these chunks carry (#13090).
+ */
+export function googleStreamChunkError(error: NonNullable<GenerateContentResponse["error"]>, provider: string): Error {
+	const detail =
+		error.message && error.status
+			? `${error.message} (${error.status})`
+			: error.message || error.status || "unknown error";
+	const message = `Google API stream error: ${detail}`;
+	return typeof error.code === "number" && error.code >= 400
+		? new AIError.GoogleApiError(message, error.code)
+		: new AIError.ProviderResponseError(message, { provider, kind: "output" });
+}
+
 /**
  * Drives the chunked `generateContentStream` iterator into an `AssistantMessage` and
  * the corresponding `AssistantMessageEventStream`. Shared between `streamGoogle` and
@@ -645,19 +662,7 @@ export async function consumeGoogleStream<T extends GoogleApiType>(args: {
 	};
 
 	for await (const chunk of googleStream) {
-		if (chunk.error) {
-			// Keep the RPC status alongside the message: an in-band quota failure
-			// is classified from this text, and `RESOURCE_EXHAUSTED` is the only
-			// account-exhaustion signal some of these chunks carry (#13090).
-			const detail =
-				chunk.error.message && chunk.error.status
-					? `${chunk.error.message} (${chunk.error.status})`
-					: chunk.error.message || chunk.error.status || "unknown error";
-			const message = `Google API stream error: ${detail}`;
-			throw typeof chunk.error.code === "number" && chunk.error.code >= 400
-				? new AIError.GoogleApiError(message, chunk.error.code)
-				: new AIError.ProviderResponseError(message, { provider: model.provider, kind: "output" });
-		}
+		if (chunk.error) throw googleStreamChunkError(chunk.error, model.provider);
 		if (!chunk.candidates?.length && chunk.promptFeedback?.blockReason) {
 			const detail = chunk.promptFeedback.blockReasonMessage;
 			throw new AIError.ProviderResponseError(

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

@@ -102,6 +102,7 @@ export { setCodexAttestationProvider } from "./openai-codex-attestation";
 export type { CodexAttestationProvider } from "./openai-codex-attestation";
 import {
 	getOpenAIEffortControlState,
+	releaseOpenAIEffortControlSession,
 	type OpenAIEffortControlState,
 	planStableOpenAIEffort,
 } from "./openai-configuration-update";
@@ -434,6 +435,7 @@ export interface OpenAICodexWebSocketDebugStats {
  * is historical — SSE-only sessions use it too.
  */
 type CodexWebSocketSessionState = {
+	sessionId: string;
 	disableWebsocket: boolean;
 	lastRequest?: RequestBody;
 	/** Last completed response; an in-progress response cannot replace the retry baseline. */
@@ -1058,6 +1060,20 @@ function createCodexProviderSessionState(): CodexProviderSessionState {
 		webSocketPublicToPrivate: new Map(),
 		metadataSessions: new Map(),
 		effortControls: new Map(),
+		releaseSession: sessionId => {
+			const normalizedSessionId = normalizeOpenAIPromptCacheKey(sessionId);
+			if (!normalizedSessionId) return;
+			for (const [key, session] of state.webSocketSessions) {
+				if (session.sessionId !== normalizedSessionId) continue;
+				session.connection?.close("session_disposed");
+				state.webSocketSessions.delete(key);
+				for (const [publicKey, privateKey] of state.webSocketPublicToPrivate) {
+					if (privateKey === key) state.webSocketPublicToPrivate.delete(publicKey);
+				}
+			}
+			state.metadataSessions.delete(normalizedSessionId);
+			releaseOpenAIEffortControlSession(state.effortControls, normalizedSessionId);
+		},
 		close: () => {
 			for (const session of state.webSocketSessions.values()) {
 				session.connection?.close("session_disposed");
@@ -1472,14 +1488,14 @@ function createCodexRequestContext(
 		transportProviderSessionState?.webSocketPublicToPrivate.set(publicSessionKey, sessionKey);
 	}
 	const sharedWebsocketState =
-		sessionKey && providerSessionState
+		sessionKey && transportSessionId && providerSessionState
 			? isolatedTransportState
 				? providerSessionState.webSocketSessions.get(sessionKey)
-				: getCodexWebSocketSessionState(sessionKey, providerSessionState)
+				: getCodexWebSocketSessionState(sessionKey, transportSessionId, providerSessionState)
 			: undefined;
 	const websocketState =
-		sessionKey && isolatedTransportState
-			? getCodexWebSocketSessionState(sessionKey, isolatedTransportState)
+		sessionKey && transportSessionId && isolatedTransportState
+			? getCodexWebSocketSessionState(sessionKey, transportSessionId, isolatedTransportState)
 			: sharedWebsocketState;
 	if (isolatedTransportState && websocketState && sharedWebsocketState) {
 		websocketState.disableWebsocket = sharedWebsocketState.disableWebsocket;
@@ -1616,7 +1632,7 @@ function applyCodexStableEffort(
 	const providerState = getCodexProviderSessionState(options?.providerSessionState);
 	const sessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
 	if (!providerState || !sessionId) return;
-	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`);
+	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`, sessionId);
 	body.reasoning = { ...body.reasoning, effort: planStableOpenAIEffort(state, body.input, effort) };
 }
 
@@ -2621,11 +2637,17 @@ class CodexStreamProcessor {
 		}
 
 		if (item.type === "function_call") {
+			const partial = block?.type === "toolCall" ? block[kStreamingPartialJson] : undefined;
 			const toolCall: ToolCall = {
 				type: "toolCall",
 				id: encodeResponsesToolCallId(item.call_id, item.id),
 				name: item.name,
-				arguments: parseToolCallArguments(item.arguments),
+				// An empty terminal item falls back to what `.delta`/`.done` already delivered.
+				arguments: item.arguments
+					? parseToolCallArguments(item.arguments)
+					: block?.type === "toolCall" && !partial
+						? block.arguments
+						: parseToolCallArguments(partial),
 			};
 			item.arguments = replayableToolCallArguments(item.arguments, toolCall.arguments);
 			if (block?.type === "toolCall") {
@@ -3361,13 +3383,10 @@ export async function prewarmOpenAICodexResponses(
 	if (publicSessionKey && sessionKey) {
 		providerSessionState?.webSocketPublicToPrivate.set(publicSessionKey, sessionKey);
 	}
-	if (!sessionKey || !providerSessionState) return;
-	const state = getCodexWebSocketSessionState(sessionKey, providerSessionState);
+	if (!sessionKey || !transportSessionId || !providerSessionState) return;
+	const state = getCodexWebSocketSessionState(sessionKey, transportSessionId, providerSessionState);
 	if (!shouldUseCodexWebSocket(model, state, options?.preferWebsockets)) return;
-	const metadataSession = getOrCreateCodexMetadataSessionState(
-		transportSessionId ?? crypto.randomUUID(),
-		providerSessionState,
-	);
+	const metadataSession = getOrCreateCodexMetadataSessionState(transportSessionId, providerSessionState);
 	const turnState = getOrCreateCodexTurnState(metadataSession, sessionKey);
 	const codexClientVersion = CODEX_CLIENT_VERSION;
 	const requestIdentity = createCodexCompatibilityIdentity(metadataSession);
@@ -3418,11 +3437,13 @@ function getCodexWebSocketSessionKey(
 
 function getCodexWebSocketSessionState(
 	sessionKey: string,
+	sessionId: string,
 	providerSessionState: CodexProviderSessionState,
 ): CodexWebSocketSessionState {
 	const existing = providerSessionState.webSocketSessions.get(sessionKey);
 	if (existing) return existing;
 	const created: CodexWebSocketSessionState = {
+		sessionId,
 		disableWebsocket: false,
 		canAppend: false,
 		fallbackCount: 0,

package/src/providers/openai-configuration-update.ts

@@ -36,13 +36,16 @@ interface EffortTransition<TEffort extends string> {
 
 /** Per-conversation effort baseline and recorded transitions. */
 export interface OpenAIEffortControlState<TEffort extends string = string> {
+	sessionId: string;
 	baseEffort?: TEffort;
 	currentEffort?: TEffort;
 	transitions: EffortTransition<TEffort>[];
 }
 
-export function createOpenAIEffortControlState<TEffort extends string>(): OpenAIEffortControlState<TEffort> {
-	return { transitions: [] };
+export function createOpenAIEffortControlState<TEffort extends string>(
+	sessionId: string,
+): OpenAIEffortControlState<TEffort> {
+	return { sessionId, transitions: [] };
 }
 
 const MAX_EFFORT_CONTROL_STATES = 16;
@@ -54,6 +57,7 @@ const MAX_EFFORT_CONTROL_STATES = 16;
 export function getOpenAIEffortControlState<TEffort extends string>(
 	states: Map<string, OpenAIEffortControlState<TEffort>>,
 	key: string,
+	sessionId: string,
 ): OpenAIEffortControlState<TEffort> {
 	const existing = states.get(key);
 	if (existing) {
@@ -61,7 +65,7 @@ export function getOpenAIEffortControlState<TEffort extends string>(
 		states.set(key, existing);
 		return existing;
 	}
-	const created = createOpenAIEffortControlState<TEffort>();
+	const created = createOpenAIEffortControlState<TEffort>(sessionId);
 	states.set(key, created);
 	if (states.size > MAX_EFFORT_CONTROL_STATES) {
 		const oldest = states.keys().next().value;
@@ -70,6 +74,16 @@ export function getOpenAIEffortControlState<TEffort extends string>(
 	return created;
 }
 
+/** Release one conversation's effort state from the Responses and Codex `releaseSession` implementations. */
+export function releaseOpenAIEffortControlSession<TEffort extends string>(
+	states: Map<string, OpenAIEffortControlState<TEffort>>,
+	sessionId: string,
+): void {
+	for (const [key, state] of states) {
+		if (state.sessionId === sessionId) states.delete(key);
+	}
+}
+
 interface AnchorableItem {
 	type?: string | null;
 	role?: string;

package/src/providers/openai-responses.ts

@@ -56,6 +56,7 @@ import {
 import { compactGrammarDefinition } from "./grammar";
 import {
 	getOpenAIEffortControlState,
+	releaseOpenAIEffortControlSession,
 	type OpenAIEffortControlState,
 	planStableOpenAIEffort,
 } from "./openai-configuration-update";
@@ -95,6 +96,7 @@ import {
 	getJuiceValue,
 	getOpenAIPromptCacheKey,
 	getOpenAIResponsesRoutingSessionId,
+	normalizeOpenAIPromptCacheKey,
 	getOpenAIStrictToolsScope,
 	getOpenRouterResponsesSessionId,
 	isCompiledGrammarTooLargeStrictError,
@@ -393,7 +395,14 @@ async function* resumeOpenAIResponsesEventStream(
 
 interface OpenAIResponsesProviderSessionState
 	extends ProviderSessionState, OpenAIStrictToolsState, OpenAIReasoningEffortFallbackState {
+	/**
+	 * Replay native history items. Starts false only on connection-bound hosts;
+	 * `close()` clears it so the next request rebuilds history from message
+	 * content; the first successful response sets it.
+	 */
 	nativeHistoryReplayWarmed: boolean;
+	/** Bumped by `close()`; a response warms the state only if no close happened since its request started. */
+	closeCount: number;
 	/** Stateful `previous_response_id` chain baselines, keyed by baseUrl/model/session. */
 	chains: Map<string, OpenAIResponsesChainState>;
 	/** `configuration_update` effort baselines, keyed by baseUrl/model/session. */
@@ -404,6 +413,7 @@ interface OpenAIResponsesProviderSessionState
 type ResponsesStableEffort = Exclude<ReasoningEffort, "none" | null>;
 
 interface OpenAIResponsesChainState {
+	sessionId: string;
 	/**
 	 * Wire params of the last successful turn; never carries
 	 * `previous_response_id`.
@@ -420,17 +430,29 @@ interface OpenAIResponsesChainState {
 	disabled: boolean;
 }
 
-function createOpenAIResponsesProviderSessionState(): OpenAIResponsesProviderSessionState {
+function createOpenAIResponsesProviderSessionState(
+	model: Model<"openai-responses">,
+): OpenAIResponsesProviderSessionState {
 	const strictToolsState = createOpenAIStrictToolsState();
 	const reasoningEffortFallbackState = createOpenAIReasoningEffortFallbackState();
 	const state: OpenAIResponsesProviderSessionState = {
 		...strictToolsState,
 		...reasoningEffortFallbackState,
-		nativeHistoryReplayWarmed: false,
+		nativeHistoryReplayWarmed: !model.compat.connectionBoundNativeHistory,
+		closeCount: 0,
 		chains: new Map(),
 		effortControls: new Map(),
+		releaseSession: sessionId => {
+			const normalizedSessionId = normalizeOpenAIPromptCacheKey(sessionId);
+			if (!normalizedSessionId) return;
+			for (const [key, chain] of state.chains) {
+				if (chain.sessionId === normalizedSessionId) state.chains.delete(key);
+			}
+			releaseOpenAIEffortControlSession(state.effortControls, normalizedSessionId);
+		},
 		close: () => {
 			state.nativeHistoryReplayWarmed = false;
+			state.closeCount++;
 			state.chains.clear();
 			state.effortControls.clear();
 			clearOpenAIStrictToolsState(state);
@@ -448,7 +470,7 @@ function getOpenAIResponsesProviderSessionState(
 	const key = `${OPENAI_RESPONSES_PROVIDER_SESSION_STATE_PREFIX}${model.provider}`;
 	const existing = providerSessionState.get(key) as OpenAIResponsesProviderSessionState | undefined;
 	if (existing) return existing;
-	const created = createOpenAIResponsesProviderSessionState();
+	const created = createOpenAIResponsesProviderSessionState(model);
 	providerSessionState.set(key, created);
 	return created;
 }
@@ -511,7 +533,7 @@ function getOpenAIResponsesChainState(
 	const key = `${resolvedBaseUrl ?? model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`;
 	const existing = providerSessionState.chains.get(key);
 	if (existing) return existing;
-	const created: OpenAIResponsesChainState = { canAppend: false, staleFailures: 0, disabled: false };
+	const created: OpenAIResponsesChainState = { sessionId, canAppend: false, staleFailures: 0, disabled: false };
 	providerSessionState.chains.set(key, created);
 	return created;
 }
@@ -722,6 +744,7 @@ const streamOpenAIResponsesOnce = (
 				});
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
+			const closeCountAtStart = providerSessionState?.closeCount;
 			const strictToolsScope = getOpenAIStrictToolsScope(model, baseUrl);
 			const promptCacheBreakpointPolicy =
 				resolveCacheRetention(options?.cacheRetention) !== "none" && options?.promptCache?.mode === "explicit"
@@ -1239,7 +1262,9 @@ const streamOpenAIResponsesOnce = (
 				{ supportsImageDetailOriginal: model.compat.supportsImageDetailOriginal },
 			);
 			if (replayableResponseItems) {
-				if (providerSessionState) providerSessionState.nativeHistoryReplayWarmed = true;
+				if (providerSessionState && providerSessionState.closeCount === closeCountAtStart) {
+					providerSessionState.nativeHistoryReplayWarmed = true;
+				}
 				if (chainState) {
 					chainState.lastParams = cloneJsonTree(
 						activeTrailingScaffoldingItems > 0 && Array.isArray(activeParams.input)
@@ -1744,6 +1769,7 @@ function applyResponsesStableEffort(
 	const state = getOpenAIEffortControlState(
 		providerSessionState.effortControls,
 		`${model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`,
+		sessionId,
 	);
 	params.reasoning = { ...reasoning, effort: planStableOpenAIEffort(state, input, effort) };
 }

package/src/providers/openai-shared.ts

@@ -3052,7 +3052,8 @@ export function accumulateToolCallArgumentsDelta(
 	contentIndex: number,
 ): void {
 	delta = optionalResponsesText(delta, "function call arguments delta") ?? "";
-	if (!delta) return;
+	// A non-blank `.done` consumed the buffer; a late delta must not reopen it.
+	if (!delta || block[kStreamingPartialJson] === undefined) return;
 	block[kStreamingPartialJson] += delta;
 	const throttled = parseStreamingJsonThrottled(block[kStreamingPartialJson], block[kStreamingLastParseLen] ?? 0);
 	if (throttled) {
@@ -3066,9 +3067,14 @@ export function accumulateToolCallArgumentsDelta(
  * Finalize streamed function-call arguments from the authoritative `.done`
  * payload. The caller owns the `argumentsDone` flag (generic Responses sets it;
  * Codex's block shape has no such field), so this only rewrites `arguments` and
- * drops the transient accumulation fields.
+ * drops the transient accumulation fields. A blank payload is not authoritative:
+ * it parses the buffered deltas and keeps them so the final item can still win.
  */
 export function finalizeToolCallArgumentsDone(block: ResponsesToolCallBlock, args: string): void {
+	if (!args.trim()) {
+		block.arguments = parseToolCallArguments(block[kStreamingPartialJson]);
+		return;
+	}
 	block[kStreamingPartialJson] = args;
 	block.arguments = parseToolCallArguments(block[kStreamingPartialJson]);
 	clearStreamingPartialJson(block);
@@ -3638,11 +3644,13 @@ export async function processResponsesStream<TApi extends Api>(
 				closeOpenItem(event.output_index, item.id, entry);
 			} else if (item.type === "function_call") {
 				const block = entry?.block.type === "toolCall" ? entry.block : undefined;
-				const args = block?.[kStreamingArgumentsDone]
-					? block.arguments
-					: item.arguments
-						? parseToolCallArguments(item.arguments)
-						: parseToolCallArguments(block?.[kStreamingPartialJson]);
+				// A blank `.done` leaves the delta buffer in place, so the item's own arguments still win.
+				const args =
+					block?.[kStreamingArgumentsDone] && block[kStreamingPartialJson] === undefined
+						? block.arguments
+						: item.arguments
+							? parseToolCallArguments(item.arguments)
+							: parseToolCallArguments(block?.[kStreamingPartialJson]);
 				item.arguments = replayableToolCallArguments(item.arguments, args);
 				const toolCall: ToolCall = {
 					type: "toolCall",

package/src/types.ts

@@ -405,6 +405,8 @@ export function coerceServiceTierByFamily(value: unknown): ServiceTierByFamily |
 
 export interface ProviderSessionState {
 	close(): void;
+	/** Release one routing session after its final request, preserving shared provider fallbacks. */
+	releaseSession?(sessionId: string): void;
 }
 
 export interface ProviderResponseMetadata {