@oh-my-pi/pi-ai 18.4.2 → 18.4.4

package/src/providers/anthropic.ts

@@ -155,6 +155,7 @@ import {
 	resolveAnthropicMetadataUserId,
 	stripClaudeToolPrefix,
 } from "./anthropic-identity";
+import { fitBedrockAnthropicPayload } from "./bedrock-anthropic";
 import {
 	anthropicProviderSessionStateKey,
 	clearAnthropicFastModeFallback,
@@ -2264,6 +2265,8 @@ const streamAnthropicOnce = (
 					nextParams = replacementPayload as typeof nextParams;
 				}
 				if (nextParams.compaction) stripCompactionIncompatibleParams(nextParams);
+				// After `onPayload`, so a hook cannot restore a field Bedrock rejects.
+				if (model.compat.bedrockMessagesApi) fitBedrockAnthropicPayload(nextParams);
 				nextParams = toWellFormedDeep(nextParams) as typeof nextParams;
 				rawRequestDump = {
 					provider: model.provider,
@@ -3827,22 +3830,17 @@ function ensureMaxTokensForThinking(params: MessageCreateParamsStreaming, maxAll
 	const budgetTokens = thinking.budget_tokens ?? 0;
 	if (budgetTokens <= 0) return;
 
-	const currentMaxTokens = Math.min(params.max_tokens ?? maxAllowedTokens, maxAllowedTokens);
-	const raisedMaxTokens = Math.min(
-		Math.max(currentMaxTokens, budgetTokens + OUTPUT_FALLBACK_BUFFER),
-		maxAllowedTokens,
-	);
-	params.max_tokens = raisedMaxTokens;
+	const output = budgetThinkingOutput(params.max_tokens, budgetTokens, maxAllowedTokens);
+	params.max_tokens = output.maxTokens;
 
-	if (budgetTokens + OUTPUT_FALLBACK_BUFFER <= raisedMaxTokens) return;
+	if (output.budgetTokens === budgetTokens) return;
 
-	const clampedBudget = raisedMaxTokens - OUTPUT_FALLBACK_BUFFER;
-	if (clampedBudget <= 0) {
+	if (output.budgetTokens <= 0) {
 		throw new AIError.ConfigurationError(
-			`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${raisedMaxTokens}`,
+			`Anthropic thinking budget requires max_tokens greater than ${OUTPUT_FALLBACK_BUFFER}; got ${output.maxTokens}`,
 		);
 	}
-	thinking.budget_tokens = clampedBudget;
+	thinking.budget_tokens = output.budgetTokens;
 }
 
 function applyCacheControlToLastBlock(blocks: ContentBlockParam[], cacheControl: AnthropicCacheControl): boolean {
@@ -4128,6 +4126,41 @@ function usesAdaptiveThinkingTagOnly(model: Model<"anthropic-messages">): boolea
 	return thinking.efforts.length > 0;
 }
 
+/**
+ * True when enabled thinking on `model` is budget thinking
+ * (`thinking.type: "enabled"` with `budget_tokens`) rather than adaptive.
+ */
+export function usesBudgetThinking(model: Model<"anthropic-messages">): boolean {
+	return model.thinking?.mode !== "anthropic-adaptive" || model.compat.disableAdaptiveThinking === true;
+}
+
+/** The most output tokens a request to `model` may ask for (`max_tokens` ceiling). */
+export function anthropicOutputLimit(model: Model<"anthropic-messages">): number {
+	return model.maxTokens ?? UNKNOWN_MODEL_MAX_OUTPUT_TOKENS;
+}
+
+/**
+ * The `max_tokens` and thinking budget of budget thinking: `max_tokens`
+ * rises to leave {@link OUTPUT_FALLBACK_BUFFER} visible output tokens after
+ * the budget, within `maxAllowedTokens`, and the budget shrinks when that
+ * ceiling leaves less (a non-positive budget means the ceiling is too low).
+ */
+export function budgetThinkingOutput(
+	maxTokens: number | undefined,
+	budgetTokens: number,
+	maxAllowedTokens: number,
+): { maxTokens: number; budgetTokens: number } {
+	const currentMaxTokens = Math.min(maxTokens ?? maxAllowedTokens, maxAllowedTokens);
+	const raisedMaxTokens = Math.min(
+		Math.max(currentMaxTokens, budgetTokens + OUTPUT_FALLBACK_BUFFER),
+		maxAllowedTokens,
+	);
+	return {
+		maxTokens: raisedMaxTokens,
+		budgetTokens: Math.min(budgetTokens, raisedMaxTokens - OUTPUT_FALLBACK_BUFFER),
+	};
+}
+
 /**
  * True for adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5)
  * that reject `thinking.type: "disabled"`. Turning thinking off on these models
@@ -4550,8 +4583,7 @@ function buildParams(
 			const thinkingOptions = options ?? {};
 			const mode = model.thinking?.mode;
 			const effort = resolveAnthropicAdaptiveEffort(model, thinkingOptions);
-			const compat = model.compat;
-			if (mode === "anthropic-adaptive" && !compat.disableAdaptiveThinking) {
+			if (!usesBudgetThinking(model)) {
 				const adaptive: { type: "adaptive"; display?: AnthropicThinkingDisplay } = { type: "adaptive" };
 				// Starting with Claude Opus 4.7 and Claude Fable/Mythos 5, adaptive thinking
 				// content is omitted from the response by default. Opt into summarized
@@ -4573,7 +4605,12 @@ function buildParams(
 				if (mode === "anthropic-budget-effort" && effort && effort !== "adaptive") outputConfigEffort = effort;
 			}
 		} else if (options?.thinkingEnabled === false) {
-			if (isAdaptiveOnlyThinking(model)) {
+			if (model.compat.supportsBetweenToolsThinking) {
+				// Sonnet 5.5 rejects `disabled` with a 400; `between_tools` is its lowest
+				// thinking setting. It takes no other field and leaves effort untouched:
+				// pinning `low` here would cap the whole turn's quality, not only thinking.
+				thinking = { type: "between_tools" };
+			} else if (isAdaptiveOnlyThinking(model)) {
 				// Adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) reject
 				// `thinking.type: "disabled"` — adaptive thinking cannot be switched off.
 				// Omit the thinking field (the API defaults to adaptive) and pin the
@@ -4643,6 +4680,12 @@ function buildParams(
 		model.compat.supportsPerMessageEffort === true,
 		compactionReplay,
 	);
+	// `between_tools` returns a 400 at `xhigh`/`max` effort, and the effort in
+	// force from earlier turns outlives a thinking toggle. Fall back to the
+	// default adaptive request, which accepts every effort level.
+	if (thinking?.type === "between_tools" && (effortPlan.topLevel === "xhigh" || effortPlan.topLevel === "max")) {
+		thinking = undefined;
+	}
 	const wireMessages = convertAnthropicMessages(
 		insertAnthropicControlMarkers(context.messages, [...toolPlan.inserts, ...effortPlan.inserts]),
 		effectiveModel,
@@ -4683,7 +4726,7 @@ function buildParams(
 
 	// OAuth and API-key requests alike get the full model ceiling; Claude Code
 	// itself requests 128k on Opus 5.5.
-	const maxOutputTokens = model.maxTokens ?? UNKNOWN_MODEL_MAX_OUTPUT_TOKENS;
+	const maxOutputTokens = anthropicOutputLimit(model);
 
 	// A caller-owned client targets its own endpoint: route body betas by the
 	// client's URL when it exposes one, not the model's routing. Otherwise the

package/src/providers/aws-eventstream.ts

@@ -24,6 +24,8 @@ const PRELUDE_CRC_LEN = 4;
 const MESSAGE_CRC_LEN = 4;
 const HEADER_BLOCK_OFFSET = PRELUDE_LEN + PRELUDE_CRC_LEN;
 const MIN_MESSAGE_LEN = HEADER_BLOCK_OFFSET + MESSAGE_CRC_LEN;
+/** Shared across messages: every header decode is a complete, non-streaming call. */
+const HEADER_DECODER = new TextDecoder();
 
 export interface EventStreamMessage {
 	/** Lower-cased copy is *not* applied — Bedrock uses casing like `:event-type` verbatim. */
@@ -64,12 +66,11 @@ export function decodeMessage(frame: Uint8Array): EventStreamMessage {
 function parseHeaders(buf: Uint8Array): Record<string, string> {
 	const out: Record<string, string> = {};
 	const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-	const decoder = new TextDecoder();
 	let p = 0;
 	while (p < buf.length) {
 		const nameLen = view.getUint8(p);
 		p += 1;
-		const name = decoder.decode(buf.subarray(p, p + nameLen));
+		const name = HEADER_DECODER.decode(buf.subarray(p, p + nameLen));
 		p += nameLen;
 		const type = view.getUint8(p);
 		p += 1;
@@ -108,7 +109,7 @@ function parseHeaders(buf: Uint8Array): Record<string, string> {
 				// string
 				const len = view.getUint16(p, false);
 				p += 2;
-				out[name] = decoder.decode(buf.subarray(p, p + len));
+				out[name] = HEADER_DECODER.decode(buf.subarray(p, p + len));
 				p += len;
 				break;
 			}

package/src/providers/aws-sigv4.ts

@@ -61,7 +61,7 @@ const UNSIGNABLE: Record<string, true> = {
  * `ArrayBuffer`, which is what `crypto.subtle.{digest,sign,importKey}` requires
  * under the strict TS DOM typings. No-op when already strict.
  */
-function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
+export function asStrict(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
 	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
 		return bytes as Uint8Array<ArrayBuffer>;
 	}

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

@@ -1,11 +1,10 @@
-import { $env } from "@oh-my-pi/pi-utils";
+import { $env, type ServerSentEvent } from "@oh-my-pi/pi-utils";
 import * as AIError from "../error";
 import { getEnvApiKey } from "../stream";
 import type {
 	AssistantMessage,
 	Context,
 	Model,
-	RawSseEvent,
 	ServiceTier,
 	StreamFunction,
 	StreamOptions,
@@ -104,7 +103,7 @@ const streamAzureOpenAIResponsesOnce = (
 		const { requestAbortController, requestSignal } = abortTracker;
 		const onSseEvent = options?.onSseEvent;
 		const rawSseObserver = onSseEvent
-			? (event: RawSseEvent) => {
+			? (event: ServerSentEvent) => {
 					if (!event.event && event.data && event.data !== "[DONE]") {
 						try {
 							const parsed = JSON.parse(event.data);
@@ -120,7 +119,7 @@ const streamAzureOpenAIResponsesOnce = (
 							}
 						} catch {}
 					}
-					onSseEvent(event, model);
+					onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model);
 				}
 			: undefined;
 

package/src/providers/bedrock-anthropic.ts

@@ -0,0 +1,30 @@
+import { isRecord } from "@oh-my-pi/pi-utils";
+import { extractClaudeMetadataSessionId } from "./anthropic-identity";
+import { isBedrockRequestMetadataValue } from "./bedrock-request-metadata";
+
+/**
+ * Fit an Anthropic request body to Bedrock's Anthropic Messages API
+ * (`compat.bedrockMessagesApi`): both `/anthropic` routes reject the tool
+ * `strict` field, and bedrock-runtime rejects a `metadata.user_id` outside
+ * Bedrock's request-metadata pattern. A user id that fits is kept, otherwise
+ * its embedded session id, otherwise the metadata is dropped. Mutates and
+ * returns `payload`.
+ */
+export function fitBedrockAnthropicPayload<T>(payload: T): T {
+	if (!isRecord(payload)) return payload;
+	const body: Record<string, unknown> = payload;
+	if (Array.isArray(body.tools)) {
+		for (const tool of body.tools) {
+			if (isRecord(tool)) delete tool.strict;
+		}
+	}
+	if (body.metadata === undefined) return payload;
+	const userId = isRecord(body.metadata) ? body.metadata.user_id : undefined;
+	const fitted =
+		typeof userId === "string" && isBedrockRequestMetadataValue(userId)
+			? userId
+			: extractClaudeMetadataSessionId(userId);
+	if (fitted && isBedrockRequestMetadataValue(fitted)) body.metadata = { user_id: fitted };
+	else delete body.metadata;
+	return payload;
+}

package/src/providers/bedrock-request-metadata.ts

@@ -0,0 +1,6 @@
+const BEDROCK_REQUEST_METADATA_PATTERN = /^[a-zA-Z0-9\s:_@$#=/+,\-.]*$/;
+
+/** Check Bedrock's request-metadata character and length limits. Keys must also be nonempty. */
+export function isBedrockRequestMetadataValue(value: string): boolean {
+	return value.length <= 256 && BEDROCK_REQUEST_METADATA_PATTERN.test(value);
+}

package/src/providers/connect-error-detail.ts

@@ -1,4 +1,4 @@
-import { truncate } from "@oh-my-pi/pi-utils";
+import { isRecord, truncate } from "@oh-my-pi/pi-utils";
 
 /**
  * Connect-protocol end-stream error formatting.
@@ -21,10 +21,6 @@ const GENERIC_CONNECT_ERROR_MESSAGES = new Set(["", "error", "unknown", "unknown
 /** Upper bound for appended trailer context so errors stay log-line sized. */
 const MAX_EXTRA_DETAIL_CHARS = 400;
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 function safeJson(value: unknown): string | undefined {
 	try {
 		const text = typeof value === "string" ? value : JSON.stringify(value);

package/src/providers/cursor/interaction-query.ts

@@ -32,7 +32,8 @@ type ProtoUnknownBag = { $unknown?: ProtoUnknownField[] };
 type InteractionQueryCase = NonNullable<InteractionQuery["query"]["case"]>;
 type InteractionResult = Exclude<InteractionResponse["result"], { case: undefined; value?: undefined }>;
 
-function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
 	const frame = Buffer.alloc(5 + data.length);
 	frame[0] = flags;
 	frame.writeUInt32BE(data.length, 1);
@@ -46,7 +47,8 @@ function isProtoUnknownField(value: unknown): value is ProtoUnknownField {
 	return typeof value.no === "number" && typeof value.wireType === "number" && value.data instanceof Uint8Array;
 }
 
-function protoUnknownFields(message: object): ProtoUnknownField[] {
+/** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
+export function protoUnknownFields(message: object): ProtoUnknownField[] {
 	if (!("$unknown" in message) || !Array.isArray(message.$unknown)) return [];
 	return message.$unknown.filter(isProtoUnknownField);
 }

package/src/providers/cursor.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs/promises";
 import http2 from "node:http2";
+import { cursorModelParameters } from "@oh-my-pi/pi-catalog/compat/behavior";
 import { isCursorMaxModeWireId } from "@oh-my-pi/pi-catalog/compat/collapse";
 import { classifyModel, collapseVariantId } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import type {
@@ -246,7 +247,7 @@ import {
 	piTimeout,
 	shellTimeoutSeconds,
 } from "./cursor/exec-modern";
-import { handleInteractionQuery } from "./cursor/interaction-query";
+import { frameConnectMessage, handleInteractionQuery, protoUnknownFields } from "./cursor/interaction-query";
 
 export const CURSOR_API_URL = "https://api2.cursor.sh";
 export const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
@@ -407,14 +408,14 @@ function log(type: string, subtype?: string, data?: unknown): void {
 	void appendCursorDebugLog(entry);
 }
 
-function frameConnectMessage(data: Uint8Array, flags = 0): Buffer {
-	const frame = Buffer.alloc(5 + data.length);
-	frame[0] = flags;
-	frame.writeUInt32BE(data.length, 1);
-	frame.set(data, 5);
-	return frame;
+/**
+ * Write one client message. Once the server's end frame has half-closed our
+ * side, late writes (heartbeats, exec replies from a handler still running)
+ * are dropped: writing after `end()` would error the stream.
+ */
+function writeClientMessage(h2Request: http2.ClientHttp2Stream, data: Uint8Array): void {
+	if (!h2Request.writableEnded) h2Request.write(frameConnectMessage(data));
 }
-
 class ConnectEndStreamError extends AIError.ProviderResponseError {
 	readonly diagnosticMessage: string;
 
@@ -845,6 +846,11 @@ function streamCursorWithWireMode(
 						if (endError) {
 							endStreamError = endError;
 							h2Request?.close();
+						} else {
+							// The end frame is the server's last message. Half-close our
+							// side so the stream can finish: a CONNECT proxy holds the
+							// HTTP/2 stream open until the client ends its request.
+							h2Request?.end();
 						}
 						continue;
 					}
@@ -903,7 +909,7 @@ function streamCursorWithWireMode(
 					message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
 				});
 				const heartbeatBytes = toBinary(AgentClientMessageSchema, heartbeatMessage);
-				h2Request.write(frameConnectMessage(heartbeatBytes));
+				writeClientMessage(h2Request, heartbeatBytes);
 			};
 
 			const closeDebugLog = async (): Promise<void> => {
@@ -1207,8 +1213,6 @@ export async function handleServerMessage(
 	}
 }
 
-type ProtoUnknownField = { no: number; wireType: number; data: Uint8Array };
-
 type HostedFetchCall = {
 	args?: { url?: string; toolCallId?: string };
 	result?: { result?: { case?: string; value?: { content?: string; error?: string; url?: string } } };
@@ -1250,11 +1254,6 @@ function describeHostedFetchResult(call: HostedFetchCall | undefined): { text: s
 	return { text: "Fetch completed", isError: false };
 }
 
-function protoUnknownFields(message: object): ProtoUnknownField[] {
-	const raw = (message as { $unknown?: ProtoUnknownField[] }).$unknown;
-	return Array.isArray(raw) ? raw : [];
-}
-
 function handleKvServerMessage(
 	kvMsg: KvServerMessage,
 	blobStore: Map<string, Uint8Array>,
@@ -1281,7 +1280,7 @@ function handleKvServerMessage(
 		});
 
 		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
+		writeClientMessage(h2Request, responseBytes);
 
 		log("kvClient", "getBlobResult", { blobId: blobIdKey.slice(0, 40) });
 	} else if (kvCase === "setBlobArgs") {
@@ -1302,7 +1301,7 @@ function handleKvServerMessage(
 		});
 
 		const responseBytes = toBinary(AgentClientMessageSchema, kvClientMessage);
-		h2Request.write(frameConnectMessage(responseBytes));
+		writeClientMessage(h2Request, responseBytes);
 
 		log("kvClient", "setBlobResult", { blobId: blobIdKey.slice(0, 40) });
 	}
@@ -2604,7 +2603,7 @@ function sendExecClientMessage<TCase extends NonNullable<ExecClientMessage["mess
 	});
 
 	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
+	writeClientMessage(h2Request, responseBytes);
 
 	log("execClientMessage", messageCase, value);
 }
@@ -2640,7 +2639,7 @@ function sendExecClientThrow(
 	const clientMessage = create(AgentClientMessageSchema, {
 		message: { case: "execClientControlMessage", value: controlMessage },
 	});
-	h2Request.write(frameConnectMessage(toBinary(AgentClientMessageSchema, clientMessage)));
+	writeClientMessage(h2Request, toBinary(AgentClientMessageSchema, clientMessage));
 	log("execClientControl", "throw", { id: execMsg.id, execId: execMsg.execId, error, errorCode });
 	sendExecClientStreamClose(h2Request, execMsg);
 }
@@ -2658,7 +2657,7 @@ function sendExecClientStreamClose(h2Request: http2.ClientHttp2Stream, execMsg:
 		message: { case: "execClientControlMessage", value: closeMessage },
 	});
 	const responseBytes = toBinary(AgentClientMessageSchema, clientMessage);
-	h2Request.write(frameConnectMessage(responseBytes));
+	writeClientMessage(h2Request, responseBytes);
 	log("execClientControl", "streamClose", { id: execMsg.id, execId: execMsg.execId });
 }
 
@@ -5487,13 +5486,18 @@ function resolveCursorWireModel(
 			};
 		}
 	}
-	// A bare `composer-2.5` id resolves to the Fast variant server-side
-	// (can1357/oh-my-pi#9012). Pin the Standard tier explicitly; `-fast`
-	// selections keep the Fast lane by omitting the parameter.
-	if (wireModelId === "composer-2.5") {
+	// Fixed per-model parameters come from catalog KDL (`cursor-model-parameter`
+	// in `runtime/behavior.kdl`). A bare `composer-2.5` id resolves to the Fast
+	// variant server-side (can1357/oh-my-pi#9012), so the catalog pins the
+	// Standard tier with `fast=false`; `-fast` selections keep the Fast lane by
+	// declaring no parameter.
+	const fixedParameters = cursorModelParameters(wireModelId);
+	if (fixedParameters.length > 0) {
 		return {
 			modelId: wireModelId,
-			parameters: [create(RequestedModel_ModelParameterbytesSchema, { id: "fast", value: "false" })],
+			parameters: fixedParameters.map(({ id, value }) =>
+				create(RequestedModel_ModelParameterbytesSchema, { id, value }),
+			),
 			maxMode,
 		};
 	}

package/src/providers/google-gemini-cli.ts

@@ -751,9 +751,16 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				const responseSignal = options?.signal
 					? AbortSignal.any([options.signal, responseAbortController.signal])
 					: responseAbortController.signal;
+				const onSseEvent = options?.onSseEvent;
 				const chunks = iterateWithIdleTimeout(
-					readSseJson<CloudCodeAssistResponseChunk>(activeResponse.body, responseSignal, event =>
-						options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
+					// Attach the observer only when a diagnostic listener exists: any
+					// observer turns on per-line raw capture in `readSseJson`.
+					readSseJson<CloudCodeAssistResponseChunk>(
+						activeResponse.body,
+						responseSignal,
+						onSseEvent
+							? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model)
+							: undefined,
 					),
 					{
 						firstItemTimeoutMs: firstEventTimeoutMs,

package/src/providers/google-shared.ts

@@ -4,7 +4,7 @@
 
 import { scheduler } from "node:timers/promises";
 import { calculateCost } from "@oh-my-pi/pi-catalog/models";
-import { readSseJson } from "@oh-my-pi/pi-utils";
+import { readSseJson, type SseEventObserver } from "@oh-my-pi/pi-utils";
 import { renderDemotedThinking } from "../dialect/demotion";
 import { ThinkingFenceStripper } from "../dialect/thinking-fence-strip";
 import * as AIError from "../error";
@@ -828,8 +828,14 @@ export function buildGoogleGenerateContentParams<T extends "google-generative-ai
 	// Vertex AI ignores a body field and requires the
 	// `X-Vertex-AI-LLM-Shared-Request-Type` header instead (added in
 	// streamGoogleVertex), so only emit the body field for the direct API.
-	if (model.provider === "google" && shouldSendServiceTier(options.serviceTier, model.provider)) {
-		config.serviceTier = options.serviceTier;
+	const serviceTier = options.serviceTier;
+	// `!== "ultrafast"` narrows to the Gemini wire type; `shouldSendServiceTier` already rejects it for Google.
+	if (
+		model.provider === "google" &&
+		serviceTier !== "ultrafast" &&
+		shouldSendServiceTier(serviceTier, model.provider)
+	) {
+		config.serviceTier = serviceTier;
 	}
 
 	if (context.tools && context.tools.length > 0 && options.toolChoice) {
@@ -1014,13 +1020,17 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 			let body = await openStream();
 			stream.push({ type: "start", partial: output });
 
+			// Attach the observer only when a diagnostic listener exists: any
+			// observer turns on per-line raw capture in `readSseJson`.
+			const onSseEvent = options?.onSseEvent;
+			const sseObserver: SseEventObserver | undefined = onSseEvent
+				? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, model)
+				: undefined;
 			// Gemini occasionally finishes with `finishReason: STOP` while emitting only an empty
 			// text part and no tool call. Delivered as-is the agent receives a blank message and
 			// silently halts mid-task, so retry a bounded number of times before giving up.
 			for (let emptyAttempt = 0; ; emptyAttempt++) {
-				const googleStream = readSseJson<GenerateContentResponse>(body, options?.signal, event =>
-					options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
-				);
+				const googleStream = readSseJson<GenerateContentResponse>(body, options?.signal, sseObserver);
 				await consumeGoogleStream({
 					googleStream,
 					output,

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

@@ -551,7 +551,7 @@ export interface ChatCompletionChunk {
 	/** Moderation results, present on the moderation chunk when requested. */
 	moderation?: ChatCompletionChunkModeration | null;
 	/** Processing type actually used for serving the request. */
-	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | null;
+	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | "ultrafast" | null;
 	/** Deprecated by OpenAI: backend configuration fingerprint, pairs with `seed`. */
 	system_fingerprint?: string;
 	/** Only with `stream_options: {"include_usage": true}`; null except on the last chunk. */
@@ -819,7 +819,7 @@ export interface ChatCompletionCreateParamsBase {
 	/** Deprecated by OpenAI (Beta): best-effort deterministic sampling seed. */
 	seed?: number | null;
 	/** Processing type used for serving the request. */
-	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | null;
+	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | "ultrafast" | null;
 	/** Up to 4 sequences where the API will stop generating further tokens. */
 	stop?: string | null | Array<string>;
 	/** Whether to store the output for model distillation or evals. */

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

@@ -86,7 +86,7 @@ export interface RequestBody {
 	client_metadata?: Record<string, string>;
 	max_output_tokens?: number;
 	max_completion_tokens?: number;
-	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | null;
+	service_tier?: "auto" | "default" | "flex" | "scale" | "priority" | "ultrafast" | null;
 	/** Explicit cyber access program for this request; see `openai-codex/access-programs.ts`. */
 	access_programs?: { cyber: string };
 	[key: string]: unknown;

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

@@ -1325,28 +1325,26 @@ function getCodexServiceTierCostMultiplier(
 	model: Pick<Model<"openai-codex-responses">, "serviceTierCost">,
 	serviceTier: ServiceTier | "default" | undefined,
 ): number {
+	// `ultrafast` has no published price (API preview, Codex credits), so it is
+	// shown at 1x rather than an invented multiplier.
 	if (serviceTier !== "flex" && serviceTier !== "priority") return 1;
 	return model.serviceTierCost?.[serviceTier] ?? 1;
 }
 
-function resolveCodexCostServiceTier(res: unknown, req?: unknown): ServiceTier | "default" | undefined {
-	switch (res) {
-		case "flex":
-			return "flex";
-		case "priority":
-			return "priority";
-		default:
-			if (req === "flex" || req === "priority") {
-				return req;
-			}
-			return "default";
-	}
+/**
+ * The tier a Codex response was billed at. The response echo is authoritative
+ * whenever it reports a tier (the backend may serve a requested priority/flex
+ * turn as `default`); the requested tier is used only when the echo is absent.
+ */
+function resolveCodexCostServiceTier(res: ServiceTier | undefined, req?: unknown): ServiceTier | "default" | undefined {
+	const served = res ?? req;
+	return served === "flex" || served === "priority" ? served : "default";
 }
 
 function applyCodexServiceTierPricing(
 	model: Pick<Model<"openai-codex-responses">, "serviceTierCost">,
 	usage: AssistantMessage["usage"],
-	resTier: unknown,
+	resTier: ServiceTier | undefined,
 	reqTier: unknown,
 ): void {
 	const resolvedTier = resolveCodexCostServiceTier(resTier, reqTier);
@@ -3530,6 +3528,7 @@ function parseCodexServiceTier(value: unknown): ServiceTier | undefined {
 		case "flex":
 		case "scale":
 		case "priority":
+		case "ultrafast":
 			return value;
 		default:
 			return undefined;
@@ -3749,12 +3748,18 @@ const CODEX_CHAIN_TOP_LEVEL_EXCLUDE_MAP = {
  * request schema has no `previous_response_id` (codex-rs carries it only on
  * websocket `response.create` frames) and strict gateway validators 400 it
  * with `{"detail":"Unsupported parameter: previous_response_id"}`.
+ *
+ * Entering or leaving `ultrafast` still breaks the chain: that tier is a
+ * separate serving path, and codex-rs sends a full `response.create` across
+ * such a switch rather than a `previous_response_id` delta.
  */
 function buildCodexChainedRequestBody(
 	requestBody: RequestBody,
 	state: CodexWebSocketSessionState | undefined,
 ): RequestBody {
-	const chainable = state?.canAppend === true;
+	const chainable =
+		state?.canAppend === true &&
+		(state.lastRequest?.service_tier === "ultrafast") === (requestBody.service_tier === "ultrafast");
 	const appendInput = chainable
 		? buildResponsesDeltaInput(
 				state.lastRequest,
@@ -4730,8 +4735,14 @@ async function openCodexSseEventStream(
 	if (!response.body) {
 		throw new CodexProviderStreamError("No response body", false);
 	}
-	return readSseJson<Record<string, unknown>>(response.body, signal, event =>
-		onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, undefined),
+	// Attach the observer only when a diagnostic listener exists: any observer
+	// turns on per-line raw capture in `readSseJson`.
+	return readSseJson<Record<string, unknown>>(
+		response.body,
+		signal,
+		onSseEvent
+			? event => onSseEvent({ event: event.event, data: event.data, raw: [...event.raw] }, undefined)
+			: undefined,
 	);
 }