promptfoo 0.125.0 → 0.125.1

package/dist/src/responses-CwgjeuOg.cjs

@@ -1,1109 +0,0 @@
-const require_logger = require("./logger-DXUHJBHJ.cjs");
-require("./dataUrl-CGsBT7UZ.cjs");
-const require_fetch = require("./fetch-DYte6oQX.cjs");
-const require_shared = require("./shared-D9Bf3UgD.cjs");
-const require_time = require("./time-CY7bOv6D.cjs");
-const require_render = require("./render-j-UNQw7s.cjs");
-const require_genaiTracer = require("./genaiTracer-C32xFIB8.cjs");
-const require_cache = require("./cache-DpuIzPxh.cjs");
-const require_createHash = require("./createHash-sm6Q6LWg.cjs");
-const require_gpt6 = require("./gpt6-mD0YWDzt.cjs");
-const require_util = require("./util-CbYgIWBp.cjs");
-const require_billing = require("./billing-ZA1NkqAK.cjs");
-require("./tracing-DL4_JDxy.cjs");
-const require_functionCallbackUtils = require("./functionCallbackUtils-ByWkmVud.cjs");
-const require_openrouterBilling = require("./openrouterBilling-_forjO-_.cjs");
-const require_openai = require("./openai-BwwgDeER.cjs");
-const require_input = require("./input-CY0CGCwl.cjs");
-//#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 require_logger.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 require_util.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 = require_logger.sanitizeUrl(url);
-	const hasSensitiveUrlCredentials = sanitizedUrl !== url;
-	let sendsToOpenAiApi = false;
-	let hasSensitiveUrlPath = false;
-	try {
-		const parsedUrl = new URL(url);
-		hasSensitiveUrlPath = require_util.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: require_createHash.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 require_cache.fetchWithCache(require_util.appendOpenAiApiPath(url, `${encodeURIComponent(responseId)}/cancel`), {
-			method: "POST",
-			headers,
-			...getAuthHeaders ? { getAuthHeaders } : {}
-		}, BACKGROUND_RESPONSE_CANCEL_TIMEOUT_MS, "json", true, 0);
-	} catch (error) {
-		require_logger.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 require_time.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 require_cache.fetchWithCache(require_util.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 = require_cache.isCacheEnabled() && !bustCache && cacheIdentity.coalescable;
-	const effectiveCacheOptions = cacheIdentity.cacheable ? {
-		bust: bustCache,
-		cacheKey: cacheIdentity.key
-	} : true;
-	const cacheKey = require_cache.getScopedCacheKey(cacheIdentity.key);
-	let inFlight = canCoalesce ? inFlightBackgroundCreations.get(cacheKey) : void 0;
-	if (!inFlight) {
-		const promise = require_cache.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) => {
-			require_logger.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(require_fetch.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 = require_cache.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(require_fetch.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 require_openai.OpenAiGenericProvider {
-	functionCallbackHandler = new require_functionCallbackUtils.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) => !require_util.RETIRED_OPENAI_MODEL_IDS.has(model));
-	config;
-	constructor(modelName, options = {}) {
-		super(modelName, options);
-		this.config = options.config ? { ...options.config } : {};
-		this.processor = new require_input.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" && require_util.isCustomOpenAiEndpoint(this.getApiUrl());
-	}
-	getBillingUsage(data, _config) {
-		return data.usage;
-	}
-	getBillingRegion() {}
-	applyBilling(result, data, config, cached) {
-		if (this.getGenAISystem() === "openai" && require_openrouterBilling.isOpenRouterEndpoint(this.getApiUrl())) {
-			const { cost: _existingCost, ...unbilled } = result;
-			const cost = require_openrouterBilling.calculateOpenRouterResponseCost(data, config, "responses");
-			const billingMetadata = require_openrouterBilling.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 = require_util.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 = require_util.normalizeOpenAiBillingModelName(billingModelName);
-		const responseCost = require_billing.calculateOpenAIUsageCost(billingLookupModel, config, this.getBillingUsage(data, config), {
-			apiUrl: this.getApiUrl(),
-			cachedResponse: cached,
-			provider: isBedrock ? "bedrock" : this.getGenAISystem(),
-			region: this.getBillingRegion(),
-			regionalProcessing,
-			serviceTier
-		});
-		const variant = require_gpt6.getGpt6Variant(billingModelName);
-		if ((variant === "sol" || variant === "luna" || variant === "6.1-sol") && require_billing.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 : require_billing.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 = require_util.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 : require_util.getOpenAiPartialOutput(partialOutput, config.response_format?.type === "json_schema"),
-			...billingData.usage ? { tokenUsage: require_input.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 = require_util.normalizeOpenAiBillingModelName(effectiveModelName);
-		const modelLookupName = normalizedModelName.startsWith("ft:") ? normalizedModelName.split(":")[1] : normalizedModelName;
-		const hasAzureCustomDeploymentHost = !(typeof passthroughModel === "string" && require_util.OPENAI_BILLING_MODELS.some(({ id }) => id === modelLookupName)) && [
-			config.apiHost,
-			config.apiBaseUrl,
-			this.getApiUrl()
-		].some((endpoint) => require_util.isAzureOpenAiEndpoint(endpoint));
-		const isGPT6Model = require_gpt6.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 = require_util.getOpenAiEffectiveServiceTier(this.config, promptConfig);
-		let input;
-		try {
-			const parsedJson = JSON.parse(prompt);
-			if (Array.isArray(parsedJson)) input = require_input.normalizeResponsesInput(parsedJson);
-			else input = prompt;
-		} catch {
-			input = prompt;
-		}
-		const { isGPT6Model, isAzureResponsesDeploymentWithReasoningConfig, isReasoningModel, supportsVerbosity, supportsTemperature } = this.getDeploymentCapabilities(config);
-		const maxOutputTokensDefault = config.omitDefaults ? require_logger.getEnvString("OPENAI_MAX_TOKENS") === void 0 ? void 0 : require_logger.getEnvInt("OPENAI_MAX_TOKENS") : require_logger.getEnvInt("OPENAI_MAX_TOKENS", 1024);
-		const reasoningMaxOutputTokensDefault = require_logger.getEnvInt("OPENAI_MAX_COMPLETION_TOKENS") ?? require_logger.getEnvInt("OPENAI_MAX_TOKENS");
-		const maxOutputTokens = config.max_output_tokens ?? (isReasoningModel ? reasoningMaxOutputTokensDefault : maxOutputTokensDefault);
-		const gpt6Reasoning = isGPT6Model ? require_gpt6.getGpt6ResponsesReasoning(this.config, context?.prompt?.config, (value) => require_render.renderVarsInObject(value, context?.vars ?? {})) : void 0;
-		const renderedReasoning = isGPT6Model ? gpt6Reasoning : require_util.prepareOpenAiReasoning(config.reasoning, context?.vars);
-		const renderedReasoningEffort = isReasoningModel && !isGPT6Model ? require_render.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 ? require_logger.getEnvString("OPENAI_TEMPERATURE") === void 0 ? void 0 : require_logger.getEnvFloat("OPENAI_TEMPERATURE") : require_logger.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 = require_util.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 require_util.prepareOpenAiTools(config.tools, context?.vars, callApiOptions?.abortSignal);
-		const responsesTools = Array.isArray(loadedTools) ? loadedTools.map(require_util.flattenResponseTool) : loadedTools;
-		const toolChoice = require_util.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 || require_logger.getEnvString("OPENAI_TOP_P")) ? { top_p: config.top_p ?? require_logger.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: require_util.normalizeOpenAiServiceTierForWire(effectiveServiceTier, this.getApiUrl()) }
-		};
-		if (effectiveServiceTier === null && config.passthrough?.service_tier !== null) delete body.service_tier;
-		require_util.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;
-		require_gpt6.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 require_fetch.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 require_fetch.getAbortError(callApiOptions.abortSignal);
-		const effectiveBody = resolved.body;
-		const asNumber = (v) => typeof v === "number" ? v : void 0;
-		const spanContext = require_genaiTracer.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 require_genaiTracer.withGenAISpan({
-			...spanContext,
-			openaiApiType: "responses"
-		}, () => this.callApiInternal(context, {
-			...resolved,
-			abortSignal: callApiOptions?.abortSignal
-		}, apiKey), require_genaiTracer.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 = require_shared.getRequestTimeoutMs();
-		const isGpt5ProModel = /(^|\/)gpt-5(?:\.\d+)?-pro(?:-|$)/.test(effectiveModelName);
-		if (isDeepResearchModel || isGpt5ProModel || body.background === true) {
-			const evalTimeout = require_logger.getEnvInt("PROMPTFOO_EVAL_TIMEOUT_MS", 0);
-			timeout = evalTimeout > 0 ? evalTimeout : require_shared.LONG_RUNNING_MODEL_TIMEOUT_MS;
-			require_logger.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 = require_util.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?.(require_fetch.getAbortError(abortSignal));
-						}
-					};
-					if (streamAccepted) stopStreamCreation();
-					else queueMicrotask(stopStreamCreation);
-				};
-				abortSignal?.addEventListener("abort", abortStream, { once: true });
-				const streamCompletion = (async () => {
-					try {
-						const response = await require_fetch.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", require_logger.logger, (streamedResponse) => {
-								if (typeof streamedResponse.id === "string") {
-									backgroundResponseId = streamedResponse.id;
-									if (abortSignal?.aborted || streamTimedOut) controller.abort(abortSignal?.reason);
-								}
-							}, {
-								preserveFailedOutput: this.usesGatewayErrorFormat(),
-								classifyError: require_util.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 require_cache.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", require_logger.logger, void 0, {
-						preserveFailedOutput: this.usesGatewayErrorFormat(),
-						classifyError: require_util.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 require_cache.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" && !require_openrouterBilling.isOpenRouterEndpoint(this.getApiUrl()) && (!this.usesGatewayErrorFormat() || require_util.getOpenAiGatewayErrorType(data) === void 0)) return {
-					output: errorMessage,
-					tokenUsage: data?.usage ? require_input.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 = !require_cache.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 && require_cache.isCacheEnabled() && !this.shouldBustCache(context) && !require_cache.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 (require_fetch.isAbortError(err) || abortSignal?.aborted) throw abortSignal?.aborted ? require_fetch.getAbortError(abortSignal) : err;
-			if (err instanceof require_fetch.HttpRateLimitError) return {
-				error: require_fetch.formatRateLimitErrorMessage(err),
-				metadata: {
-					rateLimitKind: err.kind,
-					http: {
-						status: err.status,
-						statusText: err.statusText,
-						headers: err.headers ?? {}
-					}
-				}
-			};
-			require_logger.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: require_util.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
-Object.defineProperty(exports, "OpenAiResponsesProvider", {
-	enumerable: true,
-	get: function() {
-		return OpenAiResponsesProvider;
-	}
-});
-Object.defineProperty(exports, "readResponsesStream", {
-	enumerable: true,
-	get: function() {
-		return readResponsesStream;
-	}
-});
-
-//# sourceMappingURL=responses-CwgjeuOg.cjs.map