promptfoo 0.125.0 → 0.125.1

package/dist/src/chat-ClTFM3qq.js

@@ -0,0 +1,934 @@
+import { J as getEnvInt, X as getEnvString, o as logger, q as getEnvFloat } from "./logger-Gff7RMNF.js";
+import "./dataUrl-DBMifX6C.js";
+import { O as formatRateLimitErrorMessage, S as DEFINITIVE_BILLING_ERROR_CODES, w as HttpRateLimitError } from "./fetch-B5KxZuKu.js";
+import { S as isCallerAbortError, _ as transformToolChoice, a as getRequestTimeoutMs, f as parseChatPrompt, h as throwIfAborted, y as waitForPromiseWithAbort } from "./shared-BBI-NXjW.js";
+import { c as extractProviderResponseAttributes, h as withGenAISpan } from "./genaiTracer-CuSjHi4t.js";
+import { i as fetchWithCache } from "./cache-DSm6t1MZ.js";
+import { n as renderVarsInObject } from "./render-DuOHcYot.js";
+import { a as isGpt6Model, n as getGpt6ChatReasoningEffort, o as resolveGpt6ChatOutputCap, t as applyGpt6RequestRules } from "./gpt6-CA0S8lOm.js";
+import { C as getOpenAiEffectiveServiceTier, D as getOpenAiPolicyRefusal, E as getOpenAiPartialOutput, F as isCustomOpenAiEndpoint, G as prepareOpenAiFunctions, I as isOpenAiErrorOnlyResponse, J as prepareOpenAiTools, K as prepareOpenAiReasoning, R as normalizeOpenAiBillingModelName, S as getOpenAiChatChoiceError, T as getOpenAiGatewayProviderCode, U as validateFunctionCall, W as isOpenAiJsonSchemaFormat, d as appendOpenAiApiPath, f as assertOpenAiApiModel, i as OPENAI_CHAT_MODELS, k as getTokenUsage, q as prepareOpenAiResponseFormat, v as formatOpenAiError, w as getOpenAiGatewayErrorType, z as normalizeOpenAiServiceTierForWire } from "./util-CsTD_ROg.js";
+import { r as calculateOpenAIUsageCost } from "./billing-Gg_jbkR9.js";
+import "./tracing-CfUes1dH.js";
+import { n as normalizeFinishReason, t as FINISH_REASON_MAP } from "./finishReason-BixMIdSI.js";
+import { c as normalizeMcpToolContent, i as getMcpErrorMessage, o as isMcpErrorResult } from "./util-DMNFhk47.js";
+import { t as MCPClient } from "./client-mRs2UvH9.js";
+import { i as transformMCPToolsToOpenAi } from "./transform-DIOIQDmM.js";
+import { n as executeProviderFunctionCallback, r as loadProviderCallbackFromFileUrl } from "./functionCallbackUtils-BfXnPo0o.js";
+import { n as getOpenRouterBillingMetadata, r as isOpenRouterEndpoint, t as calculateOpenRouterResponseCost } from "./openrouterBilling--wdhQt3U.js";
+import { n as OpenAiGenericProvider } from "./openai-TU3iAci7.js";
+//#region src/util/fetch/responseHeadersObserver.ts
+const CALLER_ERROR_RESPONSE = Symbol("responseHeadersCallerErrorResponse");
+function markResponseHeadersObserverErrorResponse(response) {
+	Object.defineProperty(response, CALLER_ERROR_RESPONSE, { value: true });
+	return response;
+}
+function isResponseHeadersObserverErrorResponse(response) {
+	return typeof response === "object" && response !== null && response[CALLER_ERROR_RESPONSE] === true;
+}
+/** Copy private caller-exception provenance when the same error response is projected. */
+function preserveResponseHeadersObserverErrorResponse(source, response) {
+	if (isResponseHeadersObserverErrorResponse(source)) markResponseHeadersObserverErrorResponse(response);
+	return response;
+}
+const OWNER = Symbol("rateLimitResponseHeadersObserver");
+const CALLER_ERRORS = Symbol("responseHeadersCallerErrors");
+function ownedObserver(record) {
+	const observer = (...args) => {
+		let observed = record.observe(args, false);
+		let caller = record.caller;
+		const owners = [record];
+		while (caller) {
+			const inherited = caller[OWNER];
+			if (!inherited) {
+				try {
+					caller(...args);
+				} catch (error) {
+					for (const owner of owners) owner.errors.add(error);
+					throw error;
+				}
+				break;
+			}
+			if (inherited.owner === record.owner) observed = inherited.observe(args, observed);
+			owners.push(inherited);
+			caller = inherited.caller;
+		}
+	};
+	observer[OWNER] = record;
+	observer[CALLER_ERRORS] = record.errors;
+	return observer;
+}
+function createResponseHeadersObserver(owner, observe) {
+	return ownedObserver({
+		owner,
+		observe,
+		errors: /* @__PURE__ */ new Set()
+	});
+}
+function composeResponseHeadersObservers(observer, caller) {
+	if (!caller) return observer;
+	const record = observer[OWNER];
+	if (record) return ownedObserver({
+		...record,
+		caller
+	});
+	const errors = /* @__PURE__ */ new Set();
+	const combined = (...args) => {
+		observer(...args);
+		try {
+			caller(...args);
+		} catch (error) {
+			errors.add(error);
+			throw error;
+		}
+	};
+	combined[CALLER_ERRORS] = errors;
+	return combined;
+}
+function isResponseHeadersObserverError(observer, error) {
+	return observer?.[CALLER_ERRORS]?.has(error) ?? false;
+}
+/** Retain the provider's existing diagnostic when it converts a caller exception. */
+function preserveResponseHeadersObserverError(observer, error, response) {
+	if (isResponseHeadersObserverError(observer, error)) markResponseHeadersObserverErrorResponse(response);
+	return response;
+}
+//#endregion
+//#region src/providers/openai/chat.ts
+function getOpenAiGatewayRateLimitKind(data) {
+	const providerCode = getOpenAiGatewayProviderCode(data);
+	if (providerCode && DEFINITIVE_BILLING_ERROR_CODES.has(providerCode.toLowerCase())) return "quota";
+	return getOpenAiGatewayErrorType(data) === "rate_limit_exceeded" ? "rate_limit" : void 0;
+}
+function getOpenAiRateLimitResponse(error, responseHeaders) {
+	if (!(error instanceof HttpRateLimitError)) return;
+	return {
+		error: formatRateLimitErrorMessage(error),
+		metadata: {
+			rateLimitKind: error.kind,
+			http: {
+				status: error.status,
+				statusText: error.statusText,
+				headers: error.headers ?? responseHeaders ?? {}
+			}
+		}
+	};
+}
+function getChatSearchCitations(annotations, output) {
+	if (!Array.isArray(annotations)) return [];
+	return annotations.flatMap((annotation) => {
+		const citation = annotation?.type === "url_citation" ? annotation.url_citation : void 0;
+		if (typeof citation?.url !== "string" || !/^https?:\/\//i.test(citation.url)) return [];
+		const excerpt = typeof output === "string" && Number.isInteger(citation.start_index) && Number.isInteger(citation.end_index) ? output.slice(citation.start_index, citation.end_index + 1).trim() : "";
+		const title = typeof citation.title === "string" ? citation.title.trim() : "";
+		return [{
+			url: citation.url,
+			content: [title, excerpt].filter(Boolean).join(": ") || citation.url
+		}];
+	});
+}
+function getChatSearchSurcharge(modelName) {
+	const billingModelName = normalizeOpenAiBillingModelName(modelName);
+	if (billingModelName.includes("/")) return 0;
+	if (/^gpt-5-search-api(?:-|$)/.test(billingModelName)) return .01;
+	if (/^gpt-4o(?:-mini)?-search-preview(?:-|$)/.test(billingModelName)) return .025;
+	return 0;
+}
+function getOpenRouterPassthrough(config) {
+	const passthrough = config?.passthrough;
+	return passthrough && typeof passthrough === "object" && !Array.isArray(passthrough) ? passthrough : {};
+}
+function getOpenRouterReasoningControl(config, vars = {}) {
+	const passthrough = getOpenRouterPassthrough(config);
+	const efforts = [
+		["flat", config?.reasoning_effort],
+		["flat", passthrough.reasoning_effort],
+		["nested", passthrough.reasoning === null ? null : passthrough.reasoning?.effort]
+	];
+	for (const [kind, configured] of efforts) {
+		if (configured === void 0) continue;
+		const value = renderVarsInObject(configured, vars);
+		if (value === null || value === "") return { kind: "reset" };
+		if (value !== void 0) return {
+			kind,
+			value
+		};
+	}
+	const budget = renderVarsInObject(passthrough.reasoning?.max_tokens, vars);
+	if (budget === null) return { kind: "reset" };
+	if (budget !== void 0) return {
+		kind: "budget",
+		value: budget
+	};
+	const enabled = renderVarsInObject(passthrough.reasoning?.enabled, vars);
+	if (typeof enabled === "boolean") return {
+		kind: "enabled",
+		value: enabled
+	};
+}
+function reconcileOpenRouterReasoning(body, providerConfig, promptConfig, vars) {
+	const providerReasoning = getOpenRouterPassthrough(providerConfig).reasoning;
+	const promptReasoning = getOpenRouterPassthrough(promptConfig).reasoning;
+	const reasoning = promptReasoning !== null && (providerReasoning != null || promptReasoning != null) ? {
+		...providerReasoning,
+		...promptReasoning
+	} : void 0;
+	const control = getOpenRouterReasoningControl(promptConfig, vars) ?? getOpenRouterReasoningControl(providerConfig, vars);
+	if (!control) {
+		if (typeof body.reasoning_effort === "function") delete body.reasoning_effort;
+		if (reasoning) {
+			if (typeof reasoning.effort === "function") delete reasoning.effort;
+			if (typeof reasoning.max_tokens === "function") delete reasoning.max_tokens;
+			body.reasoning = reasoning;
+		}
+		return;
+	}
+	if (control.kind === "reset") {
+		delete body.reasoning_effort;
+		if (reasoning) {
+			delete reasoning.effort;
+			delete reasoning.enabled;
+			delete reasoning.max_tokens;
+		}
+		if (reasoning && Object.keys(reasoning).length) body.reasoning = reasoning;
+		else delete body.reasoning;
+		return;
+	}
+	if (control.kind === "enabled") {
+		const normalizedReasoning = {
+			...reasoning,
+			enabled: control.value
+		};
+		delete normalizedReasoning.effort;
+		delete normalizedReasoning.max_tokens;
+		body.reasoning = normalizedReasoning;
+		delete body.reasoning_effort;
+		return;
+	}
+	if (control.kind === "budget") {
+		const normalizedReasoning = {
+			...reasoning,
+			max_tokens: control.value
+		};
+		delete normalizedReasoning.effort;
+		if (normalizedReasoning.enabled === false) delete normalizedReasoning.enabled;
+		body.reasoning = normalizedReasoning;
+		delete body.reasoning_effort;
+		return;
+	}
+	const effort = control.value;
+	delete reasoning?.max_tokens;
+	if (reasoning && typeof reasoning.enabled === "boolean" && reasoning.enabled === (effort === "none")) delete reasoning.enabled;
+	if (reasoning && (control.kind === "nested" || Object.prototype.hasOwnProperty.call(reasoning, "effort"))) {
+		body.reasoning = {
+			...reasoning,
+			effort
+		};
+		delete body.reasoning_effort;
+	} else {
+		body.reasoning_effort = effort;
+		if (reasoning && Object.keys(reasoning).length) body.reasoning = reasoning;
+		else if (reasoning || promptReasoning === null) delete body.reasoning;
+	}
+}
+var OpenAiChatCompletionProvider = class OpenAiChatCompletionProvider extends OpenAiGenericProvider {
+	usesOpenRouter() {
+		const system = this.getGenAISystem();
+		return system === "openrouter" || system === "openai" && isOpenRouterEndpoint(this.getApiUrl());
+	}
+	usesGatewayErrorFormat() {
+		const system = this.getGenAISystem();
+		return system === "openrouter" || system === "openai" && isCustomOpenAiEndpoint(this.getApiUrl());
+	}
+	getAudioInputFormat() {
+		const model = this.config.passthrough?.model ?? this.modelName;
+		return typeof model === "string" && /^gpt-(?:audio|4o(?:-mini)?-audio)(?:-|$)/.test(model) ? "openai" : void 0;
+	}
+	static OPENAI_CHAT_MODELS = OPENAI_CHAT_MODELS;
+	static OPENAI_CHAT_MODEL_NAMES = OPENAI_CHAT_MODELS.map((model) => model.id);
+	config;
+	mcpClient = null;
+	initializationPromise = null;
+	initializationPending = false;
+	initializationWaiters = 0;
+	lastInitializationWaitCancelled = false;
+	loadedFunctionCallbacks = {};
+	constructor(modelName, options = {}) {
+		if (!OpenAiChatCompletionProvider.OPENAI_CHAT_MODEL_NAMES.includes(modelName)) logger.debug(`Using unknown chat model: ${modelName}`);
+		super(modelName, options);
+		this.config = options.config ? { ...options.config } : {};
+		if (this.config.mcp?.enabled) this.startMCPInitialization();
+	}
+	validateFunctionToolCall(output, vars) {
+		validateFunctionCall(output, this.config.functions, vars);
+	}
+	startMCPInitialization() {
+		this.initializationPending = true;
+		this.lastInitializationWaitCancelled = false;
+		const initialization = this.initializeMCP().finally(() => {
+			if (this.initializationPromise === initialization) this.initializationPending = false;
+		});
+		this.initializationPromise = initialization;
+		initialization.catch(() => void 0);
+	}
+	async initializeMCP() {
+		this.mcpClient = new MCPClient(this.config.mcp);
+		await this.mcpClient.initialize();
+	}
+	async cleanup() {
+		if (this.mcpClient) {
+			const mcpClient = this.mcpClient;
+			const initialization = this.initializationPromise;
+			const cleanup = (async () => {
+				try {
+					await initialization;
+				} finally {
+					try {
+						await mcpClient.cleanup();
+					} finally {
+						if (this.mcpClient === mcpClient) {
+							this.mcpClient = null;
+							this.initializationPromise = null;
+						}
+					}
+				}
+			})();
+			if (this.initializationPending && this.lastInitializationWaitCancelled && this.initializationWaiters === 0) {
+				this.mcpClient = null;
+				this.initializationPromise = null;
+				cleanup.catch((error) => {
+					logger.debug("MCP cleanup after cancelled initialization failed", { error });
+				});
+				return;
+			}
+			await cleanup;
+		}
+	}
+	isReasoningCapabilityModel(modelName) {
+		return super.isReasoningModel(modelName);
+	}
+	supportsTemperatureForCapabilityModel(modelName) {
+		return !this.isReasoningCapabilityModel(modelName);
+	}
+	/**
+	* Loads a function from an external file
+	* @param fileRef The file reference in the format 'file://path/to/file:functionName'
+	* @returns The loaded function
+	*/
+	async loadExternalFunction(fileRef) {
+		return loadProviderCallbackFromFileUrl(fileRef);
+	}
+	/**
+	* Executes a function callback with proper error handling
+	*/
+	async executeFunctionCallback(functionName, args, config, callId, abortSignal) {
+		return executeProviderFunctionCallback({
+			functionName,
+			args,
+			callId,
+			abortSignal,
+			callbacks: config.functionToolCallbacks,
+			cache: this.loadedFunctionCallbacks
+		});
+	}
+	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);
+		const messages = parseChatPrompt(prompt, [{
+			role: "user",
+			content: prompt
+		}]);
+		const passthroughModel = typeof config.passthrough?.model === "string" ? config.passthrough.model : void 0;
+		const capabilityModelName = this.normalizeCapabilityModelName(passthroughModel ?? this.getCapabilityModelName()).replace(/(^|\/)ft:/, "$1");
+		const usesConfiguredCapabilities = capabilityModelName === this.normalizeCapabilityModelName(this.getCapabilityModelName()).replace(/(^|\/)ft:/, "$1");
+		const isGPT5Model = this.isGPT5Model(capabilityModelName);
+		const isOSeriesModel = capabilityModelName.startsWith("o1") || capabilityModelName.startsWith("o3") || capabilityModelName.startsWith("o4") || capabilityModelName.includes("/o1") || capabilityModelName.includes("/o3") || capabilityModelName.includes("/o4");
+		const isGPT6Model = isGpt6Model(capabilityModelName);
+		const isOpenRouterGpt6 = isGPT6Model && this.usesOpenRouter();
+		const isReasoningModel = usesConfiguredCapabilities ? this.isReasoningModel() : this.isReasoningCapabilityModel(capabilityModelName);
+		const maxCompletionTokens = isReasoningModel ? config.max_completion_tokens ?? getEnvInt("OPENAI_MAX_COMPLETION_TOKENS") : void 0;
+		const maxTokensDefault = config.omitDefaults ? getEnvString("OPENAI_MAX_TOKENS") === void 0 ? void 0 : getEnvInt("OPENAI_MAX_TOKENS") : getEnvInt("OPENAI_MAX_TOKENS", 1024);
+		const maxTokens = isReasoningModel || isGPT5Model ? void 0 : config.max_tokens ?? maxTokensDefault;
+		const temperatureDefault = config.omitDefaults ? getEnvString("OPENAI_TEMPERATURE") === void 0 ? void 0 : getEnvFloat("OPENAI_TEMPERATURE") : getEnvFloat("OPENAI_TEMPERATURE", 0);
+		const temperature = isGPT6Model || (usesConfiguredCapabilities ? this.supportsTemperature() : this.supportsTemperatureForCapabilityModel(capabilityModelName)) ? config.temperature ?? temperatureDefault : void 0;
+		const reasoningEffort = isReasoningModel && !isGPT6Model ? renderVarsInObject(config.reasoning_effort, context?.vars ?? {}) : void 0;
+		const mcpTools = this.mcpClient ? transformMCPToolsToOpenAi(this.mcpClient.getAllTools()) : [];
+		const loadedTools = await prepareOpenAiTools(config.tools, context?.vars, callApiOptions?.abortSignal) ?? [];
+		const functions = prepareOpenAiFunctions(config.functions, context?.vars);
+		const responseFormat = prepareOpenAiResponseFormat(config.response_format, context?.vars);
+		const fileTools = loadedTools;
+		const allTools = [...mcpTools, ...fileTools];
+		const body = {
+			model: this.modelName,
+			messages,
+			seed: config.seed,
+			...maxTokens === void 0 ? {} : { max_tokens: maxTokens },
+			...maxCompletionTokens === void 0 ? {} : { max_completion_tokens: maxCompletionTokens },
+			...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+			...temperature === void 0 ? {} : { temperature },
+			...config.top_p !== void 0 || getEnvString("OPENAI_TOP_P") ? { top_p: config.top_p ?? getEnvFloat("OPENAI_TOP_P", 1) } : {},
+			...config.presence_penalty !== void 0 || getEnvString("OPENAI_PRESENCE_PENALTY") ? { presence_penalty: config.presence_penalty ?? getEnvFloat("OPENAI_PRESENCE_PENALTY", 0) } : {},
+			...config.frequency_penalty !== void 0 || getEnvString("OPENAI_FREQUENCY_PENALTY") ? { frequency_penalty: config.frequency_penalty ?? getEnvFloat("OPENAI_FREQUENCY_PENALTY", 0) } : {},
+			...config.functions ? { functions } : {},
+			...config.function_call ? { function_call: config.function_call } : {},
+			...allTools.length > 0 ? { tools: allTools } : {},
+			...config.tool_choice ? { tool_choice: transformToolChoice(config.tool_choice, "openai") } : {},
+			...config.tool_resources ? { tool_resources: config.tool_resources } : {},
+			...config.response_format ? { response_format: responseFormat } : {},
+			...callApiOptions?.includeLogProbs ? { logprobs: callApiOptions.includeLogProbs } : {},
+			...config.stop ? { stop: config.stop } : {},
+			...config.safety_identifier === void 0 ? {} : { safety_identifier: config.safety_identifier },
+			...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 ? {} : { service_tier: normalizeOpenAiServiceTierForWire(effectiveServiceTier, this.getApiUrl()) },
+			...capabilityModelName.includes("audio") ? {
+				modalities: config.modalities || ["text", "audio"],
+				audio: config.audio || {
+					voice: "alloy",
+					format: "wav"
+				}
+			} : {},
+			...(isGPT5Model || isGPT6Model) && config.verbosity ? { verbosity: config.verbosity } : {}
+		};
+		assertOpenAiApiModel(body.model, this.getApiUrl());
+		if (!isGPT6Model && config.reasoning_effort && (isReasoningModel || capabilityModelName.includes("gpt-oss"))) body.reasoning_effort = renderVarsInObject(config.reasoning_effort, context?.vars ?? {});
+		if (config.reasoning && isOSeriesModel) body.reasoning = prepareOpenAiReasoning(config.reasoning, context?.vars);
+		if (config.user) body.user = config.user;
+		if (config.metadata) body.metadata = config.metadata;
+		if (config.store !== void 0) body.store = config.store;
+		if ((isReasoningModel || isGPT5Model) && "max_tokens" in body) delete body.max_tokens;
+		const gpt6Effort = isGPT6Model && !isOpenRouterGpt6 ? getGpt6ChatReasoningEffort(this.config, context?.prompt?.config, (value) => renderVarsInObject(value, context?.vars ?? {})) : void 0;
+		if (isGPT6Model) {
+			const outputCap = resolveGpt6ChatOutputCap(this.config, context?.prompt?.config, isOpenRouterGpt6, {
+				maxCompletionTokens: getEnvInt("OPENAI_MAX_COMPLETION_TOKENS"),
+				maxTokens: isOpenRouterGpt6 || gpt6Effort === "none" ? getEnvInt("OPENAI_MAX_TOKENS") : void 0
+			});
+			if (outputCap === void 0) delete body.max_completion_tokens;
+			else body.max_completion_tokens = outputCap;
+		}
+		if (isOpenRouterGpt6) reconcileOpenRouterReasoning(body, this.config, context?.prompt?.config, context?.vars);
+		else if (isGPT6Model) {
+			if (config.reasoning != null) throw new Error("GPT-6 Chat Completions requests use reasoning_effort. Configure reasoning_effort, or use the Responses API for config.reasoning.");
+			if (gpt6Effort === void 0) delete body.reasoning_effort;
+			else body.reasoning_effort = gpt6Effort;
+		}
+		applyGpt6RequestRules(body, capabilityModelName, "chat", { isOpenRouter: isOpenRouterGpt6 });
+		return {
+			body,
+			config: {
+				...config,
+				functions,
+				response_format: responseFormat,
+				service_tier: effectiveServiceTier
+			}
+		};
+	}
+	getBillingModelName(config) {
+		const passthroughModel = config.passthrough?.model;
+		return typeof passthroughModel === "string" ? passthroughModel : super.getBillingModelName(config);
+	}
+	getBillingRegion() {}
+	/**
+	* Calculate the response cost from the provider's raw usage payload.
+	*
+	* OpenAI-compatible providers can override this hook when their API exposes
+	* authoritative billing data or uses provider-specific token accounting.
+	*/
+	calculateResponseCost(data, config, cached) {
+		if (this.usesOpenRouter()) return calculateOpenRouterResponseCost(data, config);
+		const modelName = this.getBillingModelName(config);
+		const billingModelName = normalizeOpenAiBillingModelName(modelName);
+		const tokenCost = calculateOpenAIUsageCost(billingModelName, config, data.usage, {
+			apiUrl: this.getApiUrl(),
+			cachedResponse: cached,
+			provider: this.getGenAISystem(),
+			region: this.getBillingRegion(),
+			serviceTier: data.service_tier ?? config.service_tier
+		});
+		const searchCost = cached ? 0 : getChatSearchSurcharge(modelName);
+		return tokenCost === void 0 ? searchCost || void 0 : tokenCost + searchCost;
+	}
+	/**
+	* Extract provider-specific fields while the raw OpenAI-compatible response is still available.
+	*/
+	getProviderResponseMetadata(data) {
+		return this.usesOpenRouter() && data && typeof data === "object" ? getOpenRouterBillingMetadata(data) ?? {} : {};
+	}
+	getChatTracingRequest(body) {
+		const asNumber = (value) => typeof value === "number" ? value : void 0;
+		return {
+			maxTokens: asNumber(body.max_completion_tokens) ?? asNumber(body.max_tokens),
+			temperature: asNumber(body.temperature),
+			topP: asNumber(body.top_p),
+			stopSequences: Array.isArray(body.stop) ? body.stop : typeof body.stop === "string" ? [body.stop] : void 0
+		};
+	}
+	async callApi(prompt, context, callApiOptions) {
+		if (this.config.mcp?.enabled && !this.mcpClient) {
+			throwIfAborted(callApiOptions?.abortSignal);
+			this.startMCPInitialization();
+		}
+		if (this.initializationPromise == null) throwIfAborted(callApiOptions?.abortSignal);
+		else {
+			this.initializationWaiters++;
+			let cancelled = false;
+			try {
+				await waitForPromiseWithAbort(this.initializationPromise, callApiOptions?.abortSignal);
+			} catch (error) {
+				cancelled = isCallerAbortError(error, callApiOptions?.abortSignal, { requireReasonMatch: true });
+				throw error;
+			} finally {
+				this.initializationWaiters--;
+				if (this.initializationWaiters === 0) this.lastInitializationWaitCancelled = cancelled;
+			}
+		}
+		throwIfAborted(callApiOptions?.abortSignal);
+		const apiKey = this.getApiKey();
+		if (this.requiresApiKey() && !apiKey) throw new Error(this.getMissingApiKeyErrorMessage());
+		const spanContext = {
+			system: this.getGenAISystem(),
+			operationName: "chat",
+			openaiApiType: "chat_completions",
+			model: this.modelName,
+			providerId: this.id(),
+			evalId: context?.evaluationId || context?.test?.metadata?.evaluationId,
+			testIndex: context?.testIdx ?? context?.test?.vars?.__testIdx,
+			promptLabel: context?.prompt?.label,
+			traceparent: context?.traceparent,
+			requestBody: prompt
+		};
+		let prepared;
+		try {
+			prepared = await this.getOpenAiBody(prompt, context, callApiOptions);
+		} catch (error) {
+			return withGenAISpan(spanContext, async () => {
+				throw error;
+			}, extractProviderResponseAttributes);
+		}
+		return withGenAISpan({
+			...spanContext,
+			...this.getChatTracingRequest(prepared.body)
+		}, () => this.callApiInternal(prepared, context, callApiOptions, apiKey), extractProviderResponseAttributes);
+	}
+	/**
+	* Internal implementation of callApi without tracing wrapper.
+	* This is called by callApi after setting up the tracing span.
+	*/
+	async callApiInternal(prepared, context, callApiOptions, apiKey) {
+		const { body, config } = prepared;
+		const getAuthHeaders = this.getRequestAuthentication();
+		throwIfAborted(callApiOptions?.abortSignal);
+		let data;
+		let status;
+		let statusText;
+		let cached = false;
+		let latencyMs;
+		let deleteFromCache;
+		let responseHeaders;
+		let completedRefusal;
+		const getRefusalResponse = ({ data, cached, status, statusText, headers, latencyMs }) => {
+			const choice = data?.choices?.[0];
+			const message = choice?.message;
+			const finishReason = normalizeFinishReason(choice?.finish_reason);
+			if (!message || !message.refusal && finishReason !== FINISH_REASON_MAP.content_filter) return;
+			const cost = this.calculateResponseCost(data, config, cached);
+			return {
+				output: message.refusal || message.content || "Content filtered by provider",
+				tokenUsage: getTokenUsage(data, cached),
+				cached,
+				latencyMs,
+				...cost === void 0 ? {} : { cost },
+				isRefusal: true,
+				...finishReason && { finishReason },
+				guardrails: { flagged: true },
+				metadata: {
+					...this.getProviderResponseMetadata(data),
+					http: {
+						status,
+						statusText,
+						headers: headers ?? {}
+					}
+				}
+			};
+		};
+		try {
+			({data, cached, status, statusText, latencyMs, deleteFromCache, headers: responseHeaders} = await fetchWithCache(appendOpenAiApiPath(this.getApiUrl(), "chat/completions"), {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...apiKey && !getAuthHeaders ? { Authorization: `Bearer ${apiKey}` } : {},
+					...this.getOpenAiRequestHeaders(config.headers)
+				},
+				body: JSON.stringify(body),
+				...getAuthHeaders ? { getAuthHeaders } : {},
+				...callApiOptions?.abortSignal ? { signal: callApiOptions.abortSignal } : {}
+			}, getRequestTimeoutMs(), "json", this.shouldBustCache(context), this.config.maxRetries, (response) => {
+				if (response.status >= 200 && response.status < 300) {
+					if (response.headers && getOpenAiGatewayRateLimitKind(response.data) !== "quota") callApiOptions?.onResponseHeaders?.(response.headers);
+					completedRefusal = getRefusalResponse(response);
+				}
+			}, callApiOptions?.onResponseHeaders ? (backoff) => callApiOptions.onResponseHeaders?.(backoff.headers, backoff) : void 0));
+			const gatewayErrorFormat = this.usesGatewayErrorFormat();
+			const policy = getOpenAiPolicyRefusal(data, gatewayErrorFormat);
+			if (policy) {
+				const cost = this.calculateResponseCost(data, config, cached);
+				return {
+					output: policy.partialOutput === void 0 ? policy.message : getOpenAiPartialOutput(policy.partialOutput, isOpenAiJsonSchemaFormat(body.response_format)),
+					tokenUsage: data?.usage ? getTokenUsage(data, cached) : void 0,
+					cached,
+					latencyMs,
+					...cost === void 0 ? {} : { cost },
+					isRefusal: true,
+					guardrails: {
+						flagged: true,
+						...policy.flaggedInput ? { flaggedInput: true } : {},
+						reason: policy.message
+					},
+					raw: data,
+					metadata: {
+						...this.getProviderResponseMetadata(data),
+						...policy.code ? { providerPolicy: { code: policy.code } } : {},
+						http: {
+							status,
+							statusText,
+							headers: responseHeaders ?? {}
+						}
+					}
+				};
+			}
+			const choiceError = (this.usesOpenRouter() || gatewayErrorFormat && getOpenAiGatewayErrorType(data) !== void 0) && !data?.error ? getOpenAiChatChoiceError(data) : void 0;
+			if (choiceError) {
+				await deleteFromCache?.();
+				const cost = this.calculateResponseCost(data, config, cached);
+				const rateLimitKind = getOpenAiGatewayRateLimitKind(data);
+				return {
+					error: `API error: ${choiceError.error.message}`,
+					tokenUsage: data?.usage ? getTokenUsage(data, cached) : void 0,
+					cached,
+					latencyMs,
+					...cost === void 0 ? {} : { cost },
+					raw: data,
+					metadata: {
+						...this.getProviderResponseMetadata(data),
+						...rateLimitKind ? { rateLimitKind } : {},
+						http: {
+							status,
+							statusText,
+							headers: responseHeaders ?? {}
+						}
+					}
+				};
+			}
+			if (status < 200 || status >= 300) {
+				const errorMessage = `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}`;
+				const rateLimitKind = getOpenAiGatewayRateLimitKind(data);
+				if (typeof data === "object" && data?.error?.code === "invalid_prompt" && !this.usesOpenRouter() && (!gatewayErrorFormat || getOpenAiGatewayErrorType(data) === void 0)) {
+					const cost = this.calculateResponseCost(data, config, cached);
+					return {
+						output: errorMessage,
+						tokenUsage: data?.usage ? getTokenUsage(data, cached) : void 0,
+						cached,
+						latencyMs,
+						...cost === void 0 ? {} : { cost },
+						isRefusal: true,
+						guardrails: {
+							flagged: true,
+							flaggedInput: true
+						},
+						metadata: {
+							...this.getProviderResponseMetadata(data),
+							http: {
+								status,
+								statusText,
+								headers: responseHeaders ?? {}
+							}
+						}
+					};
+				}
+				return {
+					error: errorMessage,
+					metadata: {
+						...rateLimitKind ? { rateLimitKind } : {},
+						http: {
+							status,
+							statusText,
+							headers: responseHeaders ?? {}
+						}
+					}
+				};
+			}
+		} catch (err) {
+			const signal = callApiOptions?.abortSignal;
+			if (!isResponseHeadersObserverError(callApiOptions?.onResponseHeaders, err) && isCallerAbortError(err, signal)) {
+				if (completedRefusal) return completedRefusal;
+				throwIfAborted(signal);
+			}
+			logger.error(`API call error: ${String(err)}`);
+			await deleteFromCache?.();
+			const rateLimitResponse = getOpenAiRateLimitResponse(err, responseHeaders);
+			if (rateLimitResponse) return preserveResponseHeadersObserverError(callApiOptions?.onResponseHeaders, err, rateLimitResponse);
+			return preserveResponseHeadersObserverError(callApiOptions?.onResponseHeaders, err, {
+				error: `API call error: ${String(err)}`,
+				metadata: { http: {
+					status: 0,
+					statusText: "Error",
+					headers: responseHeaders ?? {}
+				} }
+			});
+		}
+		let errorOrigin;
+		let completedModelAccounting;
+		try {
+			const refusal = completedRefusal ?? getRefusalResponse({
+				data,
+				cached,
+				status,
+				statusText,
+				headers: responseHeaders,
+				latencyMs
+			});
+			if (refusal) return refusal;
+			if (isOpenAiErrorOnlyResponse(data)) return {
+				error: formatOpenAiError({
+					...data,
+					error: {
+						...data.error,
+						message: data.error.message
+					}
+				}),
+				metadata: { http: {
+					status,
+					statusText,
+					headers: responseHeaders ?? {}
+				} }
+			};
+			throwIfAborted(callApiOptions?.abortSignal);
+			const message = data.choices[0].message;
+			const finishReason = normalizeFinishReason(data.choices[0].finish_reason);
+			const cost = this.calculateResponseCost(data, config, cached);
+			const providerMetadata = this.getProviderResponseMetadata(data);
+			completedModelAccounting = {
+				tokenUsage: getTokenUsage(data, cached),
+				cost,
+				cached,
+				latencyMs
+			};
+			const contentFiltered = finishReason === FINISH_REASON_MAP.content_filter;
+			let reasoning = "";
+			let output = "";
+			if (message.reasoning) {
+				reasoning = message.reasoning;
+				output = message.content;
+			} else if (message.content && (message.function_call || message.tool_calls)) {
+				if (Array.isArray(message.tool_calls) && message.tool_calls.length === 0) output = message.content;
+				else output = message;
+			} else if (message.content === null || message.content === void 0 || message.content === "" && message.tool_calls) output = message.function_call || message.tool_calls;
+			else output = message.content;
+			const logProbs = data.choices[0].logprobs?.content?.map((logProbObj) => logProbObj.logprob);
+			if (isOpenAiJsonSchemaFormat(body.response_format) && typeof output === "string") try {
+				output = JSON.parse(output);
+			} catch (error) {
+				logger.error(`Failed to parse JSON output: ${error}`);
+			}
+			if (reasoning && typeof output === "string" && (this.config.showThinking ?? true)) output = `Thinking: ${reasoning}\n\n${output}`;
+			const mcpToolCalls = [];
+			const functionCalls = message.function_call ? [message.function_call] : message.tool_calls;
+			if (functionCalls && (config.functionToolCallbacks || this.mcpClient)) {
+				const results = [];
+				let hasSuccessfulCallback = false;
+				for (const functionCall of functionCalls) {
+					throwIfAborted(callApiOptions?.abortSignal);
+					const functionName = functionCall.name || functionCall.function?.name;
+					if (this.mcpClient) {
+						if (this.mcpClient.getAllTools().find((tool) => tool.name === functionName)) {
+							const rawArgs = functionCall.arguments || functionCall.function?.arguments || "{}";
+							const toolCallId = functionCall.id ?? functionCall.call_id;
+							let parsedArgs;
+							try {
+								parsedArgs = typeof rawArgs === "string" ? JSON.parse(rawArgs) : rawArgs;
+								throwIfAborted(callApiOptions?.abortSignal);
+								const mcpResult = await this.mcpClient.callTool(functionName, parsedArgs, callApiOptions?.abortSignal);
+								if (isMcpErrorResult(mcpResult)) {
+									const errorMessage = getMcpErrorMessage(mcpResult);
+									results.push(`MCP Tool Error (${functionName}): ${errorMessage}`);
+									mcpToolCalls.push({
+										id: toolCallId,
+										name: functionName,
+										input: parsedArgs,
+										output: errorMessage,
+										is_error: true
+									});
+									if (callApiOptions?.abortSignal?.aborted) return {
+										error: `MCP Tool Error (${functionName}): ${errorMessage}`,
+										tokenUsage: getTokenUsage(data, cached),
+										cached,
+										latencyMs,
+										logProbs,
+										...finishReason && { finishReason },
+										cost,
+										guardrails: { flagged: contentFiltered },
+										metadata: {
+											...providerMetadata,
+											errorOrigin: "tool",
+											http: {
+												status,
+												statusText,
+												headers: responseHeaders ?? {}
+											},
+											toolCalls: mcpToolCalls
+										}
+									};
+								} else {
+									throwIfAborted(callApiOptions?.abortSignal);
+									const content = normalizeMcpToolContent(mcpResult?.content);
+									results.push(`MCP Tool Result (${functionName}): ${content}`);
+									mcpToolCalls.push({
+										id: toolCallId,
+										name: functionName,
+										input: parsedArgs,
+										output: content,
+										is_error: false
+									});
+								}
+								hasSuccessfulCallback = true;
+								continue;
+							} catch (error) {
+								if (isCallerAbortError(error, callApiOptions?.abortSignal, { requireReasonMatch: true })) throwIfAborted(callApiOptions?.abortSignal);
+								if (callApiOptions?.abortSignal?.aborted) {
+									errorOrigin = "tool";
+									throw error;
+								}
+								logger.debug(`MCP tool execution failed for ${functionName}: ${error}`);
+								results.push(`MCP Tool Error (${functionName}): ${error}`);
+								mcpToolCalls.push({
+									id: toolCallId,
+									name: functionName,
+									input: parsedArgs ?? rawArgs,
+									output: String(error),
+									is_error: true
+								});
+								hasSuccessfulCallback = true;
+								continue;
+							}
+						}
+					}
+					if (config.functionToolCallbacks && config.functionToolCallbacks[functionName]) try {
+						throwIfAborted(callApiOptions?.abortSignal);
+						const functionResult = await this.executeFunctionCallback(functionName, functionCall.arguments || functionCall.function?.arguments, config, functionCall.call_id ?? functionCall.id, callApiOptions?.abortSignal);
+						throwIfAborted(callApiOptions?.abortSignal);
+						results.push(functionResult);
+						hasSuccessfulCallback = true;
+					} catch (error) {
+						if (isCallerAbortError(error, callApiOptions?.abortSignal, { requireReasonMatch: true })) throwIfAborted(callApiOptions?.abortSignal);
+						if (callApiOptions?.abortSignal?.aborted) {
+							errorOrigin = "tool";
+							throw error;
+						}
+						logger.debug(`Function callback failed for ${functionName} with error ${error}, falling back to original output`);
+						hasSuccessfulCallback = false;
+						break;
+					}
+				}
+				throwIfAborted(callApiOptions?.abortSignal);
+				if (hasSuccessfulCallback && results.length > 0) return {
+					output: results.join("\n"),
+					tokenUsage: getTokenUsage(data, cached),
+					cached,
+					latencyMs,
+					logProbs,
+					...finishReason && { finishReason },
+					cost,
+					guardrails: { flagged: contentFiltered },
+					metadata: {
+						...providerMetadata,
+						http: {
+							status,
+							statusText,
+							headers: responseHeaders ?? {}
+						},
+						...mcpToolCalls.length > 0 && { toolCalls: mcpToolCalls }
+					}
+				};
+			}
+			if (message.reasoning_content && typeof message.reasoning_content === "string" && typeof output === "string" && (this.config.showThinking ?? true)) output = `Thinking: ${message.reasoning_content}\n\n${output}`;
+			if (message.audio) return {
+				output: message.audio.transcript || "",
+				audio: {
+					id: message.audio.id,
+					expiresAt: message.audio.expires_at,
+					data: message.audio.data,
+					transcript: message.audio.transcript,
+					format: message.audio.format || body.audio?.format || "wav"
+				},
+				tokenUsage: getTokenUsage(data, cached),
+				cached,
+				latencyMs,
+				logProbs,
+				...finishReason && { finishReason },
+				cost,
+				guardrails: { flagged: contentFiltered },
+				metadata: {
+					...providerMetadata,
+					http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					},
+					...mcpToolCalls.length > 0 && { toolCalls: mcpToolCalls }
+				}
+			};
+			const citations = getChatSearchCitations(message.annotations, output);
+			return {
+				output,
+				tokenUsage: getTokenUsage(data, cached),
+				cached,
+				latencyMs,
+				logProbs,
+				...finishReason && { finishReason },
+				cost,
+				guardrails: { flagged: contentFiltered },
+				metadata: {
+					...providerMetadata,
+					http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					},
+					...data.choices.length > 1 && { choices: data.choices },
+					...Array.isArray(message.annotations) && message.annotations.length > 0 && { annotations: message.annotations },
+					...citations.length > 0 && { citations },
+					...mcpToolCalls.length > 0 && { toolCalls: mcpToolCalls }
+				}
+			};
+		} catch (err) {
+			if (isCallerAbortError(err, callApiOptions?.abortSignal, { requireReasonMatch: true })) throwIfAborted(callApiOptions?.abortSignal);
+			if (errorOrigin !== "tool") await deleteFromCache?.();
+			return {
+				error: `API error: ${String(err)}: ${JSON.stringify(data)}`,
+				...errorOrigin === "tool" && completedModelAccounting,
+				metadata: {
+					...errorOrigin && { errorOrigin },
+					http: {
+						status,
+						statusText,
+						headers: responseHeaders ?? {}
+					}
+				}
+			};
+		}
+	}
+};
+//#endregion
+export { createResponseHeadersObserver as a, preserveResponseHeadersObserverError as c, composeResponseHeadersObservers as i, preserveResponseHeadersObserverErrorResponse as l, getOpenAiGatewayRateLimitKind as n, isResponseHeadersObserverError as o, getOpenAiRateLimitResponse as r, isResponseHeadersObserverErrorResponse as s, OpenAiChatCompletionProvider as t };
+
+//# sourceMappingURL=chat-ClTFM3qq.js.map