@gajae-code/ai 0.18.11 → 0.18.12

package/src/providers/ollama.ts

@@ -28,6 +28,7 @@ import {
 } from "../utils/tool-choice-capability";
 import { flagTruncatedToolCalls } from "./openai-responses-shared";
 import { transformMessages } from "./transform-messages";
+import { joinTextWithImagePlaceholder } from "./vision-guard";
 
 export interface OllamaChatOptions extends StreamOptions {
 	reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
@@ -148,7 +149,10 @@ function selectToolsForToolChoice(tools: Tool[] | undefined, toolChoice: ToolCho
 	return [];
 }
 
-function toPlainContent(content: string | Array<{ type: "text" | "image"; text?: string; data?: string }>): {
+function toPlainContent(
+	content: string | Array<{ type: "text" | "image"; text?: string; data?: string }>,
+	supportsImages: boolean,
+): {
 	content: string;
 	images?: string[];
 } {
@@ -157,31 +161,36 @@ function toPlainContent(content: string | Array<{ type: "text" | "image"; text?:
 	}
 	const textParts: string[] = [];
 	const images: string[] = [];
+	let omittedImages = false;
 	for (const block of content) {
 		if (block.type === "text" && typeof block.text === "string") {
 			textParts.push(block.text);
 		}
-		if (block.type === "image" && typeof block.data === "string") {
-			images.push(block.data);
+		if (block.type === "image") {
+			if (supportsImages && typeof block.data === "string") {
+				images.push(block.data);
+			} else if (!supportsImages) {
+				omittedImages = true;
+			}
 		}
 	}
 	return {
-		content: textParts.join("\n"),
+		content: joinTextWithImagePlaceholder(textParts.join("\n"), omittedImages),
 		...(images.length > 0 ? { images } : {}),
 	};
 }
 
-function convertMessage(message: Message): OllamaMessage {
+function convertMessage(message: Message, supportsImages: boolean): OllamaMessage {
 	if (message.role === "user") {
-		const converted = toPlainContent(message.content as UserMessage["content"]);
+		const converted = toPlainContent(message.content as UserMessage["content"], supportsImages);
 		return { role: "user", ...converted };
 	}
 	if (message.role === "developer") {
-		const converted = toPlainContent(message.content as DeveloperMessage["content"]);
+		const converted = toPlainContent(message.content as DeveloperMessage["content"], supportsImages);
 		return { role: "system", ...converted };
 	}
 	if (message.role === "toolResult") {
-		const converted = toPlainContent(message.content as ToolResultMessage["content"]);
+		const converted = toPlainContent(message.content as ToolResultMessage["content"], supportsImages);
 		return {
 			role: "tool",
 			tool_name: message.toolName,
@@ -233,8 +242,9 @@ function convertMessages(model: Model<"ollama-chat">, context: Context): OllamaM
 	}
 	messages.push(...context.messages);
 	const isCloud = model.provider === "ollama-cloud";
+	const supportsImages = model.input.includes("image");
 	return transformMessages(messages, model).map(msg => {
-		const converted = convertMessage(msg);
+		const converted = convertMessage(msg, supportsImages);
 		// Ollama cloud rejects requests when assistant history messages contain the `thinking`
 		// field — it's valid in model responses but not accepted as a history input. Strip it
 		// to prevent HTTP 400 errors. Local Ollama instances are unaffected.

package/src/providers/openai-anthropic-shim.ts

@@ -67,6 +67,7 @@ export function streamOpenAIAnthropicShim(
 					thinking: model.thinking,
 					input: model.input,
 					cost: model.cost,
+					streamIdleTimeoutMs: model.streamIdleTimeoutMs,
 				};
 
 				const reasoningEffort = options?.reasoning;

package/src/providers/openai-chat-server-schema.ts

@@ -223,7 +223,7 @@ export const openaiChatRequestSchema = z.object({
 	user: nullableOptional(z.string()),
 	reasoning_effort: nullableOptional(z.enum(["minimal", "low", "medium", "high", "xhigh", "max"])),
 	parallel_tool_calls: nullableOptional(z.boolean()),
-	service_tier: nullableOptional(z.enum(["auto", "default", "flex", "scale", "priority"])),
+	service_tier: nullableOptional(z.enum(["auto", "default", "flex", "scale", "priority", "ultrafast"])),
 	metadata: nullableOptional(z.record(z.string(), z.unknown())),
 
 	// ── Accept-and-ignore passthroughs ─────────────────────────────────────

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

@@ -46,7 +46,14 @@ function isReasoningEffort(value: unknown): value is ReasoningEffort {
 }
 
 function isServiceTier(value: unknown): value is ResolvedServiceTier {
-	return value === "auto" || value === "default" || value === "flex" || value === "scale" || value === "priority";
+	return (
+		value === "auto" ||
+		value === "default" ||
+		value === "flex" ||
+		value === "scale" ||
+		value === "priority" ||
+		value === "ultrafast"
+	);
 }
 
 // ---------------------------------------------------------------------------
@@ -399,6 +406,7 @@ export function encodeResponse(message: AssistantMessage, requestedModelId: stri
 				logprobs: null,
 			},
 		],
+		...(message.serviceTier ? { service_tier: message.serviceTier } : {}),
 		usage: buildUsage(message),
 	};
 }
@@ -536,6 +544,7 @@ export function encodeStream(
 			model: requestedModelId,
 			system_fingerprint: null,
 			choices: [],
+			...(message.serviceTier ? { service_tier: message.serviceTier } : {}),
 			usage: buildUsage(message),
 		});
 	};
@@ -671,7 +680,10 @@ export function encodeStream(
 										: hasToolCalls
 											? "tool_calls"
 											: "stop";
-							writeSse(controller, baseChunk({}, finishReason));
+							writeSse(controller, {
+								...baseChunk({}, finishReason),
+								...(event.message.serviceTier ? { service_tier: event.message.serviceTier } : {}),
+							});
 							if (includeUsage) writeUsage(controller, event.message);
 							controller.enqueue(encoder.encode("data: [DONE]\n\n"));
 							controller.close();

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

@@ -32,7 +32,9 @@ import {
 	type Context,
 	type FetchImpl,
 	type Model,
+	modelSupportsUltrafastTier,
 	type ProviderSessionState,
+	parseResolvedServiceTier,
 	resolveServiceTier,
 	type ServiceTier,
 	type StreamFunction,
@@ -774,15 +776,15 @@ function getCodexUserAgent(): string {
 	return formatCodexUserAgent(os.platform(), os.release(), os.arch());
 }
 
-function getCodexServiceTierCostMultiplier(
-	model: Pick<Model<"openai-codex-responses">, "id">,
-	serviceTier: ServiceTier | "default" | undefined,
-): number {
+/** ChatGPT Codex included-usage multipliers; API token pricing uses separate provider paths. */
+function getCodexServiceTierCostMultiplier(serviceTier: ServiceTier | "default" | undefined): number {
 	switch (serviceTier) {
 		case "flex":
 			return 0.5;
 		case "priority":
-			return model.id === "gpt-5.5" ? 2.5 : 2;
+			return 2.5;
+		case "ultrafast":
+			return 8;
 		default:
 			return 1;
 	}
@@ -795,23 +797,19 @@ function resolveCodexCostServiceTier(res: unknown, req?: unknown): ServiceTier |
 		case "flex":
 		case "scale":
 		case "priority":
+		case "ultrafast":
 			return res;
 		default:
-			if (req === "flex" || req === "priority") {
+			if (req === "flex" || req === "priority" || req === "ultrafast") {
 				return req;
 			}
 			return "default";
 	}
 }
 
-function applyCodexServiceTierPricing(
-	model: Pick<Model<"openai-codex-responses">, "id">,
-	usage: AssistantMessage["usage"],
-	resTier: unknown,
-	reqTier: unknown,
-): void {
+function applyCodexServiceTierPricing(usage: AssistantMessage["usage"], resTier: unknown, reqTier: unknown): void {
 	const resolvedTier = resolveCodexCostServiceTier(resTier, reqTier);
-	const multiplier = getCodexServiceTierCostMultiplier(model, resolvedTier);
+	const multiplier = getCodexServiceTierCostMultiplier(resolvedTier);
 	if (multiplier === 1) return;
 	usage.cost.input *= multiplier;
 	usage.cost.output *= multiplier;
@@ -988,6 +986,12 @@ async function buildTransformedCodexRequestBody(
 	const resolvedServiceTier = resolveServiceTier(options?.serviceTier, model.provider);
 	if (resolvedServiceTier === "flex" || resolvedServiceTier === "scale" || resolvedServiceTier === "priority") {
 		params.service_tier = resolvedServiceTier;
+	} else if (resolvedServiceTier === "ultrafast") {
+		// Gate ultrafast to models that explicitly support it
+		if (modelSupportsUltrafastTier(model)) {
+			params.service_tier = "ultrafast";
+		}
+		// else: silently omit ultrafast if model doesn't support it (fail-closed)
 	}
 	if (context.tools && context.tools.length > 0) {
 		params.tools = convertOpenAICodexResponsesTools(context.tools, model);
@@ -2301,7 +2305,10 @@ function handleResponseCompleted(
 	}
 
 	calculateCost(model, output.usage);
-	applyCodexServiceTierPricing(model, output.usage, response?.service_tier, runtime.requestBodyForState.service_tier);
+	output.serviceTier =
+		parseResolvedServiceTier(response?.service_tier) ??
+		parseResolvedServiceTier(runtime.requestBodyForState.service_tier);
+	applyCodexServiceTierPricing(output.usage, response?.service_tier, runtime.requestBodyForState.service_tier);
 	output.stopReason = mapOpenAIResponsesStopReason(response?.status as OpenAI.Responses.ResponseStatus | undefined);
 	// A response cut short for length may have stopped mid-tool-call. Flag any
 	// call that never received its `output_item.done` so the agent loop rejects

package/src/providers/openai-completions.d.ts

@@ -33,7 +33,7 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     repetitionGuard?: RepetitionGuardOptions;
 }
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
-export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];
+export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined, serviceTier?: ServiceTier): AssistantMessage["usage"];
 export declare function convertMessages(model: Model<"openai-completions">, context: Context, compat: ResolvedOpenAICompat): ChatCompletionMessageParam[];
 /**
  * Detect compatibility settings from provider and baseUrl for known providers.

package/src/providers/openai-completions.ts

@@ -33,8 +33,10 @@ import {
 	type Message,
 	type MessageAttribution,
 	type Model,
+	modelSupportsUltrafastTier,
 	type OpenAICompat,
 	type ProviderSessionState,
+	parseResolvedServiceTier,
 	type RepetitionGuardOptions,
 	resolveServiceTier,
 	type ServiceTier,
@@ -660,7 +662,9 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 
 		try {
 			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(model.provider, model.id);
+			const idleTimeoutMs =
+				options?.streamIdleTimeoutMs ??
+				getOpenAIStreamIdleTimeoutMs(model.provider, model.id, model.streamIdleTimeoutMs);
 			const {
 				client,
 				copilotPremiumRequests,
@@ -685,6 +689,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				options?.providerSessionId,
 				options?.maxRetryDelayMs,
 				options?.attemptScope,
+				options?.streamIdleTimeoutMs,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			getCapturedErrorResponse = captureErrorResponse;
@@ -696,6 +701,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 			);
 			let disableStrictTools = providerSessionState?.strictToolsDisabled ?? false;
 			let strictFallbackErrorMessage: string | undefined;
+			let effectiveServiceTier: ServiceTier | undefined;
 			const createCompletionsStream = async (toolStrictModeOverride?: ToolStrictModeOverride) => {
 				clearCapturedErrorResponse();
 				const effectiveToolStrictModeOverride = disableStrictTools ? "none" : toolStrictModeOverride;
@@ -717,6 +723,9 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				if (replacementPayload !== undefined) {
 					params = replacementPayload as typeof params;
 				}
+				// Capture the service tier for use in cost calculations
+				effectiveServiceTier = (params as Record<string, unknown>).service_tier as ServiceTier | undefined;
+				output.serviceTier = parseResolvedServiceTier(effectiveServiceTier);
 				rawRequestDump = {
 					provider: model.provider,
 					api: output.api,
@@ -1149,7 +1158,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 			let hasExplicitUsageReport = false;
 			let hasNonzeroUsageEvidence = false;
 			const applyUsage = (rawUsage: object): void => {
-				const usage = parseChunkUsage(rawUsage, model, premiumRequestsTotal);
+				const usage = parseChunkUsage(rawUsage, model, premiumRequestsTotal, effectiveServiceTier);
 				const hasExplicitTotal = getOptionalNumberProperty(rawUsage, "total_tokens") !== undefined;
 				const hasExplicitComponents =
 					getOptionalNumberProperty(rawUsage, "prompt_tokens") !== undefined &&
@@ -1187,6 +1196,11 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				// `choices`-less or malformed chunks after a trip never spends the
 				// budget and the request hangs open (#5627 review r5).
 				if (chunk && typeof chunk === "object") {
+					const responseServiceTier = parseResolvedServiceTier(Reflect.get(chunk, "service_tier"));
+					if (responseServiceTier !== undefined) {
+						effectiveServiceTier = responseServiceTier;
+						output.serviceTier = responseServiceTier;
+					}
 					// OpenAI documents ChatCompletionChunk.id as the unique chat completion identifier,
 					// and each chunk in a streamed completion carries the same id.
 					output.responseId ||= chunk.id;
@@ -1540,6 +1554,7 @@ async function createClient(
 	providerSessionId?: string,
 	maxRetryDelayMs?: number,
 	attemptScope?: import("../types.js").AttemptScopeRef,
+	effectiveIdleTimeoutOverride?: number,
 ): Promise<{
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -1686,7 +1701,13 @@ async function createClient(
 	// The OpenAI SDK's default is 10 minutes per attempt × `maxRetries`, which
 	// turns a stalled-before-headers fetch into a multi-minute hang invisible
 	// to the agent loop (the iterator watchdog only arms AFTER `create()` returns).
-	const sdkTimeoutMs = resolveOpenAISdkRequestTimeoutMs(model.provider, streamFirstEventTimeoutOverride, model.id);
+	const sdkTimeoutMs = resolveOpenAISdkRequestTimeoutMs(
+		model.provider,
+		streamFirstEventTimeoutOverride,
+		model.id,
+		model.streamIdleTimeoutMs,
+		effectiveIdleTimeoutOverride,
+	);
 	return {
 		client: new OpenAI({
 			apiKey,
@@ -1792,10 +1813,23 @@ function buildParams(
 	if (options?.frequencyPenalty !== undefined) {
 		params.frequency_penalty = options.frequencyPenalty;
 	}
-	if (shouldSendServiceTier(options?.serviceTier, model.provider, compat.supportsServiceTier === true)) {
+	if (
+		shouldSendServiceTier(
+			options?.serviceTier,
+			model.provider,
+			compat.supportsServiceTier === true,
+			modelSupportsUltrafastTier(model),
+		)
+	) {
 		const resolved = resolveServiceTier(options?.serviceTier, model.provider);
 		if (resolved === "flex" || resolved === "scale" || resolved === "priority") {
 			params.service_tier = resolved;
+		} else if (resolved === "ultrafast") {
+			// Gate ultrafast to models that explicitly support it
+			if (modelSupportsUltrafastTier(model)) {
+				(params as Record<string, unknown>).service_tier = "ultrafast";
+			}
+			// else: silently omit ultrafast if model doesn't support it (fail-closed)
 		}
 	}
 
@@ -1988,10 +2022,28 @@ function getChoiceUsage(choice: ChatCompletionChunk.Choice): object | undefined
 	return getOptionalObjectProperty(choice, "usage");
 }
 
+/**
+ * Get the service tier cost multiplier for Completions API.
+ * Completions API applies the same multipliers as Codex for consistency.
+ */
+function getCompletionsServiceTierCostMultiplier(serviceTier: ServiceTier | undefined): number {
+	switch (serviceTier) {
+		case "flex":
+			return 0.5;
+		case "priority":
+			return 2;
+		case "ultrafast":
+			return 6;
+		default:
+			return 1;
+	}
+}
+
 export function parseChunkUsage(
 	rawUsage: object,
 	model: Model<"openai-completions">,
 	premiumRequests: number | undefined,
+	serviceTier?: ServiceTier,
 ): AssistantMessage["usage"] {
 	const promptTokenDetails = getOptionalObjectProperty(rawUsage, "prompt_tokens_details");
 	const completionTokenDetails = getOptionalObjectProperty(rawUsage, "completion_tokens_details");
@@ -2030,6 +2082,15 @@ export function parseChunkUsage(
 		...(premiumRequests !== undefined ? { premiumRequests } : {}),
 	};
 	calculateCost(model, usage);
+	// Apply service tier cost multiplier (ultrafast = 6x, priority = 2x, flex = 0.5x)
+	const multiplier = getCompletionsServiceTierCostMultiplier(serviceTier);
+	if (multiplier !== 1) {
+		usage.cost.input *= multiplier;
+		usage.cost.output *= multiplier;
+		usage.cost.cacheRead *= multiplier;
+		usage.cost.cacheWrite *= multiplier;
+		usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	}
 	return usage;
 }
 

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

@@ -49,7 +49,14 @@ function isReasoningEffort(value: unknown): value is NonNullable<ParsedRequest["
 }
 
 function isServiceTier(value: unknown): value is NonNullable<ParsedRequest["options"]["serviceTier"]> {
-	return value === "auto" || value === "default" || value === "flex" || value === "scale" || value === "priority";
+	return (
+		value === "auto" ||
+		value === "default" ||
+		value === "flex" ||
+		value === "scale" ||
+		value === "priority" ||
+		value === "ultrafast"
+	);
 }
 
 function isObj(v: unknown): v is Record<string, unknown> {
@@ -714,6 +721,7 @@ function buildResponseEnvelope(
 		created_at: Math.floor(message.timestamp / 1000),
 		status,
 		model: requestedModelId,
+		...(message.serviceTier ? { service_tier: message.serviceTier } : {}),
 		output: items,
 		usage,
 		...(status === "incomplete" ? { incomplete_details: { reason: "max_output_tokens" } } : {}),
@@ -1230,6 +1238,7 @@ export function encodeStream(
 								created_at: createdAt,
 								status,
 								model: requestedModelId,
+								...(message?.serviceTier ? { service_tier: message.serviceTier } : {}),
 								output: items,
 								usage,
 								...(status === "incomplete" ? { incomplete_details: { reason: "max_output_tokens" } } : {}),

package/src/providers/openai-responses-shared.d.ts

@@ -43,6 +43,7 @@ export declare function appendResponsesToolResultMessages<TApi extends Api>(mess
 export interface ProcessResponsesStreamOptions {
     onFirstToken?: () => void;
     onOutputItemDone?: (item: ResponseOutputItem) => void;
+    serviceTier?: ServiceTier;
 }
 export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<boolean>;
 /**
@@ -99,7 +100,7 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
  * Apply the common `StreamOptions` → Responses sampling-parameter mapping (max output tokens,
  * temperature, top-p/k, min-p, presence/repetition penalties, service tier). Mutates `params`.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string, supportsServiceTier?: boolean): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, provider: string, supportsServiceTier?: boolean, modelSupportsUltrafastTier?: boolean): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

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

@@ -18,6 +18,7 @@ import {
 	type AssistantMessage,
 	type ImageContent,
 	type Model,
+	parseResolvedServiceTier,
 	resolveServiceTier,
 	type ServiceTier,
 	type StopReason,
@@ -437,9 +438,27 @@ function appendResponsesToolResultOutput(
 	}
 }
 
+/**
+ * Get the service tier cost multiplier for Responses API.
+ * Responses API applies the same multipliers as Codex for consistency.
+ */
+function getResponsesServiceTierCostMultiplier(serviceTier: ServiceTier | undefined): number {
+	switch (serviceTier) {
+		case "flex":
+			return 0.5;
+		case "priority":
+			return 2;
+		case "ultrafast":
+			return 6;
+		default:
+			return 1;
+	}
+}
+
 export interface ProcessResponsesStreamOptions {
 	onFirstToken?: () => void;
 	onOutputItemDone?: (item: ResponseOutputItem) => void;
+	serviceTier?: ServiceTier;
 }
 
 export async function processResponsesStream<TApi extends Api>(
@@ -973,6 +992,21 @@ export async function processResponsesStream<TApi extends Api>(
 			}
 			populateResponsesUsageFromResponse(output, response?.usage);
 			calculateCost(model, output.usage);
+			// Apply service tier cost multiplier (ultrafast = 6x, priority = 2x, flex = 0.5x)
+			const effectiveServiceTier = parseResolvedServiceTier(response?.service_tier) ?? options?.serviceTier;
+			output.serviceTier = parseResolvedServiceTier(effectiveServiceTier);
+			const multiplier = getResponsesServiceTierCostMultiplier(effectiveServiceTier);
+			if (multiplier !== 1) {
+				output.usage.cost.input *= multiplier;
+				output.usage.cost.output *= multiplier;
+				output.usage.cost.cacheRead *= multiplier;
+				output.usage.cost.cacheWrite *= multiplier;
+				output.usage.cost.total =
+					output.usage.cost.input +
+					output.usage.cost.output +
+					output.usage.cost.cacheRead +
+					output.usage.cost.cacheWrite;
+			}
 			// A `response.incomplete` frame is terminal because the response was cut
 			// short, so the event type itself proves truncation. Deriving `length`
 			// from the event rather than trusting `response.status` stops a relay that
@@ -1214,6 +1248,7 @@ export function applyCommonResponsesSamplingParams<P extends CommonResponsesPara
 	options: CommonSamplingOptions | undefined,
 	provider: string,
 	supportsServiceTier = false,
+	modelSupportsUltrafastTier = false,
 ): void {
 	if (options?.maxTokens) params.max_output_tokens = options.maxTokens;
 	if (options?.temperature !== undefined) params.temperature = options.temperature;
@@ -1222,10 +1257,16 @@ export function applyCommonResponsesSamplingParams<P extends CommonResponsesPara
 	if (options?.minP !== undefined) params.min_p = options.minP;
 	if (options?.presencePenalty !== undefined) params.presence_penalty = options.presencePenalty;
 	if (options?.repetitionPenalty !== undefined) params.repetition_penalty = options.repetitionPenalty;
-	if (shouldSendServiceTier(options?.serviceTier, provider, supportsServiceTier)) {
+	if (shouldSendServiceTier(options?.serviceTier, provider, supportsServiceTier, modelSupportsUltrafastTier)) {
 		const resolved = resolveServiceTier(options?.serviceTier, provider);
 		if (resolved === "flex" || resolved === "scale" || resolved === "priority") {
 			params.service_tier = resolved;
+		} else if (resolved === "ultrafast") {
+			// Responses API: gate ultrafast to models that explicitly support it
+			if (modelSupportsUltrafastTier) {
+				(params as Record<string, unknown>).service_tier = "ultrafast";
+			}
+			// else: silently omit ultrafast if model doesn't support it (fail-closed)
 		}
 	}
 }

package/src/providers/openai-responses.ts

@@ -15,6 +15,7 @@ import {
 	isKnownProvider,
 	type MessageAttribution,
 	type Model,
+	modelSupportsUltrafastTier,
 	type OpenAICompat,
 	type ProviderSessionState,
 	type ServiceTier,
@@ -48,6 +49,7 @@ import {
 	resolveOpenAISdkRequestTimeoutMs,
 } from "../utils/idle-iterator";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
+import { isLoopbackHostname } from "../utils/parse-bind";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { callWithCopilotModelRetry } from "../utils/retry";
 import { resolveRetryBudget } from "../utils/retry-budget";
@@ -168,27 +170,49 @@ function isCanonicalOpenAIAffinityOrigin(baseUrl: string | undefined): boolean {
 	}
 }
 /**
- * Official OpenAI keeps its existing session-routing behavior even when prompt
- * caching is disabled. Relay affinity is opt-in, cache-enabled, and limited to
- * explicitly supported openai or unknown provider ids so known non-target
- * transports cannot inherit the headers.
+ * True when the base URL is http(s) and its hostname is a loopback literal
+ * (`127.0.0.0/8`, `localhost`, `::1`). Hostnames are matched as written and
+ * never resolved, so a DNS alias pointed at loopback stays opt-in. A loopback
+ * relay runs in the same trust scope as the process that dials it, so the
+ * ChatGPT codex backend contract applies: without a stable session identity the
+ * backend cannot reuse the warmed prompt prefix, and every turn replays the
+ * whole context. Remote custom relays stay opt-in.
  */
+function isLoopbackRelayOrigin(baseUrl: string | undefined): boolean {
+	if (!baseUrl) return false;
+	try {
+		const url = new URL(baseUrl);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+		return isLoopbackHostname(url.hostname);
+	} catch {
+		return false;
+	}
+}
 
+/**
+ * Official OpenAI keeps its existing session-routing behavior even when prompt
+ * caching is disabled. Relay affinity is cache-enabled and limited to explicitly
+ * supported openai or unknown provider ids so known non-target transports cannot
+ * inherit the headers. Custom relays default on for loopback origins, where the
+ * caller owns the endpoint, and an explicit `false` opts out everywhere.
+ */
 function shouldSendOpenAIResponsesSessionHeaders(
 	model: Model<"openai-responses">,
 	baseUrl: string | undefined,
 	cacheRetention: CacheRetention,
 ): boolean {
+	const affinityCompat = model.compat?.supportsResponsesSessionAffinity;
 	if (model.provider === "openai") {
 		if (isCanonicalOpenAIAffinityOrigin(baseUrl)) return true;
-		return cacheRetention !== "none" && model.compat?.supportsResponsesSessionAffinity === true;
+		if (cacheRetention === "none" || affinityCompat === false) return false;
+		return affinityCompat === true || isLoopbackRelayOrigin(baseUrl);
 	}
-	if (cacheRetention === "none" || isKnownProvider(model.provider)) {
+	if (cacheRetention === "none" || isKnownProvider(model.provider) || affinityCompat === false) {
 		return false;
 	}
 	return (
 		Boolean(baseUrl?.trim()) &&
-		model.compat?.supportsResponsesSessionAffinity === true &&
+		(affinityCompat === true || isLoopbackRelayOrigin(baseUrl)) &&
 		!isCanonicalOpenAIAffinityOrigin(baseUrl)
 	);
 }
@@ -394,11 +418,14 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				options?.maxRetryDelayMs,
 				options?.attemptScope,
 				options?.streamFirstEventTimeoutMs,
+				options?.streamIdleTimeoutMs,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
 			let { params } = buildParams(model, context, options, providerSessionState, cacheRetention, baseUrl);
-			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs(model.provider, model.id);
+			const idleTimeoutMs =
+				options?.streamIdleTimeoutMs ??
+				getOpenAIStreamIdleTimeoutMs(model.provider, model.id, model.streamIdleTimeoutMs);
 			const replacementPayload = await options?.onPayload?.(
 				params,
 				undefined,
@@ -491,6 +518,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 					onOutputItemDone: item => {
 						nativeOutputItems.push(structuredCloneJSON<unknown>(item) as unknown as Record<string, unknown>);
 					},
+					serviceTier: (params as unknown as Record<string, unknown>).service_tier as ServiceTier | undefined,
 				},
 			);
 			if (premiumRequestsTotal !== undefined) output.usage.premiumRequests = premiumRequestsTotal;
@@ -588,6 +616,7 @@ function createClient(
 	maxRetryDelayMs?: number,
 	attemptScope?: import("../types.js").AttemptScopeRef,
 	streamFirstEventTimeoutOverride?: number,
+	effectiveIdleTimeoutOverride?: number,
 ): {
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -660,7 +689,13 @@ function createClient(
 	);
 	// Bound HTTP request timeout to the first-event window so a stalled-before-headers
 	// fetch cannot wait the SDK's 10-minute default before the transport watchdog arms.
-	const sdkTimeoutMs = resolveOpenAISdkRequestTimeoutMs(model.provider, streamFirstEventTimeoutOverride, model.id);
+	const sdkTimeoutMs = resolveOpenAISdkRequestTimeoutMs(
+		model.provider,
+		streamFirstEventTimeoutOverride,
+		model.id,
+		model.streamIdleTimeoutMs,
+		effectiveIdleTimeoutOverride,
+	);
 	return {
 		client: new OpenAI({
 			apiKey,
@@ -746,7 +781,13 @@ function buildParams(
 		stream_options: model.provider === "openai" ? { include_obfuscation: false } : undefined,
 	};
 
-	applyCommonResponsesSamplingParams(params, options, model.provider, model.compat?.supportsServiceTier === true);
+	applyCommonResponsesSamplingParams(
+		params,
+		options,
+		model.provider,
+		model.compat?.supportsServiceTier === true,
+		modelSupportsUltrafastTier(model),
+	);
 	// TODO: openai responses has no top-level `stop`/`stop_sequences`; surface via reasoning.stop?
 	// `StreamOptions.stopSequences` is intentionally dropped for this provider.
 	// TODO: openai responses has no top-level `frequency_penalty` field as of the current SDK;

package/src/providers/pi-native-server.ts

@@ -326,7 +326,7 @@ function sanitizeEvent(event: AssistantMessageEvent): AssistantMessageEvent | un
 		case "done":
 			return { ...event, message: sanitizeMessage(event.message) };
 		case "error":
-			return { ...event, error: sanitizeMessage(event.error) };
+			return { type: "error", reason: event.reason, error: sanitizeMessage(event.error) };
 		case "toolChoiceIncapability":
 			return event;
 		case "thinking_start":