@oh-my-pi/pi-ai 18.2.1 → 18.2.2

package/src/auth-storage.ts

@@ -3783,7 +3783,7 @@ export class AuthStorage {
 	ingestUsageHeaders(
 		provider: Provider,
 		headers: Record<string, string>,
-		options?: { sessionId?: string; baseUrl?: string },
+		options?: { sessionId?: string; baseUrl?: string; responseStatus?: number },
 	): boolean {
 		if (this.#fetchUsageReportsOverride) return false;
 		const parseHeaders = this.#resolveUsageProvider(provider)?.parseRateLimitHeaders;
@@ -3796,7 +3796,7 @@ export class AuthStorage {
 			this.#buildUsageRequestForOauth(provider, credential, options?.baseUrl),
 		);
 		const now = Date.now();
-		const parsedReport = parseHeaders(headers, now);
+		const parsedReport = parseHeaders(headers, now, { responseStatus: options?.responseStatus });
 		if (!parsedReport) return false;
 		// Throttled to one ingest per interval — except when a window reads
 		// exhausted: persist that snapshot immediately. A full-backed cache can

package/src/index.ts

@@ -8,6 +8,7 @@ export * from "./auth-storage";
 export * from "./error/rate-limit";
 export * from "./oneshot-retry";
 export * from "./provider-details";
+export * from "./provider-session-state";
 export * from "./providers/anthropic";
 export * from "./providers/anthropic-client";
 export * from "./providers/azure-openai-responses";

package/src/provider-session-state.ts

@@ -0,0 +1,56 @@
+/**
+ * Credential-rotation handling for a retained `providerSessionState` map.
+ *
+ * A host that keeps one provider-session map per logical conversation (the
+ * auth-gateway's server-owned store, an in-process omp session) can outlive the
+ * credential that filled it: `AuthStorage.markUsageLimitReached` and the
+ * auth-retry resolver both switch a session to a sibling account mid-flight.
+ * Most of what a provider learns is a property of the *endpoint*, so rebuilding
+ * the whole map on a switch would re-pay every rejected round-trip the map
+ * exists to avoid. A minority is a property of the *account*, and keeping that
+ * across a switch is a bug.
+ *
+ * Audit of what the retained records hold, per provider:
+ *
+ * - **Anthropic** — `fastModeDisabled` is account-scoped: the rejection reads
+ *   "this model does not support fast mode for your account", i.e. a plan
+ *   entitlement, so a switch to an entitled sibling must re-probe. Its
+ *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
+ *   (grammar-too-large 400 for the model's tool schema),
+ *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks the API itself
+ *   dropped), `controlStates` (per-conversation control baselines).
+ * - **OpenAI Responses** — the `previous_response_id` chain baselines are
+ *   account-scoped: a stored response belongs to the account that created it.
+ *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining
+ *   circuit breaker are endpoint-scoped and stay.
+ * - **OpenAI Completions** — strict-tools and reasoning-effort fallbacks only;
+ *   both endpoint-scoped. Nothing to reset.
+ * - **Codex** — already sub-keys its WebSocket sessions by account id AND
+ *   bearer (`getCodexWebSocketSessionKey`), so a switch naturally lands on a
+ *   fresh transport session while the old one stays reachable for teardown.
+ *   Resetting from the outside would close a socket a retry may still be on.
+ * - **Antigravity** — `lastGoodEndpoint` is endpoint-scoped; the agent /
+ *   conversation ids are conversation-scoped. Neither depends on the account.
+ * - **GitLab Duo** — the active workflow is account-bound, but it is a live
+ *   server-side workflow plus socket, and the switch happens *inside* the
+ *   request that may still be resuming it. Tearing it down here would abort the
+ *   very turn that rotated; it stays on its existing session-close path.
+ */
+
+import { clearAnthropicFastModeFallback } from "./providers/anthropic";
+import { resetOpenAIResponsesAccountScopedState } from "./providers/openai-responses";
+import type { ProviderSessionState } from "./types";
+
+/**
+ * Reset the account-dependent lessons in `states`, keeping everything a
+ * provider learned about the endpoint. Call when a retained map is about to be
+ * reused for a session whose credential now resolves to a different account.
+ */
+export function resetAccountScopedProviderSessionState(states: Map<string, ProviderSessionState>): void {
+	if (states.size === 0) return;
+	// Fast mode is the account-scoped half of the Anthropic record; the helper
+	// the `/fast on` re-arm path already uses clears exactly that flag.
+	clearAnthropicFastModeFallback(states);
+	resetOpenAIResponsesAccountScopedState(states);
+}

package/src/providers/amazon-bedrock.ts

@@ -5,6 +5,9 @@
  * SigV4 signing and decodes the `application/vnd.amazon.eventstream` response.
  * No `@aws-sdk/*`, no `@smithy/*`, no `proxy-agent`. Proxies are honored via
  * Bun's native `HTTPS_PROXY` support.
+ *
+ * A `models.yml` `baseUrl` is the request origin verbatim (VPC endpoint, gateway, …);
+ * only AWS's own regional host is re-pointed at the resolved region. SigV4 unaffected.
  */
 
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
@@ -145,6 +148,13 @@ const INFERENCE_PROFILE_GEO_DEFAULT_REGION: Record<string, string> = {
 	jp: "ap-northeast-1",
 };
 
+/**
+ * AWS's own regional host, which every bundled catalog entry carries as a required
+ * placeholder `baseUrl` — no routing info, so its region segment is re-derived.
+ * FIPS, VPC-endpoint and gateway hosts don't match and are used as configured.
+ */
+const AWS_REGIONAL_BEDROCK_HOST = /^bedrock-runtime\.[a-z0-9-]+\.amazonaws\.com$/;
+
 /** Geo prefix of a cross-region inference-profile id, e.g. `eu.anthropic.…` → `eu`. */
 function inferenceProfileGeo(modelId: string): string | undefined {
 	const dot = modelId.indexOf(".");
@@ -453,9 +463,15 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 			// raw dump so the inspector shows exactly what was sent.
 			commandInput = { ...commandInput, requestMetadata: sanitizeRequestMetadata(commandInput.requestMetadata) };
 
-			const host = `bedrock-runtime.${region}.amazonaws.com`;
-			const url = `https://${host}/model/${encodeURIComponent(model.id)}/converse-stream`;
-			const urlPath = `/model/${encodeURIComponent(model.id)}/converse-stream`;
+			// `baseUrl` is the origin verbatim, path prefix (and query, for gateways
+			// that authenticate via a query parameter) included, so a gateway mounted
+			// under a path works. AWS's own host is re-pointed: the catalog can't know the region.
+			const base = new URL(model.baseUrl || `https://bedrock-runtime.${region}.amazonaws.com`);
+			if (AWS_REGIONAL_BEDROCK_HOST.test(base.host)) base.host = `bedrock-runtime.${region}.amazonaws.com`;
+			const host = base.host;
+			const urlPath = `${base.pathname.replace(/\/+$/, "")}/model/${encodeURIComponent(model.id)}/converse-stream`;
+			const query = base.search.slice(1) || undefined;
+			const url = `${base.origin}${urlPath}${base.search}`;
 			rawRequestDump = {
 				provider: model.provider,
 				api: output.api,
@@ -527,6 +543,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 					method: "POST",
 					host,
 					path: urlPath,
+					query,
 					body,
 					region,
 					service: "bedrock",

package/src/providers/anthropic-messages-server.ts

@@ -19,6 +19,7 @@ import type {
 	ToolResultMessage,
 	UserMessage,
 } from "../types";
+import { isCursorExecResolved } from "../utils/block-symbols";
 import {
 	type AnthropicAssistantContentBlock,
 	type AnthropicMessage,
@@ -505,14 +506,33 @@ function randomFallback(): string {
 	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
-function mapStopReasonOut(reason: StopReason): "end_turn" | "max_tokens" | "tool_use" {
+/**
+ * True for a `toolCall` block the client is expected to execute.
+ *
+ * Cursor's exec channel stamps {@link kCursorExecResolved} on calls it already
+ * ran server-side — `todo`, `web_fetch`, `connect_scm`, a native it declined —
+ * and those are not handoffs: the client never declared the tool, has no
+ * implementation to run, and repeating one would reapply a side effect the
+ * server already committed. Only unresolved calls are real external handoffs.
+ */
+function isClientToolUse(content: AssistantMessage["content"][number]): content is ToolCall {
+	return content.type === "toolCall" && !isCursorExecResolved(content);
+}
+
+function mapStopReasonOut(reason: StopReason, hasToolUse: boolean): "end_turn" | "max_tokens" | "tool_use" {
 	switch (reason) {
 		case "length":
 			return "max_tokens";
 		case "toolUse":
 			return "tool_use";
 		default:
-			return "end_turn";
+			// A provider whose protocol has no separate tool-use stop — Cursor
+			// ends the turn with `stop` when it hands a client-declared tool
+			// back for the caller to execute — still owes the client
+			// `tool_use`, or the canonical Anthropic loop (run tools while
+			// `stop_reason === "tool_use"`) never runs the tool it asked for.
+			// The OpenAI chat wire maps the same case to `tool_calls`.
+			return hasToolUse ? "tool_use" : "end_turn";
 	}
 }
 
@@ -536,6 +556,9 @@ function encodeContentBlocks(message: AssistantMessage): Record<string, unknown>
 				blocks.push(c.block);
 				break;
 			case "toolCall":
+				// Cursor already executed this one; the client must not run it
+				// again and cannot answer it. See `isClientToolUse`.
+				if (!isClientToolUse(c)) break;
 				blocks.push({ type: "tool_use", id: c.id, name: c.name, input: c.arguments ?? {} });
 				break;
 		}
@@ -568,7 +591,7 @@ export function encodeResponse(message: AssistantMessage, requestedModelId: stri
 		role: "assistant",
 		model: requestedModelId,
 		content: encodeContentBlocks(message),
-		stop_reason: mapStopReasonOut(message.stopReason),
+		stop_reason: mapStopReasonOut(message.stopReason, message.content.some(isClientToolUse)),
 		// TODO: surface the matched stop sequence once pi-ai's
 		// `AssistantMessage.stopReason` carries the matched string. Intentionally
 		// `null` for now (Anthropic schema allows it).
@@ -633,6 +656,23 @@ export function encodeStream(
 			const messageId = newMessageId();
 			let started = false;
 			const open = new Map<number, OpenBlock>();
+			// Cursor's exec channel hands back calls it already ran server-side;
+			// `isClientToolUse` keeps them off the wire. Anthropic clients (the
+			// official SDK included) append every `content_block_start` to their
+			// snapshot and then address deltas by `index`, so a hole in the
+			// numbering misroutes each later delta. Shift emitted indices down by
+			// the number of blocks suppressed before them — identity while
+			// nothing is suppressed. A suppressed call always closes the
+			// preceding text/thinking block before it opens, so no block that is
+			// still open is ever renumbered.
+			const suppressed = new Set<number>();
+			const wireIndex = (contentIndex: number): number => {
+				let shift = 0;
+				for (const index of suppressed) {
+					if (index < contentIndex) shift++;
+				}
+				return contentIndex - shift;
+			};
 
 			const ensureStart = (partial: AssistantMessage | undefined) => {
 				if (started) return;
@@ -663,10 +703,11 @@ export function encodeStream(
 			const emitServerToolBlocksBefore = (message: AssistantMessage, beforeIndex: number) => {
 				const limit = Math.min(beforeIndex, message.content.length);
 				while (nextContentIndexToInspect < limit) {
-					const index = nextContentIndexToInspect++;
-					const content = message.content[index];
+					const contentIndex = nextContentIndexToInspect++;
+					const content = message.content[contentIndex];
 					if (content?.type !== "anthropicServerTool") continue;
 					ensureStart(message);
+					const index = wireIndex(contentIndex);
 					controller.enqueue(
 						sseFrame("content_block_start", {
 							type: "content_block_start",
@@ -678,10 +719,11 @@ export function encodeStream(
 				}
 			};
 
-			const closeBlock = (index: number) => {
-				if (!open.has(index)) return;
-				controller.enqueue(sseFrame("content_block_stop", { type: "content_block_stop", index }));
-				open.delete(index);
+			const closeBlock = (contentIndex: number) => {
+				const block = open.get(contentIndex);
+				if (!block) return;
+				controller.enqueue(sseFrame("content_block_stop", { type: "content_block_stop", index: block.index }));
+				open.delete(contentIndex);
 			};
 
 			pingTimer = setInterval(() => {
@@ -711,11 +753,12 @@ export function encodeStream(
 						case "text_start": {
 							emitServerToolBlocksBefore(ev.partial, ev.contentIndex);
 							ensureStart(ev.partial);
-							open.set(ev.contentIndex, { index: ev.contentIndex, kind: "text" });
+							const index = wireIndex(ev.contentIndex);
+							open.set(ev.contentIndex, { index, kind: "text" });
 							controller.enqueue(
 								sseFrame("content_block_start", {
 									type: "content_block_start",
-									index: ev.contentIndex,
+									index,
 									content_block: { type: "text", text: "" },
 								}),
 							);
@@ -725,7 +768,7 @@ export function encodeStream(
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
-									index: ev.contentIndex,
+									index: wireIndex(ev.contentIndex),
 									delta: { type: "text_delta", text: ev.delta },
 								}),
 							);
@@ -736,11 +779,12 @@ export function encodeStream(
 						case "thinking_start": {
 							emitServerToolBlocksBefore(ev.partial, ev.contentIndex);
 							ensureStart(ev.partial);
-							open.set(ev.contentIndex, { index: ev.contentIndex, kind: "thinking" });
+							const index = wireIndex(ev.contentIndex);
+							open.set(ev.contentIndex, { index, kind: "thinking" });
 							controller.enqueue(
 								sseFrame("content_block_start", {
 									type: "content_block_start",
-									index: ev.contentIndex,
+									index,
 									content_block: { type: "thinking", thinking: "" },
 								}),
 							);
@@ -750,7 +794,7 @@ export function encodeStream(
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
-									index: ev.contentIndex,
+									index: wireIndex(ev.contentIndex),
 									delta: { type: "thinking_delta", thinking: ev.delta },
 								}),
 							);
@@ -761,7 +805,7 @@ export function encodeStream(
 								controller.enqueue(
 									sseFrame("content_block_delta", {
 										type: "content_block_delta",
-										index: ev.contentIndex,
+										index: wireIndex(ev.contentIndex),
 										delta: { type: "signature_delta", signature: c.thinkingSignature },
 									}),
 								);
@@ -773,11 +817,21 @@ export function encodeStream(
 							emitServerToolBlocksBefore(ev.partial, ev.contentIndex);
 							ensureStart(ev.partial);
 							const tc = ev.partial.content[ev.contentIndex] as ToolCall | undefined;
-							open.set(ev.contentIndex, { index: ev.contentIndex, kind: "tool_use" });
+							if (tc && !isClientToolUse(tc)) {
+								// Cursor's exec channel already ran this call and
+								// buffered its result. Streaming it would invite the
+								// client to repeat a committed side effect and answer
+								// a tool it never declared, so drop the whole block —
+								// start, deltas and stop — from the wire.
+								suppressed.add(ev.contentIndex);
+								break;
+							}
+							const index = wireIndex(ev.contentIndex);
+							open.set(ev.contentIndex, { index, kind: "tool_use" });
 							controller.enqueue(
 								sseFrame("content_block_start", {
 									type: "content_block_start",
-									index: ev.contentIndex,
+									index,
 									content_block: {
 										type: "tool_use",
 										id: tc?.id ?? "",
@@ -789,10 +843,11 @@ export function encodeStream(
 							break;
 						}
 						case "toolcall_delta":
+							if (suppressed.has(ev.contentIndex)) break;
 							controller.enqueue(
 								sseFrame("content_block_delta", {
 									type: "content_block_delta",
-									index: ev.contentIndex,
+									index: wireIndex(ev.contentIndex),
 									delta: { type: "input_json_delta", partial_json: ev.delta },
 								}),
 							);
@@ -809,7 +864,12 @@ export function encodeStream(
 									// TODO: surface matched stop sequence once pi-ai
 									// propagates it on the `done` event.
 									delta: {
-										stop_reason: mapStopReasonOut(ev.reason),
+										// A call Cursor resolved after it opened (an MCP
+										// frame answered by a local handler) already
+										// streamed; the client still must not be told to
+										// run it, so it does not terminate the turn with
+										// `tool_use` either.
+										stop_reason: mapStopReasonOut(ev.reason, ev.message.content.some(isClientToolUse)),
 										stop_sequence: null,
 									},
 									...(bindingControlsRequested

package/src/providers/anthropic-signature.ts

@@ -17,7 +17,7 @@ const HEADER_MODEL_FIELD = 6;
 const MAX_MODEL_ID_LENGTH = 128;
 const MODEL_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
 
-/** Returns the first length-delimited field `field` in `message`, or undefined. */
+/** Finds a length-delimited field, rejecting tags and lengths that exceed uint32. */
 function lengthDelimitedField(message: Uint8Array, field: number): Uint8Array | undefined {
 	let offset = 0;
 	while (offset < message.length) {
@@ -27,6 +27,7 @@ function lengthDelimitedField(message: Uint8Array, field: number): Uint8Array |
 		do {
 			if (offset >= message.length) return undefined;
 			byte = message[offset++];
+			if (shift === 28 && byte > 0x0f) return undefined;
 			tag |= (byte & 0x7f) << shift;
 			shift += 7;
 		} while (byte & 0x80);
@@ -49,10 +50,12 @@ function lengthDelimitedField(message: Uint8Array, field: number): Uint8Array |
 				do {
 					if (offset >= message.length) return undefined;
 					byte = message[offset++];
+					if (shift === 28 && byte > 0x0f) return undefined;
 					length |= (byte & 0x7f) << shift;
 					shift += 7;
 				} while (byte & 0x80);
-				if (offset + length > message.length) return undefined;
+				length >>>= 0;
+				if (length > message.length - offset) return undefined;
 				if (fieldNumber === field) return message.subarray(offset, offset + length);
 				offset += length;
 				break;

package/src/providers/aws-sigv4.ts

@@ -137,18 +137,29 @@ function encodeRfc3986(str: string): string {
 	return encodeURIComponent(str).replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
 }
 
-function canonicalQuery(query: string | undefined): string {
+/**
+ * AWS's canonical-request spec encodes each name/value first, THEN sorts by
+ * the encoded form ("Sort the encoded parameter names by character code" —
+ * https://docs.aws.amazon.com/IAM/latest/UserGuide/create-canonical-request.html).
+ * Sorting the decoded form instead gives the wrong order whenever encoding
+ * changes a character's relative position — e.g. raw key `%7B` (decodes to
+ * `{`, 0x7B) vs `x` (0x78): decoded, `x` < `{`; encoded, `%` (0x25) < `x`, so
+ * `%7B` sorts first. A gateway that validates SigV4 (or AWS itself) computes
+ * the signature over ITS OWN canonicalization and rejects ours if the two
+ * disagree on order.
+ */
+export function canonicalQuery(query: string | undefined): string {
 	if (!query) return "";
 	const pairs: Array<[string, string]> = [];
 	for (const part of query.split("&")) {
 		if (!part) continue;
 		const eq = part.indexOf("=");
-		const k = eq === -1 ? part : part.slice(0, eq);
-		const v = eq === -1 ? "" : part.slice(eq + 1);
-		pairs.push([decodeURIComponent(k), decodeURIComponent(v)]);
+		const rawKey = eq === -1 ? part : part.slice(0, eq);
+		const rawValue = eq === -1 ? "" : part.slice(eq + 1);
+		pairs.push([encodeRfc3986(decodeURIComponent(rawKey)), encodeRfc3986(decodeURIComponent(rawValue))]);
 	}
 	pairs.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : a[1] > b[1] ? 1 : 0));
-	return pairs.map(([k, v]) => `${encodeRfc3986(k)}=${encodeRfc3986(v)}`).join("&");
+	return pairs.map(([k, v]) => `${k}=${v}`).join("&");
 }
 
 export interface SignedHeaders {

package/src/providers/cursor.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import http2 from "node:http2";
+import { isCursorMaxModeWireId } from "@oh-my-pi/pi-catalog/compat/collapse";
 import { classifyModel, collapseVariantId } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import type {
 	ConversationStep,
@@ -5234,6 +5235,46 @@ function extractImages(content: (TextContent | ImageContent)[]) {
 		);
 }
 
+/**
+ * Resolve `max_mode` for the wire id a request actually routes to.
+ *
+ * `GetUsableModels` marks max-mode models per raw row and discovery copies that
+ * onto `cursorMaxMode`, so on a row that puts its own id on the wire the marker
+ * is the authority — Cursor serves the whole Opus `-fast` lane in max mode
+ * (`claude-opus-4-8-high-fast` included) and leaves reasoning tiers such as
+ * `claude-4.6-opus-max` out of it, neither of which the wire slug can tell.
+ *
+ * Collapsing a family ORs the members' markers onto the logical row, so there
+ * `cursorMaxMode: true` only means *some* tier needs max mode; sending it for
+ * every tier is the refused `-low` request of issue #9478. The members' own
+ * markers survive per wire id in `cursorMaxModeRoutes`, so the routed id is
+ * looked up there first.
+ *
+ * A row's own wire id still owns its marker even when it has effort routing
+ * (for example a bare/thinking pair). Logical-only bundled rows and routes
+ * discovery never advertised have no per-id marker; only those use the suffix.
+ * A collapsed row whose `true` no route's suffix can explain keeps it for every
+ * route: the marker came from a member the suffix rule cannot see.
+ */
+function resolveCursorMaxMode(model: Model<"cursor-agent">, wireModelId: string): boolean {
+	const discovered = model.cursorMaxModeRoutes?.[wireModelId];
+	if (discovered !== undefined) return discovered;
+	const routing = model.thinking?.effortRouting;
+	if (routing === undefined || wireModelId === model.id) {
+		return model.cursorMaxMode ?? isCursorMaxModeWireId(wireModelId);
+	}
+	let routesOwnId = routing.off === model.id;
+	let hasInferredMaxRoute = typeof routing.off === "string" && isCursorMaxModeWireId(routing.off);
+	for (const effort of THINKING_EFFORTS) {
+		const target = routing[effort];
+		if (target === model.id) routesOwnId = true;
+		if (typeof target === "string" && isCursorMaxModeWireId(target)) hasInferredMaxRoute = true;
+	}
+	if (routesOwnId) return model.cursorMaxMode ?? isCursorMaxModeWireId(wireModelId);
+	if (model.cursorMaxMode === true && !hasInferredMaxRoute) return true;
+	return isCursorMaxModeWireId(wireModelId);
+}
+
 /**
  * Resolve the Cursor Run wire model id and its parameter list.
  *
@@ -5261,9 +5302,11 @@ function resolveCursorWireModel(
 ): {
 	modelId: string;
 	parameters: RequestedModel_ModelParameterbytes[];
+	maxMode: boolean;
 } {
 	const wireModelId = requestModelId ?? model.requestModelId ?? model.id;
-	if (wireMode === "discovered") return { modelId: wireModelId, parameters: [] };
+	const maxMode = resolveCursorMaxMode(model, wireModelId);
+	if (wireMode === "discovered") return { modelId: wireModelId, parameters: [], maxMode };
 	// `collapseVariantId` keeps the lane in the logical id (`-high-fast` →
 	// base `-fast`) and decodes the KDL effort (`-none` → `off`).
 	const collapsed = collapseVariantId("cursor", wireModelId);
@@ -5271,11 +5314,12 @@ function resolveCursorWireModel(
 	const base = effort !== undefined ? collapsed.logicalId : undefined;
 	if (effort !== undefined && base && classifyModel("cursor", base).class === "openai") {
 		if (effort === "off") {
-			return { modelId: base, parameters: [] };
+			return { modelId: base, parameters: [], maxMode };
 		}
 		if ((THINKING_EFFORTS as readonly string[]).includes(effort)) {
 			return {
 				modelId: base,
+				maxMode,
 				parameters: [
 					create(RequestedModel_ModelParameterbytesSchema, { id: "reasoning", value: collapsed.effort }),
 				],
@@ -5289,9 +5333,10 @@ function resolveCursorWireModel(
 		return {
 			modelId: wireModelId,
 			parameters: [create(RequestedModel_ModelParameterbytesSchema, { id: "fast", value: "false" })],
+			maxMode,
 		};
 	}
-	return { modelId: wireModelId, parameters: [] };
+	return { modelId: wireModelId, parameters: [], maxMode };
 }
 
 async function buildGrpcRequestForWireMode(
@@ -5401,12 +5446,11 @@ async function buildGrpcRequestForWireMode(
 		turns,
 	});
 
-	const { modelId: wireModelId, parameters: wireParameters } = resolveCursorWireModel(
-		model,
-		options?.wireModelId,
-		wireMode,
-	);
-	const cursorMaxMode = model.cursorMaxMode === true;
+	const {
+		modelId: wireModelId,
+		parameters: wireParameters,
+		maxMode: cursorMaxMode,
+	} = resolveCursorWireModel(model, options?.wireModelId, wireMode);
 	const modelDetails = create(ModelDetailsSchema, {
 		modelId: wireModelId,
 		displayModelId: model.id,

package/src/providers/openai-completions.ts

@@ -1277,6 +1277,12 @@ const streamOpenAICompletionsOnce = (
 
 					if (choice?.delta?.tool_calls && choice.delta.tool_calls.length > 0) {
 						const toolCalls = choice.delta.tool_calls;
+						// Pure tool-call responses never emit a text/thinking delta, so
+						// without this stamp TTFT stays undefined for every turn that
+						// begins with a structured call (measured: all toolUse-stop
+						// rows on OpenAI-compatible gateways) and the usage row's
+						// TTFT/tok/s figures silently degrade.
+						if (!firstTokenTime) firstTokenTime = performance.now();
 						for (let toolCallOffset = 0; toolCallOffset < toolCalls.length; toolCallOffset++) {
 							const toolCall = toolCalls[toolCallOffset]!;
 							const streamIndex = typeof toolCall.index === "number" ? toolCall.index : undefined;

package/src/providers/openai-responses.ts

@@ -295,6 +295,33 @@ function resetOpenAIResponsesChainState(state: OpenAIResponsesChainState): void
 	state.lastPromptCacheBreakpointPolicy = undefined;
 }
 
+/**
+ * Drop the account-bound half of every retained `openai-responses` record in
+ * `states`: the stateful `previous_response_id` chain baselines.
+ *
+ * Chaining stores the turn server-side under the account that created it, so a
+ * baseline minted by one credential is dead weight the moment the session is
+ * switched to a sibling account — the next delta request answers
+ * `Previous response not found` and burns a turn re-learning that. Everything
+ * else this record holds describes the *deployment*, not the account
+ * (strict-tools demotion, reasoning-effort fallback, native-history-replay
+ * warmup, the chaining circuit breaker), and is deliberately preserved:
+ * re-learning an endpoint's limits on every credential switch is the cost this
+ * state exists to avoid.
+ */
+export function resetOpenAIResponsesAccountScopedState(states: Map<string, ProviderSessionState>): void {
+	for (const [key, value] of states) {
+		if (!key.startsWith(OPENAI_RESPONSES_PROVIDER_SESSION_STATE_PREFIX)) continue;
+		const state = value as OpenAIResponsesProviderSessionState;
+		for (const chain of state.chains.values()) {
+			resetOpenAIResponsesChainState(chain);
+			// The stale-failure counter tallies the previous account's 404s; a
+			// fresh account must not inherit a tripped circuit breaker.
+			chain.staleFailures = 0;
+		}
+	}
+}
+
 interface OpenAIResponsesChainedParams {
 	params: OpenAIResponsesSamplingParams;
 	/** Set iff the params carry previous_response_id (delta request). */