promptfoo 0.125.0 → 0.125.1

package/dist/src/responses-BMbaUXQI.js

@@ -0,0 +1,1098 @@
+import { G as getEnvInt, S as sanitizeUrl, W as getEnvFloat, o as logger, p as isSecretField, q as getEnvString } from "./logger-CNHLbG5Y.js";
+import "./dataUrl-DUSr-ZvI.js";
+import { C as formatRateLimitErrorMessage, T as isAbortError, n as fetchWithRetries, w as getAbortError, y as HttpRateLimitError } from "./fetch-BG_Jl7ty.js";
+import { a as getRequestTimeoutMs, t as LONG_RUNNING_MODEL_TIMEOUT_MS } from "./shared-BnN4RWgk.js";
+import { n as sleep } from "./time-Db5rO0GY.js";
+import { n as renderVarsInObject } from "./render-DrCSgzhR.js";
+import { c as extractProviderResponseAttributes, h as withGenAISpan, i as buildChatSpanContext } from "./genaiTracer-QTyx3Q-T.js";
+import { i as fetchWithCache, l as getScopedCacheKey, n as claimCacheKeyOnce, u as isCacheEnabled } from "./cache-DeF5zIEN.js";
+import { n as sha256 } from "./createHash-D7vud8fe.js";
+import { a as isGpt6Model, i as getGpt6Variant, r as getGpt6ResponsesReasoning, t as applyGpt6RequestRules } from "./gpt6-CA0S8lOm.js";
+import { C as getOpenAiEffectiveServiceTier, D as getOpenAiPolicyRefusal, E as getOpenAiPartialOutput, F as isCustomOpenAiEndpoint, J as prepareOpenAiTools, K as prepareOpenAiReasoning, M as hasSensitiveOpenAiCachePath, N as hasSensitiveOpenAiCacheString, P as isAzureOpenAiEndpoint, R as normalizeOpenAiBillingModelName, _ as flattenResponseTool, d as appendOpenAiApiPath, f as assertOpenAiApiModel, h as classifyOpenAiGatewayStreamError, q as prepareOpenAiResponseFormat, r as OPENAI_BILLING_MODELS, u as RETIRED_OPENAI_MODEL_IDS, v as formatOpenAiError, w as getOpenAiGatewayErrorType, z as normalizeOpenAiServiceTierForWire } from "./util-CeGgoYs1.js";
+import { n as calculateObservableOpenAIToolCost, o as usesAzureOpenAiBilling, r as calculateOpenAIUsageCost } from "./billing-DstHUOON.js";
+import "./tracing-B8p6SMbW.js";
+import { t as FunctionCallbackHandler } from "./functionCallbackUtils-B_cYp7P5.js";
+import { n as getOpenRouterBillingMetadata, r as isOpenRouterEndpoint, t as calculateOpenRouterResponseCost } from "./openrouterBilling--wdhQt3U.js";
+import { n as OpenAiGenericProvider } from "./openai-Wnwbwy-M.js";
+import { n as ResponsesProcessor, r as getResponsesTokenUsage, t as normalizeResponsesInput } from "./input-F-ngQQw4.js";
+//#region src/providers/responses/stream.ts
+function getResponsesOutputText(response) {
+	if (typeof response.output_text === "string" && response.output_text.trim()) return response.output_text;
+	if (!Array.isArray(response.output)) return;
+	return response.output.flatMap((item) => {
+		if (!["message", "output_message"].includes(item?.type) || item.role && item.role !== "assistant") return [];
+		const text = Array.isArray(item.content) ? item.content.filter((part) => ["output_text", "text"].includes(part?.type) && typeof part.text === "string").map((part) => part.text).join("") : "";
+		return text.trim() ? [text] : [];
+	}).join("\n") || void 0;
+}
+function parseSseEvent(chunk, providerName, logger) {
+	const data = chunk.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+	if (!data || data === "[DONE]") return;
+	try {
+		return JSON.parse(data);
+	} catch {
+		logger.debug(`[${providerName} Responses] Ignoring malformed SSE payload`, { dataLength: data.length });
+		return;
+	}
+}
+async function readResponsesStream(response, providerName, logger, onResponse, options) {
+	if (!response.body) throw new Error(`${providerName} streaming response has no body`);
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let latestResponse;
+	let outputText = "";
+	const textByOutputIndex = /* @__PURE__ */ new Map();
+	let pendingError;
+	const processChunk = (chunk) => {
+		const event = parseSseEvent(chunk, providerName, logger);
+		if (!event) return;
+		if (event.type === "error") {
+			const code = event.error?.code ?? event.code;
+			const message = event.error?.message ?? event.message ?? "unknown stream error";
+			const error = /* @__PURE__ */ new Error(`${providerName} streaming response error${code ? ` (${code})` : ""}: ${message}`);
+			const errorResponse = {
+				status: "failed",
+				error: event.error ?? {
+					code,
+					message
+				},
+				...event.error_type ? { error_type: event.error_type } : {}
+			};
+			const classification = options?.preserveFailedOutput ? options.classifyError?.(errorResponse) : void 0;
+			if (!classification || classification === "technical") throw error;
+			pendingError = {
+				error,
+				response: errorResponse,
+				classification
+			};
+			return;
+		}
+		if (event.response && typeof event.response === "object") {
+			latestResponse = event.response;
+			onResponse?.(latestResponse);
+		} else if (Array.isArray(event.output)) latestResponse = event;
+		if (event.type === "response.output_text.delta") {
+			const delta = typeof event.delta === "string" ? event.delta : event.output_text?.delta;
+			if (typeof delta === "string") {
+				outputText += delta;
+				if (options?.preserveFailedOutput) {
+					const index = typeof event.output_index === "number" ? event.output_index : 0;
+					const partIndex = typeof event.content_index === "number" ? event.content_index : 0;
+					const content = textByOutputIndex.get(index) ?? /* @__PURE__ */ new Map();
+					content.set(partIndex, (content.get(partIndex) ?? "") + delta);
+					textByOutputIndex.set(index, content);
+				}
+			}
+		}
+	};
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const chunks = buffer.split(/\r?\n\r?\n/);
+		buffer = chunks.pop() || "";
+		for (const chunk of chunks) processChunk(chunk);
+	}
+	buffer += decoder.decode();
+	if (buffer.trim()) processChunk(buffer);
+	if (pendingError) {
+		const terminal = latestResponse?.status === "failed" ? options?.classifyError?.(latestResponse) : void 0;
+		if (terminal === "technical" || terminal !== "refusal" && terminal !== "content_policy_violation" && pendingError.classification === "potential") throw pendingError.error;
+		if (terminal !== "refusal" && terminal !== "content_policy_violation") latestResponse = {
+			...latestResponse,
+			...pendingError.response,
+			error_type: pendingError.classification
+		};
+	}
+	if (latestResponse) {
+		if (options?.preserveFailedOutput && latestResponse.status === "failed" && outputText) {
+			const streamedText = Array.from(textByOutputIndex).sort(([left], [right]) => left - right).map(([, content]) => Array.from(content).sort(([left], [right]) => left - right).map(([, text]) => text).join("")).filter((text) => text.trim()).join("\n");
+			const reportedText = getResponsesOutputText(latestResponse);
+			if (streamedText && (!reportedText || streamedText.length > reportedText.length && streamedText.startsWith(reportedText))) return {
+				...latestResponse,
+				output_text: streamedText
+			};
+		}
+		return latestResponse;
+	}
+	if (outputText) return { output: [{
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: outputText
+		}]
+	}] };
+	throw new Error(`${providerName} streaming response did not include output content`);
+}
+//#endregion
+//#region src/providers/openai/responses.ts
+function hasUnpricedAzureResponsesToolUsage(data) {
+	const output = Array.isArray(data?.output) ? data.output : [];
+	if (output.some((item) => [
+		"file_search_call",
+		"code_interpreter_call",
+		"image_generation_call"
+	].includes(item?.type))) return true;
+	const webSearch = data?.tool_usage?.web_search;
+	const requests = webSearch?.num_requests;
+	if (typeof requests === "number" && Number.isFinite(requests) && requests >= 0) return requests > 0;
+	return webSearch != null || output.some((item) => item?.type === "web_search_call");
+}
+const BACKGROUND_RESPONSE_CANCEL_TIMEOUT_MS = 1e4;
+const BACKGROUND_STREAM_CREATION_GRACE_MIN_MS = 1e3;
+const BACKGROUND_STREAM_CREATION_GRACE_MAX_MS = 3e4;
+let nextBackgroundProviderScope = 0;
+const inFlightBackgroundCreations = /* @__PURE__ */ new Map();
+const inFlightBackgroundResponses = /* @__PURE__ */ new Map();
+function isSensitiveBackgroundCacheHeader(key) {
+	return isSecretField(key) || /(?:^|[-_])(?:authorization|api[-_]?key|token|secret|signature|credential|cookie|password)(?:[-_]|$)/i.test(key);
+}
+function hasSensitiveBackgroundCacheValue(value, fieldName) {
+	if (fieldName && isSensitiveBackgroundCacheHeader(fieldName)) return value !== void 0 && value !== null && value !== "";
+	if (typeof value === "string") return hasSensitiveOpenAiCacheString(value);
+	if (Array.isArray(value)) return value.some((item) => hasSensitiveBackgroundCacheValue(item, fieldName));
+	if (value && typeof value === "object") return Object.entries(value).some(([key, nestedValue]) => hasSensitiveBackgroundCacheValue(nestedValue, key));
+	return false;
+}
+function canonicalizeBackgroundCacheValue(value, fieldName) {
+	if (Array.isArray(value)) return value.map((item) => canonicalizeBackgroundCacheValue(item, fieldName));
+	if (value && typeof value === "object") return Object.fromEntries((fieldName === "properties" ? Object.entries(value) : Object.entries(value).sort(([left], [right]) => left.localeCompare(right))).map(([key, nestedValue]) => [key, canonicalizeBackgroundCacheValue(nestedValue, key)]));
+	return value;
+}
+function getBackgroundCacheIdentity(url, request, responseId) {
+	const headerEntries = Object.entries(request.headers);
+	const cacheHeaders = headerEntries.filter(([key, value]) => !isSensitiveBackgroundCacheHeader(key) && !hasSensitiveBackgroundCacheValue(value)).map(([key, value]) => [key.toLowerCase(), value]).sort(([left], [right]) => left.localeCompare(right));
+	const hasSensitiveHeader = headerEntries.some(([key, value]) => isSensitiveBackgroundCacheHeader(key) && value.trim().length > 0);
+	const hasSensitiveHeaderValue = headerEntries.some(([key, value]) => !isSensitiveBackgroundCacheHeader(key) && hasSensitiveBackgroundCacheValue(value));
+	const hasTenantDiscriminator = cacheHeaders.some(([key, value]) => /(?:^|[-_])(?:project|tenant|account)(?:[-_]|$)/i.test(key) && value.trim().length > 0);
+	const sanitizedUrl = sanitizeUrl(url);
+	const hasSensitiveUrlCredentials = sanitizedUrl !== url;
+	let sendsToOpenAiApi = false;
+	let hasSensitiveUrlPath = false;
+	try {
+		const parsedUrl = new URL(url);
+		hasSensitiveUrlPath = hasSensitiveOpenAiCachePath(decodeURIComponent(parsedUrl.pathname));
+		sendsToOpenAiApi = parsedUrl.hostname.toLowerCase() === "api.openai.com";
+	} catch {
+		hasSensitiveUrlPath = true;
+	}
+	let parsedBody;
+	try {
+		parsedBody = JSON.parse(request.body);
+	} catch {
+		parsedBody = request.body;
+	}
+	const hasSensitiveBody = hasSensitiveBackgroundCacheValue(parsedBody);
+	return {
+		key: sha256(JSON.stringify({
+			url: hasSensitiveUrlPath ? "[sensitive]" : sanitizedUrl,
+			method: request.method,
+			headers: cacheHeaders,
+			...responseId ? { id: responseId } : { body: hasSensitiveBody ? "[sensitive]" : canonicalizeBackgroundCacheValue(parsedBody) },
+			...hasSensitiveHeader && !hasTenantDiscriminator ? { scope: request.cacheScope } : {}
+		})),
+		cacheable: !hasSensitiveBody && !hasSensitiveUrlCredentials && !hasSensitiveUrlPath && !hasSensitiveHeaderValue && (!hasSensitiveHeader || sendsToOpenAiApi && hasTenantDiscriminator),
+		coalescable: !hasSensitiveBody && !hasSensitiveUrlCredentials && !hasSensitiveUrlPath && !hasSensitiveHeaderValue && (sendsToOpenAiApi ? !request.hasPerPromptAuthorization || hasTenantDiscriminator : !hasSensitiveHeader)
+	};
+}
+async function cancelBackgroundResponse(responseId, url, { headers, getAuthHeaders }) {
+	try {
+		await fetchWithCache(appendOpenAiApiPath(url, `${encodeURIComponent(responseId)}/cancel`), {
+			method: "POST",
+			headers,
+			...getAuthHeaders ? { getAuthHeaders } : {}
+		}, BACKGROUND_RESPONSE_CANCEL_TIMEOUT_MS, "json", true, 0);
+	} catch (error) {
+		logger.warn(`Failed to cancel background response ${responseId}: ${String(error)}`);
+	}
+}
+async function pollBackgroundResponse(initial, url, authentication, timeout, maxRetries, signal, deadline = Date.now() + timeout, cancelOnStop = true) {
+	if (!initial.id) return {
+		data: initial,
+		status: 0,
+		statusText: "Error",
+		error: "Background response is missing its response ID."
+	};
+	let data = initial;
+	let status = 200;
+	let statusText = "OK";
+	let responseHeaders;
+	let firstPoll = true;
+	let deadlineSignal;
+	try {
+		while (data.status === "queued" || data.status === "in_progress") {
+			signal?.throwIfAborted();
+			if (!firstPoll) {
+				await sleep(Math.min(1e3, Math.max(0, deadline - Date.now())));
+				signal?.throwIfAborted();
+			}
+			firstPoll = false;
+			const remainingMs = deadline - Date.now();
+			if (remainingMs <= 0) {
+				if (cancelOnStop) await cancelBackgroundResponse(initial.id, url, authentication);
+				return {
+					data,
+					status: 0,
+					statusText: "Error",
+					error: `Background response ${initial.id} timed out after ${timeout}ms.`,
+					timedOut: true
+				};
+			}
+			deadlineSignal = AbortSignal.timeout(remainingMs);
+			const pollSignal = signal ? AbortSignal.any([signal, deadlineSignal]) : deadlineSignal;
+			const polled = await fetchWithCache(appendOpenAiApiPath(url, encodeURIComponent(initial.id)), {
+				method: "GET",
+				headers: authentication.headers,
+				...authentication.getAuthHeaders ? { getAuthHeaders: authentication.getAuthHeaders } : {},
+				signal: pollSignal
+			}, remainingMs, "json", true, maxRetries);
+			data = polled.data;
+			status = polled.status;
+			statusText = polled.statusText;
+			responseHeaders = polled.headers;
+			if (status < 200 || status >= 300) {
+				const shouldCancel = status >= 400 && status < 500 && ![
+					404,
+					408,
+					409,
+					410,
+					425,
+					429
+				].includes(status);
+				if (shouldCancel) await cancelBackgroundResponse(initial.id, url, authentication);
+				return {
+					data,
+					status,
+					statusText,
+					headers: responseHeaders,
+					error: `API error: ${status} ${statusText}\n${JSON.stringify(data)}`,
+					cancelled: shouldCancel
+				};
+			}
+		}
+	} catch (error) {
+		if (signal?.aborted) {
+			if (cancelOnStop) await cancelBackgroundResponse(initial.id, url, authentication);
+			throw error;
+		}
+		if (deadlineSignal?.aborted || Date.now() >= deadline) {
+			if (cancelOnStop) await cancelBackgroundResponse(initial.id, url, authentication);
+			return {
+				data,
+				status: 0,
+				statusText: "Error",
+				error: `Background response ${initial.id} timed out after ${timeout}ms.`,
+				timedOut: true
+			};
+		}
+		throw error;
+	}
+	return {
+		data,
+		status,
+		statusText,
+		headers: responseHeaders
+	};
+}
+async function createBackgroundResponseWithCancellation(url, request, timeout, bustCache, maxRetries) {
+	const signal = request.signal;
+	const cacheIdentity = getBackgroundCacheIdentity(url, request);
+	const canCoalesce = isCacheEnabled() && !bustCache && cacheIdentity.coalescable;
+	const effectiveCacheOptions = cacheIdentity.cacheable ? {
+		bust: bustCache,
+		cacheKey: cacheIdentity.key
+	} : true;
+	const cacheKey = getScopedCacheKey(cacheIdentity.key);
+	let inFlight = canCoalesce ? inFlightBackgroundCreations.get(cacheKey) : void 0;
+	if (!inFlight) {
+		const promise = fetchWithCache(url, {
+			method: request.method,
+			headers: request.headers,
+			body: request.body,
+			...request.getAuthHeaders ? { getAuthHeaders: request.getAuthHeaders } : {}
+		}, timeout, "json", effectiveCacheOptions, maxRetries);
+		inFlight = {
+			promise,
+			subscribers: 0,
+			billed: false
+		};
+		if (canCoalesce) {
+			inFlightBackgroundCreations.set(cacheKey, inFlight);
+			promise.finally(() => {
+				if (inFlightBackgroundCreations.get(cacheKey) === inFlight) inFlightBackgroundCreations.delete(cacheKey);
+			}).catch(() => {});
+		}
+	}
+	inFlight.subscribers++;
+	let released = false;
+	let onAbort;
+	const release = (aborted = false) => {
+		if (released) return;
+		released = true;
+		inFlight.subscribers--;
+		if (!aborted || inFlight.subscribers > 0) return;
+		inFlight.promise.then(async (created) => {
+			if (inFlight.subscribers > 0) return;
+			if (!canCoalesce && created.data.id && (created.data.status === "queued" || created.data.status === "in_progress")) await cancelBackgroundResponse(created.data.id, url, request);
+			await created.deleteFromCache?.();
+		}).catch((error) => {
+			logger.warn(`Failed to clean up an aborted background response: ${String(error)}`);
+		});
+	};
+	const cancellation = new Promise((_resolve, reject) => {
+		if (!signal) return;
+		onAbort = () => {
+			release(true);
+			reject(getAbortError(signal));
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		const created = await Promise.race([inFlight.promise, cancellation]);
+		if (created.cached || created.status < 200 || created.status >= 300 || created.data.status !== "completed" && created.data.status !== "incomplete") return created;
+		const shared = inFlight.billed;
+		inFlight.billed = true;
+		return shared ? {
+			...created,
+			cached: true
+		} : created;
+	} finally {
+		if (onAbort) signal?.removeEventListener("abort", onAbort);
+		release();
+	}
+}
+async function resolveBackgroundResponse(initial, url, request, timeout, maxRetries, cached, deleteFromCache, cancelOnStop, deadline = Date.now() + timeout) {
+	const polled = await pollBackgroundResponse(initial, url, request, timeout, maxRetries, request.signal, deadline, cancelOnStop);
+	if (!cached || !polled.error || polled.status !== 404 && polled.status !== 410) return polled;
+	await deleteFromCache?.();
+	const retried = await createBackgroundResponseWithCancellation(url, request, Math.max(1, deadline - Date.now()), cancelOnStop, maxRetries);
+	if (retried.status < 200 || retried.status >= 300) return {
+		data: retried.data,
+		status: retried.status,
+		statusText: retried.statusText,
+		headers: retried.headers,
+		error: `API error: ${retried.status} ${retried.statusText}\n${JSON.stringify(retried.data)}`,
+		retried: true
+	};
+	if (retried.data.status === "queued" || retried.data.status === "in_progress") return {
+		...await pollBackgroundResponse(retried.data, url, request, timeout, maxRetries, request.signal, deadline, cancelOnStop),
+		retried: true
+	};
+	return {
+		data: retried.data,
+		status: retried.status,
+		statusText: retried.statusText,
+		headers: retried.headers,
+		retried: true
+	};
+}
+async function coalesceBackgroundResponse(initial, url, request, timeout, maxRetries, cached, deleteFromCache, cancelOnStop, deadline) {
+	const cacheIdentity = getBackgroundCacheIdentity(url, request, initial.id);
+	if (!cacheIdentity.coalescable) return resolveBackgroundResponse(initial, url, request, timeout, maxRetries, cached, deleteFromCache, cancelOnStop, deadline);
+	const cacheKey = getScopedCacheKey(cacheIdentity.key);
+	let inFlight = inFlightBackgroundResponses.get(cacheKey);
+	if (!inFlight) {
+		const controller = new AbortController();
+		const promise = resolveBackgroundResponse(initial, url, {
+			...request,
+			signal: controller.signal
+		}, timeout, maxRetries, cached, deleteFromCache, cancelOnStop, deadline);
+		inFlight = {
+			promise,
+			controller,
+			subscribers: 0,
+			billed: false
+		};
+		inFlightBackgroundResponses.set(cacheKey, inFlight);
+		promise.finally(() => {
+			if (inFlightBackgroundResponses.get(cacheKey) === inFlight) inFlightBackgroundResponses.delete(cacheKey);
+		}).catch(() => {});
+	}
+	inFlight.subscribers++;
+	const callerSignal = request.signal;
+	let released = false;
+	let onAbort;
+	const release = () => {
+		if (released) return false;
+		released = true;
+		inFlight.subscribers--;
+		if (inFlight.subscribers === 0 && callerSignal?.aborted) {
+			inFlight.controller.abort(callerSignal.reason);
+			return true;
+		}
+		return false;
+	};
+	const cancellation = new Promise((_resolve, reject) => {
+		if (!callerSignal) return;
+		onAbort = () => {
+			if (release() && cancelOnStop) deleteFromCache?.();
+			reject(getAbortError(callerSignal));
+		};
+		if (callerSignal.aborted) {
+			onAbort();
+			return;
+		}
+		callerSignal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		const result = await Promise.race([inFlight.promise, cancellation]);
+		if (result.timedOut && deadline !== void 0 && Date.now() < deadline) {
+			if (inFlightBackgroundResponses.get(cacheKey) === inFlight) inFlightBackgroundResponses.delete(cacheKey);
+			release();
+			return await coalesceBackgroundResponse(result.data, url, request, timeout, maxRetries, cached, deleteFromCache, cancelOnStop, deadline);
+		}
+		if (result.error) return result;
+		const shared = inFlight.billed;
+		inFlight.billed = true;
+		return shared ? {
+			...result,
+			shared: true
+		} : result;
+	} finally {
+		if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
+		release();
+	}
+}
+var OpenAiResponsesProvider = class extends OpenAiGenericProvider {
+	functionCallbackHandler = new FunctionCallbackHandler();
+	processor;
+	backgroundCacheScope = `provider:${++nextBackgroundProviderScope}`;
+	static OPENAI_RESPONSES_MODEL_NAMES = [
+		"gpt-4o",
+		"gpt-4o-2024-08-06",
+		"gpt-4o-2024-11-20",
+		"gpt-4o-2024-05-13",
+		"gpt-4o-mini",
+		"gpt-4o-mini-2024-07-18",
+		"gpt-4.1",
+		"gpt-4.1-2025-04-14",
+		"gpt-4.1-mini",
+		"gpt-4.1-mini-2025-04-14",
+		"gpt-4.1-nano",
+		"gpt-4.1-nano-2025-04-14",
+		"gpt-5",
+		"gpt-5-2025-08-07",
+		"gpt-5-nano",
+		"gpt-5-nano-2025-08-07",
+		"gpt-5-mini",
+		"gpt-5-mini-2025-08-07",
+		"gpt-5-pro",
+		"gpt-5-pro-2025-10-06",
+		"gpt-5.1",
+		"gpt-5.1-2025-11-13",
+		"gpt-5.2",
+		"gpt-5.2-2025-12-11",
+		"gpt-5.2-pro",
+		"gpt-5.2-pro-2025-12-11",
+		"gpt-5.3-codex",
+		"gpt-6-astra",
+		"gpt-6-sol",
+		"gpt-6-luna",
+		"gpt-6.1-sol",
+		"gpt-5.6",
+		"gpt-5.6-sol",
+		"gpt-5.6-terra",
+		"gpt-5.6-luna",
+		"gpt-5.5",
+		"gpt-5.5-2026-04-23",
+		"gpt-5.5-pro",
+		"gpt-5.5-pro-2026-04-23",
+		"gpt-5.4",
+		"gpt-5.4-2026-03-05",
+		"gpt-5.4-mini",
+		"gpt-5.4-mini-2026-03-17",
+		"gpt-5.4-nano",
+		"gpt-5.4-nano-2026-03-17",
+		"gpt-5.4-pro",
+		"gpt-5.4-pro-2026-03-05",
+		"o1",
+		"o1-2024-12-17",
+		"o1-pro",
+		"o1-pro-2025-03-19",
+		"o3-pro",
+		"o3-pro-2025-06-10",
+		"o3",
+		"o3-2025-04-16",
+		"o4-mini",
+		"o4-mini-2025-04-16",
+		"o3-mini",
+		"o3-mini-2025-01-31",
+		"gpt-5-codex-mini"
+	].filter((model) => !RETIRED_OPENAI_MODEL_IDS.has(model));
+	config;
+	constructor(modelName, options = {}) {
+		super(modelName, options);
+		this.config = options.config ? { ...options.config } : {};
+		this.processor = new ResponsesProcessor({
+			modelName: this.modelName,
+			providerType: "openai",
+			functionCallbackHandler: this.functionCallbackHandler,
+			costCalculator: () => void 0
+		});
+	}
+	isReasoningModel(modelName = this.getCapabilityModelName()) {
+		return modelName === "codex-mini-latest" || super.isReasoningModel(modelName);
+	}
+	isReasoningCapabilityModel(modelName) {
+		if (modelName === this.getCapabilityModelName().replace(/(^|\/)ft:/, "$1")) return this.isReasoningModel();
+		return modelName === "codex-mini-latest" || super.isReasoningModel(modelName);
+	}
+	supportsTemperatureForCapabilityModel(modelName) {
+		return modelName === this.getCapabilityModelName().replace(/(^|\/)ft:/, "$1") ? this.supportsTemperature() : !this.isReasoningCapabilityModel(modelName);
+	}
+	getEffectiveModelName(config) {
+		const passthroughModel = config.passthrough?.model;
+		return typeof passthroughModel === "string" ? this.normalizeCapabilityModelName(passthroughModel) : this.getCapabilityModelName();
+	}
+	getBillingModelName(config) {
+		return this.getEffectiveModelName(config);
+	}
+	usesGatewayErrorFormat() {
+		return this.getGenAISystem() === "openai" && isCustomOpenAiEndpoint(this.getApiUrl());
+	}
+	getBillingUsage(data, _config) {
+		return data.usage;
+	}
+	getBillingRegion() {}
+	applyBilling(result, data, config, cached) {
+		if (this.getGenAISystem() === "openai" && isOpenRouterEndpoint(this.getApiUrl())) {
+			const { cost: _existingCost, ...unbilled } = result;
+			const cost = calculateOpenRouterResponseCost(data, config, "responses");
+			const billingMetadata = getOpenRouterBillingMetadata(data);
+			return {
+				...unbilled,
+				...cost === void 0 ? {} : { cost },
+				...billingMetadata ? { metadata: {
+					...result.metadata,
+					...billingMetadata
+				} } : {}
+			};
+		}
+		const serviceTier = data.service_tier ?? config.service_tier;
+		const modelName = this.getBillingModelName(config);
+		const unprefixedModelName = normalizeOpenAiBillingModelName(modelName);
+		const bedrockEndpoint = this.getBedrockEndpoint();
+		const isBedrock = this.getGenAISystem() === "bedrock" || bedrockEndpoint !== void 0;
+		const runtimeProfile = bedrockEndpoint === "runtime" ? /^(global|us)\.openai\.(.+)$/.exec(unprefixedModelName) : null;
+		const billingModelName = runtimeProfile?.[2] ?? (isBedrock && bedrockEndpoint !== "runtime" ? unprefixedModelName.replace(/^openai\./, "") : unprefixedModelName);
+		const regionalProcessing = bedrockEndpoint === "runtime" ? Boolean(runtimeProfile && runtimeProfile[1] !== "global") : isBedrock || this.modelName.startsWith("openai.");
+		const billingLookupModel = normalizeOpenAiBillingModelName(billingModelName);
+		const responseCost = calculateOpenAIUsageCost(billingLookupModel, config, this.getBillingUsage(data, config), {
+			apiUrl: this.getApiUrl(),
+			cachedResponse: cached,
+			provider: isBedrock ? "bedrock" : this.getGenAISystem(),
+			region: this.getBillingRegion(),
+			regionalProcessing,
+			serviceTier
+		});
+		const variant = getGpt6Variant(billingModelName);
+		if ((variant === "sol" || variant === "luna" || variant === "6.1-sol") && usesAzureOpenAiBilling(config, this.getApiUrl(), this.getGenAISystem())) {
+			const { cost: _existingCost, ...unbilled } = result;
+			return responseCost === void 0 || !cached && hasUnpricedAzureResponsesToolUsage(data) ? unbilled : {
+				...unbilled,
+				cost: responseCost
+			};
+		}
+		const observableToolCost = cached ? 0 : calculateObservableOpenAIToolCost(data, billingLookupModel, config);
+		return {
+			...result,
+			...responseCost === void 0 ? {} : { cost: responseCost + observableToolCost }
+		};
+	}
+	getBedrockEndpoint() {
+		try {
+			const hostname = new URL(this.getApiUrl()).hostname;
+			if (/^bedrock-mantle\.[a-z0-9-]+\.api\.aws$/.test(hostname)) return "mantle";
+			if (/^bedrock-runtime(?:-fips)?\.[a-z0-9-]+\.(?:amazonaws\.com|api\.aws)$/.test(hostname)) return "runtime";
+		} catch {}
+	}
+	supportsPersistedGpt6EffortUpdates() {
+		return this.getGenAISystem() !== "bedrock" && this.getBedrockEndpoint() === void 0;
+	}
+	getPolicyResponse(data, config, cached, status, statusText, headers) {
+		const policy = getOpenAiPolicyRefusal(data, this.usesGatewayErrorFormat());
+		if (!policy) return;
+		const response = data.response ?? data;
+		const billingData = {
+			...response,
+			usage: response.usage ?? data.usage
+		};
+		const partialOutput = getResponsesOutputText(response);
+		return this.applyBilling({
+			output: partialOutput === void 0 ? policy.message : getOpenAiPartialOutput(partialOutput, config.response_format?.type === "json_schema"),
+			...billingData.usage ? { tokenUsage: getResponsesTokenUsage(billingData, cached) } : {},
+			cached,
+			isRefusal: true,
+			guardrails: {
+				flagged: true,
+				...!partialOutput && policy.flaggedInput ? { flaggedInput: true } : {},
+				reason: policy.message
+			},
+			raw: response,
+			metadata: {
+				...response.id ? { responseId: response.id } : {},
+				...response.model ? { model: response.model } : {},
+				...policy.code ? { providerPolicy: { code: policy.code } } : {},
+				http: {
+					status,
+					statusText,
+					headers: headers ?? {}
+				}
+			}
+		}, billingData, config, cached);
+	}
+	getDeploymentCapabilities(config) {
+		const effectiveModelName = this.getEffectiveModelName(config);
+		const capabilityModelName = effectiveModelName.replace(/(^|\/)ft:/, "$1");
+		const isEffectiveGpt5Model = capabilityModelName.startsWith("gpt-5") || capabilityModelName.includes("/gpt-5");
+		const isEffectiveReasoningModel = this.isReasoningCapabilityModel(capabilityModelName);
+		const supportsTemperature = this.supportsTemperatureForCapabilityModel(capabilityModelName);
+		const passthroughModel = config.passthrough?.model;
+		const normalizedModelName = normalizeOpenAiBillingModelName(effectiveModelName);
+		const modelLookupName = normalizedModelName.startsWith("ft:") ? normalizedModelName.split(":")[1] : normalizedModelName;
+		const hasAzureCustomDeploymentHost = !(typeof passthroughModel === "string" && OPENAI_BILLING_MODELS.some(({ id }) => id === modelLookupName)) && [
+			config.apiHost,
+			config.apiBaseUrl,
+			this.getApiUrl()
+		].some((endpoint) => isAzureOpenAiEndpoint(endpoint));
+		const isGPT6Model = isGpt6Model(capabilityModelName);
+		const isAzureResponsesDeploymentWithReasoningConfig = hasAzureCustomDeploymentHost && (config.reasoning !== void 0 || config.reasoning_effort !== void 0);
+		const isAzureResponsesDeploymentWithVerbosityConfig = hasAzureCustomDeploymentHost && config.verbosity !== void 0;
+		return {
+			isGPT6Model,
+			isAzureResponsesDeploymentWithReasoningConfig,
+			isReasoningModel: isGPT6Model || isEffectiveReasoningModel || isAzureResponsesDeploymentWithReasoningConfig,
+			supportsVerbosity: isGPT6Model || isEffectiveGpt5Model || isAzureResponsesDeploymentWithVerbosityConfig,
+			supportsTemperature: isGPT6Model || supportsTemperature
+		};
+	}
+	async getOpenAiBody(prompt, context, callApiOptions) {
+		const promptConfig = context?.prompt?.config;
+		const mergedConfig = {
+			...this.config,
+			...promptConfig
+		};
+		const passthrough = mergedConfig.passthrough ? { ...mergedConfig.passthrough } : void 0;
+		const config = {
+			...mergedConfig,
+			passthrough
+		};
+		const effectiveServiceTier = getOpenAiEffectiveServiceTier(this.config, promptConfig);
+		let input;
+		try {
+			const parsedJson = JSON.parse(prompt);
+			if (Array.isArray(parsedJson)) input = normalizeResponsesInput(parsedJson);
+			else input = prompt;
+		} catch {
+			input = prompt;
+		}
+		const { isGPT6Model, isAzureResponsesDeploymentWithReasoningConfig, isReasoningModel, supportsVerbosity, supportsTemperature } = this.getDeploymentCapabilities(config);
+		const maxOutputTokensDefault = config.omitDefaults ? getEnvString("OPENAI_MAX_TOKENS") === void 0 ? void 0 : getEnvInt("OPENAI_MAX_TOKENS") : getEnvInt("OPENAI_MAX_TOKENS", 1024);
+		const reasoningMaxOutputTokensDefault = getEnvInt("OPENAI_MAX_COMPLETION_TOKENS") ?? getEnvInt("OPENAI_MAX_TOKENS");
+		const maxOutputTokens = config.max_output_tokens ?? (isReasoningModel ? reasoningMaxOutputTokensDefault : maxOutputTokensDefault);
+		const gpt6Reasoning = isGPT6Model ? getGpt6ResponsesReasoning(this.config, context?.prompt?.config, (value) => renderVarsInObject(value, context?.vars ?? {})) : void 0;
+		const renderedReasoning = isGPT6Model ? gpt6Reasoning : prepareOpenAiReasoning(config.reasoning, context?.vars);
+		const renderedReasoningEffort = isReasoningModel && !isGPT6Model ? renderVarsInObject(config.reasoning_effort, context?.vars ?? {}) : void 0;
+		const effectiveReasoningEffort = renderedReasoning?.effort ?? renderedReasoningEffort;
+		const hasAzureReasoningEffort = isAzureResponsesDeploymentWithReasoningConfig && effectiveReasoningEffort !== void 0 && effectiveReasoningEffort !== "none";
+		const temperatureDefault = config.omitDefaults || isGPT6Model ? getEnvString("OPENAI_TEMPERATURE") === void 0 ? void 0 : getEnvFloat("OPENAI_TEMPERATURE") : getEnvFloat("OPENAI_TEMPERATURE", 0);
+		const temperature = supportsTemperature && (isGPT6Model || !hasAzureReasoningEffort) ? config.temperature ?? temperatureDefault : void 0;
+		const reasoningEffort = isReasoningModel ? effectiveReasoningEffort : void 0;
+		const instructions = config.instructions;
+		const responseFormat = prepareOpenAiResponseFormat(config.response_format, context?.vars);
+		let textFormat;
+		if (responseFormat) {
+			if (responseFormat.type === "json_object") textFormat = { format: { type: "json_object" } };
+			else if (responseFormat.type === "json_schema") {
+				const schema = responseFormat.schema || responseFormat.json_schema?.schema;
+				textFormat = { format: {
+					type: "json_schema",
+					name: responseFormat.json_schema?.name || responseFormat.name || "response_schema",
+					schema,
+					strict: true
+				} };
+			} else textFormat = { format: { type: "text" } };
+		} else textFormat = { format: { type: "text" } };
+		if (supportsVerbosity && config.verbosity) textFormat = {
+			...textFormat,
+			verbosity: config.verbosity
+		};
+		const loadedTools = await prepareOpenAiTools(config.tools, context?.vars, callApiOptions?.abortSignal);
+		const responsesTools = Array.isArray(loadedTools) ? loadedTools.map(flattenResponseTool) : loadedTools;
+		const toolChoice = flattenResponseTool(config.tool_choice);
+		const body = {
+			model: this.modelName,
+			input,
+			...config.access_programs === void 0 ? {} : { access_programs: config.access_programs },
+			...maxOutputTokens === void 0 ? {} : { max_output_tokens: maxOutputTokens },
+			...reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {},
+			...temperature === void 0 ? {} : { temperature },
+			...instructions ? { instructions } : {},
+			...(isGPT6Model || !reasoningEffort || reasoningEffort === "none") && (config.top_p !== void 0 || getEnvString("OPENAI_TOP_P")) ? { top_p: config.top_p ?? getEnvFloat("OPENAI_TOP_P", 1) } : {},
+			...responsesTools ? { tools: responsesTools } : {},
+			...toolChoice ? { tool_choice: toolChoice } : {},
+			...config.max_tool_calls ? { max_tool_calls: config.max_tool_calls } : {},
+			...config.include === void 0 ? {} : { include: config.include },
+			...config.previous_response_id ? { previous_response_id: config.previous_response_id } : {},
+			text: textFormat,
+			...config.truncation ? { truncation: config.truncation } : {},
+			...config.metadata ? { metadata: config.metadata } : {},
+			..."parallel_tool_calls" in config ? { parallel_tool_calls: Boolean(config.parallel_tool_calls) } : {},
+			...config.stream ? { stream: config.stream } : {},
+			..."store" in config ? { store: Boolean(config.store) } : {},
+			...config.background ? { background: config.background } : {},
+			...config.webhook_url ? { webhook_url: config.webhook_url } : {},
+			...config.user ? { user: config.user } : {},
+			...config.safety_identifier === void 0 ? {} : { safety_identifier: config.safety_identifier },
+			...config.service_tier ? { service_tier: config.service_tier } : {},
+			...config.prompt_cache_key === void 0 ? {} : { prompt_cache_key: config.prompt_cache_key },
+			...config.prompt_cache_options === void 0 ? {} : { prompt_cache_options: config.prompt_cache_options },
+			...config.prompt_cache_retention === void 0 ? {} : { prompt_cache_retention: config.prompt_cache_retention },
+			...config.passthrough || {},
+			...effectiveServiceTier === void 0 || effectiveServiceTier === null ? {} : { service_tier: normalizeOpenAiServiceTierForWire(effectiveServiceTier, this.getApiUrl()) }
+		};
+		if (effectiveServiceTier === null && config.passthrough?.service_tier !== null) delete body.service_tier;
+		assertOpenAiApiModel(body.model, this.getApiUrl());
+		if (isGPT6Model) {
+			if (gpt6Reasoning) body.reasoning = gpt6Reasoning;
+			else delete body.reasoning;
+		} else if (renderedReasoning && isReasoningModel) body.reasoning = {
+			...body.reasoning,
+			...renderedReasoning
+		};
+		if ("max_tokens" in body) delete body.max_tokens;
+		applyGpt6RequestRules(body, config.passthrough?.model ?? this.getCapabilityModelName(), "responses", {
+			defaultResponsesTemperature: config.omitDefaults ? void 0 : 0,
+			supportsPersistedEffortUpdates: this.supportsPersistedGpt6EffortUpdates()
+		});
+		return {
+			body,
+			config: {
+				...config,
+				service_tier: effectiveServiceTier,
+				tools: Array.isArray(body.tools) ? body.tools : loadedTools,
+				response_format: responseFormat
+			}
+		};
+	}
+	async callApi(prompt, context, callApiOptions) {
+		if (callApiOptions?.abortSignal?.aborted) throw getAbortError(callApiOptions.abortSignal);
+		const apiKey = this.getApiKey();
+		if (this.requiresApiKey() && !apiKey) throw new Error(this.getMissingApiKeyErrorMessage());
+		const resolved = await this.getOpenAiBody(prompt, context, callApiOptions);
+		if (callApiOptions?.abortSignal?.aborted) throw getAbortError(callApiOptions.abortSignal);
+		const effectiveBody = resolved.body;
+		const asNumber = (v) => typeof v === "number" ? v : void 0;
+		const spanContext = buildChatSpanContext({
+			system: this.getGenAISystem(),
+			model: String(effectiveBody.model),
+			providerId: this.id(),
+			prompt,
+			context,
+			request: {
+				maxTokens: asNumber(effectiveBody.max_output_tokens),
+				temperature: asNumber(effectiveBody.temperature),
+				topP: asNumber(effectiveBody.top_p),
+				stopSequences: Array.isArray(effectiveBody.stop) ? effectiveBody.stop : void 0
+			}
+		});
+		return withGenAISpan({
+			...spanContext,
+			openaiApiType: "responses"
+		}, () => this.callApiInternal(context, {
+			...resolved,
+			abortSignal: callApiOptions?.abortSignal
+		}, apiKey), extractProviderResponseAttributes);
+	}
+	async callApiInternal(context, prepared, apiKey) {
+		const { body, config, abortSignal } = prepared;
+		const effectiveModelName = this.getEffectiveModelName(config);
+		const isDeepResearchModel = effectiveModelName.includes("deep-research");
+		if (isDeepResearchModel) {
+			if (!config.tools?.some((tool) => tool.type === "web_search" || tool.type === "web_search_preview" || tool.type === "file_search" && Array.isArray(tool.vector_store_ids) && tool.vector_store_ids.length > 0 || tool.type === "mcp")) return { error: `Deep research model ${effectiveModelName} requires at least one data source. Configure web_search, web_search_preview, file_search with vector_store_ids, or an MCP tool.` };
+			const mcpTools = config.tools?.filter((tool) => tool.type === "mcp") || [];
+			for (const mcpTool of mcpTools) if (mcpTool.require_approval !== "never") return { error: `Deep research model ${effectiveModelName} requires MCP tools to have require_approval: 'never'. Update your MCP tool configuration:\ntools:\n  - type: mcp\n    require_approval: never` };
+		}
+		let timeout = getRequestTimeoutMs();
+		const isGpt5ProModel = /(^|\/)gpt-5(?:\.\d+)?-pro(?:-|$)/.test(effectiveModelName);
+		if (isDeepResearchModel || isGpt5ProModel || body.background === true) {
+			const evalTimeout = getEnvInt("PROMPTFOO_EVAL_TIMEOUT_MS", 0);
+			timeout = evalTimeout > 0 ? evalTimeout : LONG_RUNNING_MODEL_TIMEOUT_MS;
+			logger.debug(`Using timeout of ${timeout}ms for long-running model ${effectiveModelName}`);
+		}
+		let data;
+		let status;
+		let statusText;
+		let cached = false;
+		let deleteFromCache;
+		let updateCache;
+		let responseHeaders;
+		let pollingBackground = false;
+		try {
+			const url = appendOpenAiApiPath(this.getApiUrl(), "responses");
+			const backgroundDeadline = body.background && !body.stream ? Date.now() + timeout : void 0;
+			const customHeaders = this.getOpenAiRequestHeaders(config.headers);
+			const hasCustomHeader = (name) => Object.keys(customHeaders).some((header) => header.toLowerCase() === name);
+			const buildHeaders = (key) => ({
+				...hasCustomHeader("content-type") ? {} : { "Content-Type": "application/json" },
+				...key && !hasCustomHeader("authorization") ? { Authorization: `Bearer ${key}` } : {},
+				...customHeaders
+			});
+			const getAuthHeaders = this.getRequestAuthentication();
+			const request = {
+				method: "POST",
+				headers: buildHeaders(getAuthHeaders ? void 0 : apiKey),
+				...getAuthHeaders ? { getAuthHeaders } : {},
+				body: JSON.stringify(body),
+				cacheScope: this.backgroundCacheScope,
+				hasPerPromptAuthorization: Object.keys(context?.prompt?.config?.headers ?? {}).some((header) => header.toLowerCase() === "authorization"),
+				...abortSignal ? { signal: abortSignal } : {}
+			};
+			if (body.stream && body.background) {
+				let backgroundResponseId;
+				let streamAccepted = false;
+				let streamTimedOut = false;
+				let streamCreationGraceHandle;
+				const controller = new AbortController();
+				let rejectPendingCreation;
+				const pendingCreationCancellation = new Promise((_resolve, reject) => {
+					rejectPendingCreation = reject;
+				});
+				const startStreamCreationGrace = () => {
+					if (streamCreationGraceHandle) return;
+					streamCreationGraceHandle = setTimeout(() => controller.abort(), Math.min(Math.max(timeout, BACKGROUND_STREAM_CREATION_GRACE_MIN_MS), BACKGROUND_STREAM_CREATION_GRACE_MAX_MS));
+				};
+				const timeoutHandle = setTimeout(() => {
+					streamTimedOut = true;
+					if (streamAccepted && !backgroundResponseId) {
+						rejectPendingCreation?.(/* @__PURE__ */ new Error(`OpenAI streaming response timed out after ${timeout}ms`));
+						startStreamCreationGrace();
+						return;
+					}
+					controller.abort();
+				}, timeout);
+				const abortStream = () => {
+					if (backgroundResponseId) {
+						controller.abort(abortSignal?.reason);
+						return;
+					}
+					const stopStreamCreation = () => {
+						if (backgroundResponseId || !streamAccepted) {
+							controller.abort(abortSignal?.reason);
+							return;
+						}
+						if (abortSignal) {
+							startStreamCreationGrace();
+							rejectPendingCreation?.(getAbortError(abortSignal));
+						}
+					};
+					if (streamAccepted) stopStreamCreation();
+					else queueMicrotask(stopStreamCreation);
+				};
+				abortSignal?.addEventListener("abort", abortStream, { once: true });
+				const streamCompletion = (async () => {
+					try {
+						const response = await fetchWithRetries(url, {
+							method: request.method,
+							headers: request.headers,
+							body: request.body,
+							...request.getAuthHeaders ? { getAuthHeaders: request.getAuthHeaders } : {},
+							signal: controller.signal
+						}, timeout, config.maxRetries);
+						let responseData;
+						if (response.status >= 200 && response.status < 300) {
+							streamAccepted = true;
+							responseData = await readResponsesStream(response, "OpenAI", logger, (streamedResponse) => {
+								if (typeof streamedResponse.id === "string") {
+									backgroundResponseId = streamedResponse.id;
+									if (abortSignal?.aborted || streamTimedOut) controller.abort(abortSignal?.reason);
+								}
+							}, {
+								preserveFailedOutput: this.usesGatewayErrorFormat(),
+								classifyError: classifyOpenAiGatewayStreamError
+							});
+						} else {
+							const text = await response.text();
+							try {
+								responseData = JSON.parse(text);
+							} catch {
+								responseData = text;
+							}
+						}
+						return {
+							data: responseData,
+							status: response.status,
+							statusText: response.statusText,
+							headers: Object.fromEntries(response.headers.entries())
+						};
+					} catch (err) {
+						if (backgroundResponseId) await cancelBackgroundResponse(backgroundResponseId, url, request);
+						if (controller.signal.aborted && !abortSignal?.aborted) throw new Error(`OpenAI streaming response timed out after ${timeout}ms`);
+						throw err;
+					} finally {
+						clearTimeout(timeoutHandle);
+						clearTimeout(streamCreationGraceHandle);
+						abortSignal?.removeEventListener("abort", abortStream);
+					}
+				})();
+				({data, status, statusText, headers: responseHeaders} = await Promise.race([streamCompletion, pendingCreationCancellation]));
+			} else if (body.stream) {
+				const controller = new AbortController();
+				const timeoutHandle = setTimeout(() => controller.abort(), timeout);
+				const signal = abortSignal ? AbortSignal.any([controller.signal, abortSignal]) : controller.signal;
+				try {
+					const response = await fetchWithCache(url, {
+						...request,
+						signal
+					}, timeout, "text", true, config.maxRetries);
+					status = response.status;
+					statusText = response.statusText;
+					responseHeaders = response.headers;
+					if (status >= 200 && status < 300) data = await readResponsesStream(new Response(response.data), "OpenAI", logger, void 0, {
+						preserveFailedOutput: this.usesGatewayErrorFormat(),
+						classifyError: classifyOpenAiGatewayStreamError
+					});
+					else try {
+						data = JSON.parse(response.data);
+					} catch {
+						data = response.data;
+					}
+				} catch (err) {
+					if (controller.signal.aborted) throw new Error(`OpenAI streaming response timed out after ${timeout}ms`);
+					throw err;
+				} finally {
+					clearTimeout(timeoutHandle);
+				}
+			} else ({data, cached, status, statusText, deleteFromCache, updateCache, headers: responseHeaders} = body.background ? await createBackgroundResponseWithCancellation(url, request, timeout, this.shouldBustCache(context), config.maxRetries) : await fetchWithCache(url, {
+				method: request.method,
+				headers: request.headers,
+				body: request.body,
+				...request.getAuthHeaders ? { getAuthHeaders: request.getAuthHeaders } : {},
+				...request.signal ? { signal: request.signal } : {}
+			}, timeout, "json", this.shouldBustCache(context), config.maxRetries));
+			const policyResponse = this.getPolicyResponse(data, config, cached, status, statusText, responseHeaders);
+			if (policyResponse) return policyResponse;
+			if (status < 200 || status >= 300) {
+				const errorMessage = `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}`;
+				if (typeof data === "object" && data?.error?.code === "invalid_prompt" && !isOpenRouterEndpoint(this.getApiUrl()) && (!this.usesGatewayErrorFormat() || getOpenAiGatewayErrorType(data) === void 0)) return {
+					output: errorMessage,
+					tokenUsage: data?.usage ? getResponsesTokenUsage(data, cached) : void 0,
+					isRefusal: true,
+					metadata: { http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					} }
+				};
+				return {
+					error: errorMessage,
+					metadata: { http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					} }
+				};
+			}
+			if (body.background && (data.status === "queued" || data.status === "in_progress")) {
+				pollingBackground = true;
+				const cancelOnStop = !isCacheEnabled() || Boolean(this.shouldBustCache(context)) || !getBackgroundCacheIdentity(url, request, data.id).cacheable;
+				const polled = await coalesceBackgroundResponse(data, url, request, timeout, config.maxRetries, cached, deleteFromCache, cancelOnStop, backgroundDeadline);
+				if (polled.shared) cached = true;
+				else if (!polled.error && (polled.data.status === "completed" || polled.data.status === "incomplete")) {
+					const billingIdentity = getBackgroundCacheIdentity(url, request, polled.data.id);
+					cached = billingIdentity.cacheable && isCacheEnabled() && !this.shouldBustCache(context) && !claimCacheKeyOnce(`openai:background-billing:${billingIdentity.key}`);
+				}
+				data = polled.data;
+				status = polled.status;
+				statusText = polled.statusText;
+				responseHeaders = polled.headers;
+				const polledPolicy = this.getPolicyResponse(data, config, cached, status, statusText, responseHeaders);
+				if (polledPolicy) {
+					await deleteFromCache?.();
+					return polledPolicy;
+				}
+				if (!polled.error && (data.status === "completed" || data.status === "incomplete")) await updateCache?.(data, status, statusText, responseHeaders);
+				if (polled.error) {
+					if (polled.status === 0 && cancelOnStop || polled.cancelled) await deleteFromCache?.();
+					return {
+						error: polled.error,
+						metadata: { http: {
+							status,
+							statusText,
+							headers: responseHeaders ?? {}
+						} }
+					};
+				}
+			}
+			if (body.background && (data.status === "cancelled" || data.status === "failed")) {
+				await deleteFromCache?.();
+				const upstreamError = data.error?.message;
+				return {
+					error: upstreamError ? `Background response ${data.id} ${data.status}: ${upstreamError}` : `Background response ${data.id} was ${data.status}.`,
+					metadata: { http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					} }
+				};
+			}
+		} catch (err) {
+			if (isAbortError(err) || abortSignal?.aborted) throw abortSignal?.aborted ? getAbortError(abortSignal) : err;
+			if (err instanceof HttpRateLimitError) return {
+				error: formatRateLimitErrorMessage(err),
+				metadata: {
+					rateLimitKind: err.kind,
+					http: {
+						status: err.status,
+						statusText: err.statusText,
+						headers: err.headers ?? {}
+					}
+				}
+			};
+			logger.error(`API call error: ${String(err)}`);
+			if (!pollingBackground) await deleteFromCache?.();
+			return {
+				error: `API call error: ${String(err)}`,
+				metadata: { http: {
+					status: 0,
+					statusText: "Error",
+					headers: responseHeaders ?? {}
+				} }
+			};
+		}
+		if (data.error?.message) {
+			await deleteFromCache?.();
+			return {
+				error: formatOpenAiError(data),
+				metadata: { http: {
+					status,
+					statusText,
+					headers: responseHeaders ?? {}
+				} }
+			};
+		}
+		const result = await this.processor.processResponseOutput(data, config, cached, { suppressReasoningOutput: Boolean(body.stream) });
+		const billedResult = this.applyBilling(result, data, config, cached);
+		return {
+			...billedResult,
+			metadata: {
+				...billedResult.metadata,
+				http: {
+					status,
+					statusText,
+					headers: responseHeaders ?? {}
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { readResponsesStream as n, OpenAiResponsesProvider as t };
+
+//# sourceMappingURL=responses-BMbaUXQI.js.map