promptfoo 0.125.0 → 0.125.1

package/dist/src/agents-6hDRNoYD.js

@@ -1,777 +0,0 @@
-import { o as logger, q as getEnvString } from "./logger-CNHLbG5Y.js";
-import { t as fetchWithProxy } from "./fetch-5HtnNhHg.js";
-import { r as getTracingServiceName, t as getConfiguredTracingExport } from "./tracing-B8p6SMbW.js";
-import { n as OpenAiGenericProvider } from "./openai-Wnwbwy-M.js";
-import { loadAgentDefinition, loadHandoffs, loadInputGuardrails, loadOutputGuardrails, loadSandboxConfig, loadSessionDefinition, loadTools, loadValueFromFile, t as resolveModelSettings } from "./agents-loader-BmpJ5n4h.js";
-import { r as encodeExportTraceServiceRequest } from "./protobuf-BaJ-MMmf.js";
-import { Agent, BatchTraceProcessor, Runner, addTraceProcessor, getOrCreateTrace, handoff, protocol, startTraceExportLoop } from "@openai/agents";
-import { SandboxAgent } from "@openai/agents/sandbox";
-//#region src/providers/openai/agents-tracing.ts
-const DEFAULT_OTLP_ENDPOINT = "http://localhost:4318";
-const OTLP_SPAN_KIND_INTERNAL = 1;
-const OTLP_SPAN_KIND_CLIENT = 3;
-const INTERNAL_TRACE_METADATA_KEYS = /* @__PURE__ */ new Set([
-	"promptfoo.otlp_endpoint",
-	"promptfoo.otlp_format",
-	"promptfoo.model_provider",
-	"promptfoo.parent_span_id",
-	"promptfoo.request_model",
-	"promptfoo.service_name"
-]);
-/**
-* OTLP Tracing Exporter for OpenAI Agents.
-*
-* The Agents SDK emits a framework-native span model. Promptfoo needs those spans
-* normalized into OTLP attributes that its trajectory assertions understand.
-*/
-var OTLPTracingExporter = class {
-	/**
-	* Export traces and spans to their configured OTLP endpoint.
-	*/
-	async export(items, signal) {
-		const spans = items.filter((item) => item.type === "trace.span");
-		if (spans.length === 0) {
-			logger.debug("[AgentsTracing] No spans to export");
-			return;
-		}
-		const spansByEndpoint = groupSpansByEndpoint(spans);
-		logger.debug("[AgentsTracing] Exporting spans to OTLP", {
-			endpointCount: spansByEndpoint.size,
-			spanCount: spans.length
-		});
-		await Promise.all([...spansByEndpoint.values()].map(async ({ endpoint: otlpEndpoint, format, spans }) => {
-			try {
-				const otlpPayload = this.transformToOTLP(spans);
-				const url = `${otlpEndpoint}/v1/traces`;
-				const body = format === "protobuf" ? new Uint8Array(await encodeExportTraceServiceRequest(otlpPayload)) : JSON.stringify(otlpPayload);
-				logger.debug("[AgentsTracing] Sending OTLP payload", {
-					url,
-					format,
-					spanCount: spans.length
-				});
-				const response = await fetchWithProxy(url, {
-					method: "POST",
-					headers: { "Content-Type": format === "protobuf" ? "application/x-protobuf" : "application/json" },
-					body,
-					signal
-				});
-				if (response.ok) logger.debug("[AgentsTracing] Successfully exported traces to OTLP", {
-					otlpEndpoint,
-					spanCount: spans.length
-				});
-				else logger.error(`[AgentsTracing] OTLP export failed: ${response.status} ${response.statusText}`, { otlpEndpoint });
-			} catch (error) {
-				logger.error("[AgentsTracing] Failed to export traces to OTLP", {
-					error,
-					otlpEndpoint
-				});
-			}
-		}));
-	}
-	/**
-	* Transform openai-agents-js spans to OTLP JSON format.
-	*/
-	transformToOTLP(spans) {
-		const spansByService = /* @__PURE__ */ new Map();
-		const defaultServiceName = getTracingServiceName();
-		for (const span of spans) {
-			const serviceName = getStringTraceMetadata(span, "promptfoo.service_name") ?? defaultServiceName;
-			const serviceSpans = spansByService.get(serviceName) ?? [];
-			serviceSpans.push(span);
-			spansByService.set(serviceName, serviceSpans);
-		}
-		return { resourceSpans: [...spansByService.entries()].map(([serviceName, serviceSpans]) => ({
-			resource: { attributes: [{
-				key: "service.name",
-				value: { stringValue: serviceName }
-			}] },
-			scopeSpans: [{
-				scope: { name: "openai-agents-js" },
-				spans: serviceSpans.map((span) => this.spanToOTLP(span))
-			}]
-		})) };
-	}
-	/**
-	* Convert a single span to OTLP format.
-	*/
-	spanToOTLP(span) {
-		const startTime = span.startedAt ? new Date(span.startedAt).getTime() : Date.now();
-		const endTime = span.endedAt ? new Date(span.endedAt).getTime() : void 0;
-		const traceId = span.traceId || this.generateTraceId();
-		const spanId = span.spanId || this.generateSpanId();
-		const parentSpanId = span.parentId || getStringTraceMetadata(span, "promptfoo.parent_span_id") || void 0;
-		return {
-			traceId: this.hexToBase64(traceId, "trace"),
-			spanId: this.hexToBase64(spanId, "span"),
-			parentSpanId: parentSpanId ? this.hexToBase64(parentSpanId, "span") : void 0,
-			name: this.getSpanName(span),
-			kind: span.spanData.type === "generation" || span.spanData.type === "response" ? OTLP_SPAN_KIND_CLIENT : OTLP_SPAN_KIND_INTERNAL,
-			startTimeUnixNano: String(startTime * 1e6),
-			endTimeUnixNano: endTime ? String(endTime * 1e6) : void 0,
-			attributes: this.attributesToOTLP(this.getSpanAttributes(span)),
-			status: this.getSpanStatus(span)
-		};
-	}
-	getSpanName(span) {
-		const data = span.spanData;
-		switch (data.type) {
-			case "function": return `execute_tool ${data.name || "function"}`;
-			case "handoff": return `handoff ${data.from_agent || "unknown"} -> ${data.to_agent || "unknown"}`;
-			case "agent": return `invoke_agent ${data.name || "agent"}`;
-			case "generation": return `chat ${data.model || "unknown-model"}`;
-			case "response": return `chat ${getResponseModel(data) || "unknown-model"}`;
-			case "guardrail": return `guardrail ${data.name || "guardrail"}`;
-			case "custom": return this.getCustomSpanName(data);
-			default: return data.type ? `agent.${data.type}` : "agent.span";
-		}
-	}
-	getCustomSpanName(data) {
-		const sandboxOperation = (isRecord(data.data) ? data.data : {})["sandbox.operation"];
-		if (typeof sandboxOperation === "string" && sandboxOperation) return `sandbox.${sandboxOperation}`;
-		return data.name || "custom";
-	}
-	getSpanStatus(span) {
-		if (span.error) return {
-			code: 2,
-			message: span.error.message || String(span.error)
-		};
-		return { code: 0 };
-	}
-	getSpanAttributes(span) {
-		const data = span.spanData;
-		const attributes = { "openai.agents.span_type": data.type };
-		switch (data.type) {
-			case "function":
-				attributes["gen_ai.operation.name"] = "execute_tool";
-				attributes["gen_ai.tool.name"] = data.name;
-				attributes["tool.name"] = data.name;
-				if (data.input !== void 0) attributes["tool.arguments"] = data.input;
-				if (data.output !== void 0) attributes["tool.output"] = data.output;
-				break;
-			case "handoff":
-				attributes["handoff.from_agent"] = data.from_agent;
-				attributes["handoff.to_agent"] = data.to_agent;
-				break;
-			case "agent":
-				attributes["gen_ai.operation.name"] = "invoke_agent";
-				attributes["gen_ai.agent.name"] = data.name;
-				attributes["agent.name"] = data.name;
-				if (data.tools !== void 0) attributes["agent.tools"] = data.tools;
-				if (data.handoffs !== void 0) attributes["agent.handoffs"] = data.handoffs;
-				if (data.output_type !== void 0) attributes["agent.output_type"] = data.output_type;
-				break;
-			case "generation":
-				attributes["gen_ai.operation.name"] = "chat";
-				setGenerationProviderAttribute(data, span, attributes);
-				attributes["gen_ai.request.model"] = data.model;
-				if (data.usage?.input_tokens !== void 0) attributes["gen_ai.usage.input_tokens"] = data.usage.input_tokens;
-				if (data.usage?.output_tokens !== void 0) attributes["gen_ai.usage.output_tokens"] = data.usage.output_tokens;
-				if (data.usage && "total_tokens" in data.usage) attributes["promptfoo.usage.total_tokens"] = data.usage.total_tokens;
-				break;
-			case "response":
-				this.applyResponseSpanAttributes(data, span, attributes);
-				break;
-			case "guardrail":
-				attributes["guardrail.name"] = data.name;
-				attributes["guardrail.triggered"] = data.triggered;
-				break;
-			case "custom":
-				this.applyCustomSpanAttributes(data, attributes);
-				break;
-			default: this.applyGenericSpanAttributes(data, attributes);
-		}
-		for (const [key, value] of Object.entries(span.traceMetadata ?? {})) {
-			if (INTERNAL_TRACE_METADATA_KEYS.has(key)) continue;
-			if (key === "evaluation.id" || key === "test.case.id") attributes[key] = value;
-			else attributes[`trace.metadata.${key}`] = value;
-		}
-		return attributes;
-	}
-	applyResponseSpanAttributes(data, span, attributes) {
-		const response = isRecord(data._response) ? data._response : void 0;
-		const responseId = data.response_id ?? getStringValue(response?.id);
-		const model = getResponseModel(data);
-		const usage = isRecord(response?.usage) ? response.usage : void 0;
-		attributes["gen_ai.operation.name"] = "chat";
-		attributes["gen_ai.provider.name"] = "openai";
-		attributes["openai.api.type"] = "responses";
-		if (model) attributes["gen_ai.response.model"] = model;
-		const requestedModel = getStringTraceMetadata(span, "promptfoo.request_model");
-		if (requestedModel) attributes["gen_ai.request.model"] = requestedModel;
-		if (responseId) {
-			attributes["gen_ai.response.id"] = responseId;
-			attributes["openai.response_id"] = responseId;
-		}
-		setNumericAttribute(attributes, "gen_ai.usage.input_tokens", usage?.input_tokens);
-		setNumericAttribute(attributes, "gen_ai.usage.output_tokens", usage?.output_tokens);
-		setNumericAttribute(attributes, "promptfoo.usage.total_tokens", usage?.total_tokens);
-		const inputTokenDetails = isRecord(usage?.input_tokens_details) ? usage.input_tokens_details : void 0;
-		const outputTokenDetails = isRecord(usage?.output_tokens_details) ? usage.output_tokens_details : void 0;
-		setNumericAttribute(attributes, "gen_ai.usage.cache_read.input_tokens", inputTokenDetails?.cached_tokens);
-		setNumericAttribute(attributes, "gen_ai.usage.reasoning.output_tokens", outputTokenDetails?.reasoning_tokens);
-	}
-	applyCustomSpanAttributes(data, attributes) {
-		attributes["openai.agents.custom_span.name"] = data.name;
-		if (!isRecord(data.data)) return;
-		for (const [key, value] of Object.entries(data.data)) attributes[key] = sanitizeAttributeValue(value);
-		const command = commandToString(data.data.command ?? data.data.cmd);
-		if (command) attributes.command = command;
-		const exitCode = data.data.exit_code ?? data.data.exitCode;
-		if (typeof exitCode === "number") attributes["process.exit.code"] = exitCode;
-	}
-	applyGenericSpanAttributes(data, attributes) {
-		for (const [key, value] of Object.entries(data)) {
-			if (key === "type") continue;
-			attributes[`agent.${key}`] = sanitizeAttributeValue(value);
-		}
-	}
-	attributesToOTLP(attributes) {
-		return Object.entries(attributes).filter(([, value]) => value !== void 0).map(([key, value]) => ({
-			key,
-			value: this.valueToOTLP(value)
-		}));
-	}
-	valueToOTLP(value) {
-		if (value === null || value === void 0) return { stringValue: "" };
-		if (typeof value === "string") return { stringValue: value };
-		if (typeof value === "number") return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
-		if (typeof value === "boolean") return { boolValue: value };
-		if (Array.isArray(value)) return { arrayValue: { values: value.map((entry) => this.valueToOTLP(entry)) } };
-		if (typeof value === "object") return { stringValue: safeJsonStringify(value) };
-		return { stringValue: String(value) };
-	}
-	/**
-	* Convert hex string to base64 for OTLP JSON payloads.
-	*/
-	hexToBase64(hex, kind) {
-		if (!hex) return "";
-		try {
-			let cleanHex = hex.replace(/^(trace_|span_|group_)/, "");
-			const targetLength = kind === "span" ? 16 : 32;
-			if (cleanHex.length > targetLength) cleanHex = cleanHex.substring(0, targetLength);
-			else if (cleanHex.length < targetLength) cleanHex = cleanHex.padEnd(targetLength, "0");
-			return Buffer.from(cleanHex, "hex").toString("base64");
-		} catch (error) {
-			logger.error(`[AgentsTracing] Failed to convert hex to base64: ${hex}`, { error });
-			const fallbackLen = kind === "span" ? 16 : 32;
-			return Buffer.from(this.generateRandomHex(fallbackLen), "hex").toString("base64");
-		}
-	}
-	generateTraceId() {
-		return this.generateRandomHex(32);
-	}
-	generateSpanId() {
-		return this.generateRandomHex(16);
-	}
-	generateRandomHex(length) {
-		const bytes = Math.ceil(length / 2);
-		const buffer = Buffer.alloc(bytes);
-		for (let i = 0; i < bytes; i++) buffer[i] = Math.floor(Math.random() * 256);
-		return buffer.toString("hex").substring(0, length);
-	}
-};
-function getResponseModel(data) {
-	return isRecord(data._response) ? getStringValue(data._response.model) : void 0;
-}
-function getStringValue(value) {
-	return typeof value === "string" && value ? value : void 0;
-}
-function setNumericAttribute(attributes, name, value) {
-	if (typeof value === "number" && Number.isFinite(value)) attributes[name] = value;
-}
-function groupSpansByEndpoint(spans) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const span of spans) {
-		const endpoint = getStringTraceMetadata(span, "promptfoo.otlp_endpoint") ?? DEFAULT_OTLP_ENDPOINT;
-		const format = getStringTraceMetadata(span, "promptfoo.otlp_format") === "protobuf" ? "protobuf" : "json";
-		const destinationKey = `${format}:${endpoint}`;
-		const destination = grouped.get(destinationKey) ?? {
-			endpoint,
-			format,
-			spans: []
-		};
-		destination.spans.push(span);
-		grouped.set(destinationKey, destination);
-	}
-	return grouped;
-}
-function setGenerationProviderAttribute(data, span, attributes) {
-	const modelConfig = isRecord(data.model_config) ? data.model_config : void 0;
-	const provider = getStringValue(modelConfig?.provider) ?? getStringValue(modelConfig?.provider_name) ?? getStringValue(modelConfig?.providerName) ?? getStringTraceMetadata(span, "promptfoo.model_provider") ?? inferProviderFromModel(data.model);
-	if (provider) attributes["gen_ai.provider.name"] = provider;
-}
-function inferProviderFromModel(model) {
-	if (!model) return;
-	const explicitProvider = model.match(/^(openai|anthropic|azure|google|vertex|bedrock|litellm)[/:]/i);
-	if (explicitProvider) return explicitProvider[1].toLowerCase();
-	if (/^(gpt-|chatgpt-|o[134]-|text-embedding-|dall-e-|whisper-|tts-)/i.test(model)) return "openai";
-	if (/^claude-/i.test(model)) return "anthropic";
-	if (/^gemini-/i.test(model)) return "google";
-}
-function getStringTraceMetadata(span, key) {
-	const value = span.traceMetadata?.[key];
-	return typeof value === "string" && value ? value : void 0;
-}
-function commandToString(value) {
-	if (value === void 0 || value === null) return;
-	if (typeof value === "string") return value.trim() || void 0;
-	if (Array.isArray(value)) return value.map((part) => String(part).trim()).filter(Boolean).join(" ") || void 0;
-	return String(value).trim() || void 0;
-}
-function sanitizeAttributeValue(value) {
-	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
-	if (Array.isArray(value)) return value.map((entry) => sanitizeAttributeValue(entry));
-	if (isRecord(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, sanitizeAttributeValue(entry)]));
-	return String(value);
-}
-function safeJsonStringify(value) {
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return String(value);
-	}
-}
-function isRecord(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-//#endregion
-//#region src/providers/openai/agents.ts
-/**
-* OpenAI Agents Provider
-*
-* Integrates openai-agents-js SDK as a promptfoo provider.
-* Supports multi-turn agent workflows with tools, handoffs, and tracing.
-*/
-var OpenAiAgentsProvider = class extends OpenAiGenericProvider {
-	agentConfig;
-	agent;
-	executionModelSettings;
-	session;
-	sessionInitialization;
-	sessionQueues = /* @__PURE__ */ new WeakMap();
-	constructor(modelName, options = {}) {
-		super(modelName, options);
-		this.agentConfig = options.config || {};
-	}
-	id() {
-		return `openai:agents:${this.modelName}`;
-	}
-	toString() {
-		return `[OpenAI Agents Provider ${this.modelName}]`;
-	}
-	/**
-	* Call the agent with the given prompt
-	*/
-	async callApi(prompt, context, callApiOptions) {
-		logger.debug("[AgentsProvider] Starting agent call", {
-			prompt: prompt.substring(0, 100),
-			hasContext: !!context
-		});
-		try {
-			validateExecuteTools(this.agentConfig.executeTools);
-			if (!this.agent) this.agent = await this.initializeAgent();
-			await this.setupTracingIfNeeded(context);
-			const result = await this.runAgent(prompt, context, callApiOptions);
-			logger.debug("[AgentsProvider] Agent run completed", {
-				outputLength: result.output?.length || 0,
-				tokenUsage: result.tokenUsage
-			});
-			return result;
-		} catch (error) {
-			logger.error("[AgentsProvider] Agent call failed", { error });
-			throw error;
-		}
-	}
-	/**
-	* Initialize the agent from configuration
-	*/
-	async initializeAgent() {
-		logger.debug("[AgentsProvider] Initializing agent");
-		if (!this.agentConfig.agent) throw new Error("No agent configuration provided");
-		try {
-			const agent = await loadAgentDefinition(this.agentConfig.agent);
-			const [tools, handoffs, inputGuardrails, outputGuardrails] = await Promise.all([
-				loadTools(this.agentConfig.tools),
-				loadHandoffs(this.agentConfig.handoffs),
-				loadInputGuardrails(this.agentConfig.inputGuardrails),
-				loadOutputGuardrails(this.agentConfig.outputGuardrails)
-			]);
-			const configuredAgent = cloneAgentPreservingHooks(agent, {
-				tools: mergeArrays(agent.tools, tools) ?? (agent.hasExplicitToolConfig() ? agent.tools : void 0),
-				handoffs: mergeArrays(agent.handoffs, handoffs),
-				inputGuardrails: mergeArrays(agent.inputGuardrails, inputGuardrails),
-				outputGuardrails: mergeArrays(agent.outputGuardrails, outputGuardrails)
-			});
-			this.executionModelSettings = resolveModelSettings(this.agentConfig.modelSettings);
-			logger.debug("[AgentsProvider] Agent initialized successfully", {
-				name: configuredAgent.name,
-				toolCount: configuredAgent.tools.length,
-				handoffCount: configuredAgent.handoffs.length,
-				inputGuardrailCount: configuredAgent.inputGuardrails.length,
-				outputGuardrailCount: configuredAgent.outputGuardrails.length
-			});
-			return configuredAgent;
-		} catch (error) {
-			logger.error("[AgentsProvider] Failed to initialize agent", { error });
-			throw new Error(`Failed to initialize agent: ${error}`);
-		}
-	}
-	/**
-	* Setup tracing if enabled
-	*/
-	async setupTracingIfNeeded(context) {
-		const hasConfiguredExporter = Boolean(this.agentConfig.otlpEndpoint || getConfiguredTracingExport());
-		if (!(this.agentConfig.tracing === true || Boolean(context?.traceparent && hasConfiguredExporter) || context?.test?.metadata?.tracingEnabled === true || (this.env?.PROMPTFOO_TRACING_ENABLED ?? getEnvString("PROMPTFOO_TRACING_ENABLED")) === "true")) {
-			logger.debug("[AgentsProvider] Tracing not enabled");
-			return;
-		}
-		logger.debug("[AgentsProvider] Setting up tracing");
-		try {
-			await ensureTracingExporterRegistered();
-			logger.debug("[AgentsProvider] Tracing setup complete");
-		} catch (error) {
-			logger.error("[AgentsProvider] Failed to setup tracing", { error });
-		}
-	}
-	/**
-	* Run the agent with the given prompt
-	*/
-	async runAgent(prompt, context, callApiOptions) {
-		try {
-			const maxTurns = this.agentConfig.maxTurns === void 0 ? 10 : this.agentConfig.maxTurns;
-			logger.debug("[AgentsProvider] Running agent", {
-				agentName: this.agent?.name,
-				maxTurns
-			});
-			const runOptions = {
-				...await this.resolveRunOptions(context),
-				context: context?.vars,
-				maxTurns,
-				signal: callApiOptions?.abortSignal
-			};
-			const mockTools = this.agentConfig.executeTools === false || this.agentConfig.executeTools === "mock";
-			const runner = new Runner({});
-			if (mockTools) assertNoMockToolOverrides(runOptions.modelSettings, "run options");
-			const traceContext = parseTraceparent(context?.traceparent);
-			const configuredExport = getConfiguredTracingExport();
-			const explicitModel = runOptions.model ?? (this.agentConfig.model || this.agent?.model);
-			const traceMetadata = buildTraceMetadata(context, this.agentConfig.otlpEndpoint ?? configuredExport?.endpoint, traceContext, this.agentConfig.otlpEndpoint ? "json" : configuredExport?.format, typeof explicitModel === "string" ? explicitModel : void 0, getModelProviderName(explicitModel));
-			const executeRun = () => getOrCreateTrace(async () => {
-				const overriddenAgent = applyExecutionOverrides(this.agent, {
-					model: this.agentConfig.model || void 0,
-					modelSettings: this.executionModelSettings
-				}, this.agentConfig.executeTools !== false && this.agentConfig.executeTools !== "mock");
-				const runtimeAgent = this.wrapToolsIfNeeded(overriddenAgent);
-				return await runner.run(runtimeAgent, this.parsePromptInput(prompt), runOptions);
-			}, {
-				...traceContext ? { traceId: `trace_${traceContext.traceId}` } : {},
-				...Object.keys(traceMetadata).length ? { metadata: traceMetadata } : {}
-			});
-			const result = runOptions.session ? await this.withSessionLock(runOptions.session, executeRun) : await executeRun();
-			logger.debug("[AgentsProvider] Agent run result", {
-				hasOutput: !!result.finalOutput,
-				turns: result.newItems?.length || 0
-			});
-			return {
-				output: result.finalOutput,
-				tokenUsage: this.extractTokenUsage(result),
-				cached: false,
-				cost: void 0
-			};
-		} catch (error) {
-			logger.error("[AgentsProvider] Failed to run agent", { error });
-			throw error;
-		}
-	}
-	/**
-	* Extract token usage from agent result
-	*/
-	extractTokenUsage(result) {
-		const usage = result.runContext?.usage ?? result.state?.usage ?? result.usage;
-		if (!usage) return {};
-		const inputDetails = summarizeUsageDetails(usage.inputTokensDetails);
-		const outputDetails = summarizeUsageDetails(usage.outputTokensDetails);
-		const cachedInputTokens = inputDetails.cached_tokens ?? inputDetails.cache_read_input_tokens ?? inputDetails.cacheReadInputTokens;
-		const completionDetails = {
-			...outputDetails.reasoning_tokens === void 0 ? {} : { reasoning: outputDetails.reasoning_tokens },
-			...outputDetails.accepted_prediction_tokens === void 0 ? {} : { acceptedPrediction: outputDetails.accepted_prediction_tokens },
-			...outputDetails.rejected_prediction_tokens === void 0 ? {} : { rejectedPrediction: outputDetails.rejected_prediction_tokens },
-			...cachedInputTokens === void 0 ? {} : { cacheReadInputTokens: cachedInputTokens }
-		};
-		return {
-			total: usage.totalTokens ?? void 0,
-			prompt: usage.inputTokens ?? usage.promptTokens ?? void 0,
-			completion: usage.outputTokens ?? usage.completionTokens ?? void 0,
-			...cachedInputTokens === void 0 ? {} : { cached: cachedInputTokens },
-			...usage.requests === void 0 ? {} : { numRequests: usage.requests },
-			...Object.keys(completionDetails).length ? { completionDetails } : {}
-		};
-	}
-	wrapToolsIfNeeded(agent) {
-		if (this.agentConfig.executeTools !== false && this.agentConfig.executeTools !== "mock") return agent;
-		return this.wrapAgentForMockMode(agent, /* @__PURE__ */ new WeakMap());
-	}
-	wrapAgentForMockMode(agent, wrappedAgents) {
-		const existingWrappedAgent = wrappedAgents.get(agent);
-		if (existingWrappedAgent) return existingWrappedAgent;
-		if (agent instanceof SandboxAgent) throw new Error("executeTools: false/'mock' does not support SandboxAgent because capability tools are attached after function-tool mocks");
-		if (agent.prompt !== void 0) throw new Error("executeTools: false/'mock' does not support reusable prompt templates because they can supply hosted tools outside function-tool mocks");
-		assertNoMockToolOverrides(agent.modelSettings, `agent ${JSON.stringify(agent.name)}`);
-		if (agent.mcpServers?.length) throw new Error("executeTools: false/'mock' does not support MCP servers because they can execute outside mocked function tools");
-		const toolMocks = this.agentConfig.toolMocks ?? {};
-		const tools = agent.tools.map((tool) => {
-			if (tool.type !== "function") throw new Error("executeTools: false/'mock' only supports function tools; remove hosted or non-function tools");
-			const hasMockValue = Object.prototype.hasOwnProperty.call(toolMocks, tool.name);
-			const mockedTool = {
-				...tool,
-				isEnabled: async () => true,
-				needsApproval: async () => false,
-				inputGuardrails: [],
-				outputGuardrails: [],
-				timeoutMs: void 0,
-				timeoutBehavior: void 0,
-				timeoutErrorFunction: void 0,
-				invoke: async () => hasMockValue ? toolMocks[tool.name] : {
-					mocked: true,
-					tool: tool.name
-				}
-			};
-			Object.freeze(mockedTool.inputGuardrails);
-			Object.freeze(mockedTool.outputGuardrails);
-			return Object.freeze(mockedTool);
-		});
-		const wrappedAgent = cloneAgentPreservingHooks(agent, {
-			tools,
-			handoffs: []
-		});
-		wrappedAgents.set(agent, wrappedAgent);
-		wrappedAgent.handoffs = agent.handoffs.map((agentHandoff) => {
-			if (isAgentLike(agentHandoff)) return this.wrapAgentForMockMode(agentHandoff, wrappedAgents);
-			if (agentHandoff && typeof agentHandoff === "object" && "agent" in agentHandoff) throw new Error("executeTools: false/'mock' does not support explicit Handoff objects because their callbacks can perform external side effects");
-			throw new Error("executeTools: false/'mock' cannot safely wrap an unknown handoff shape");
-		});
-		const mockTools = Object.freeze(tools);
-		const noMcpTools = Object.freeze([]);
-		for (const [key, value] of Object.entries({
-			tools: mockTools,
-			handoffs: Object.freeze(wrappedAgent.handoffs),
-			mcpServers: noMcpTools,
-			prompt: void 0,
-			modelSettings: snapshotMockModelSettings(wrappedAgent.modelSettings),
-			getAllTools: async () => mockTools,
-			getMcpTools: async () => noMcpTools,
-			getEnabledHandoffs: Agent.prototype.getEnabledHandoffs.bind(wrappedAgent),
-			getPrompt: async () => void 0
-		})) Object.defineProperty(wrappedAgent, key, {
-			value,
-			writable: false,
-			configurable: false
-		});
-		return wrappedAgent;
-	}
-	parsePromptInput(prompt) {
-		try {
-			const parsedInput = parseAgentInputItems(JSON.parse(prompt));
-			if (parsedInput) return parsedInput;
-		} catch {}
-		return prompt;
-	}
-	async resolveRunOptions(context) {
-		const runOptions = { ...this.agentConfig.runOptions ?? {} };
-		delete runOptions.stream;
-		if (typeof runOptions.sessionInputCallback === "string") runOptions.sessionInputCallback = await loadValueFromFile(runOptions.sessionInputCallback, "session input callback");
-		if (typeof runOptions.callModelInputFilter === "string") runOptions.callModelInputFilter = await loadValueFromFile(runOptions.callModelInputFilter, "call model input filter");
-		if (typeof runOptions.toolErrorFormatter === "string") runOptions.toolErrorFormatter = await loadValueFromFile(runOptions.toolErrorFormatter, "tool error formatter");
-		if (typeof runOptions.errorHandlers === "string") runOptions.errorHandlers = await loadValueFromFile(runOptions.errorHandlers, "run error handlers");
-		if (runOptions.session) runOptions.session = await loadSessionDefinition(runOptions.session, context);
-		else if (this.agentConfig.session) runOptions.session = await this.resolveConfiguredSession(context);
-		if (runOptions.sandbox) runOptions.sandbox = await loadSandboxConfig(runOptions.sandbox, context);
-		else if (this.agentConfig.sandbox) runOptions.sandbox = await loadSandboxConfig(this.agentConfig.sandbox, context);
-		return runOptions;
-	}
-	async resolveConfiguredSession(context) {
-		if (typeof this.agentConfig.session === "function") {
-			const session = await loadSessionDefinition(this.agentConfig.session, context);
-			if (!session) throw new Error("Failed to initialize configured session");
-			return session;
-		}
-		if (typeof this.agentConfig.session === "string" && this.agentConfig.session.startsWith("file://")) {
-			const exportedSession = await loadValueFromFile(this.agentConfig.session, "session");
-			if (typeof exportedSession === "function") {
-				const session = await loadSessionDefinition(exportedSession, context);
-				if (!session) throw new Error("Failed to initialize configured session");
-				return session;
-			}
-		}
-		if (!this.session) {
-			this.sessionInitialization ??= loadSessionDefinition(this.agentConfig.session, context).then((session) => {
-				if (!session) throw new Error("Failed to initialize configured session");
-				this.session = session;
-				return session;
-			}).catch((error) => {
-				this.sessionInitialization = void 0;
-				throw error;
-			});
-			return await this.sessionInitialization;
-		}
-		return this.session;
-	}
-	async withSessionLock(session, callback) {
-		const previousRun = this.sessionQueues.get(session) ?? Promise.resolve();
-		let release = () => {};
-		const currentRun = new Promise((resolve) => {
-			release = resolve;
-		});
-		this.sessionQueues.set(session, currentRun);
-		await previousRun;
-		try {
-			return await callback();
-		} finally {
-			release();
-			if (this.sessionQueues.get(session) === currentRun) this.sessionQueues.delete(session);
-		}
-	}
-};
-function mergeArrays(existing, additions) {
-	if (!existing?.length && !additions?.length) return;
-	return [...existing ?? [], ...additions ?? []];
-}
-function cloneAgentPreservingHooks(source, config) {
-	const cloned = source.clone(config);
-	shareAgentEventEmitter(source, cloned);
-	return cloned;
-}
-/**
-* Clone the executable agent graph so provider-level model overrides win on every turn.
-*
-* The Agents SDK treats Runner model configuration as a fallback: explicit settings on an agent
-* take precedence. Handoff agents therefore need the same overrides applied before execution.
-*/
-function applyExecutionOverrides(agent, overrides, refreshPlainHandoffs = true) {
-	if (overrides.model === void 0 && overrides.modelSettings === void 0) return agent;
-	const clonedAgents = /* @__PURE__ */ new WeakMap();
-	const refreshAgent = (source, visited) => {
-		const existing = clonedAgents.get(source);
-		if (existing && visited.has(source)) return existing;
-		const snapshot = cloneAgentPreservingHooks(source, {
-			...overrides.model === void 0 ? {} : { model: overrides.model },
-			...overrides.modelSettings === void 0 ? {} : { modelSettings: overrides.modelSettings },
-			handoffs: [],
-			tools: source.tools.length > 0 || source.hasExplicitToolConfig() ? source.tools : void 0
-		});
-		const cloned = existing ? Object.assign(existing, snapshot) : snapshot;
-		clonedAgents.set(source, cloned);
-		visited.add(source);
-		cloned.handoffs = source.handoffs.map((candidate) => {
-			const explicitHandoff = "clone" in candidate && "agent" in candidate;
-			if (!explicitHandoff && !refreshPlainHandoffs) return refreshAgent(candidate, visited);
-			const agentHandoff = explicitHandoff ? candidate : handoff(candidate);
-			return agentHandoff.clone({
-				agent: refreshAgent(agentHandoff.agent, visited),
-				onInvokeHandoff: async (context, args) => refreshAgent(await agentHandoff.onInvokeHandoff(context, args), /* @__PURE__ */ new WeakSet())
-			});
-		});
-		return cloned;
-	};
-	return refreshAgent(agent, /* @__PURE__ */ new WeakSet());
-}
-let tracingProcessorRegistration;
-async function ensureTracingExporterRegistered() {
-	if (!tracingProcessorRegistration) tracingProcessorRegistration = Promise.resolve().then(() => {
-		const processor = new BatchTraceProcessor(new OTLPTracingExporter(), {
-			maxQueueSize: 100,
-			maxBatchSize: 10,
-			scheduleDelay: 1e3
-		});
-		addTraceProcessor(processor);
-		startTraceExportLoop();
-		logger.debug("[AgentsProvider] Tracing processor registered");
-	});
-	await tracingProcessorRegistration;
-}
-function parseTraceparent(traceparent) {
-	if (!traceparent) return;
-	const match = traceparent.trim().toLowerCase().match(/^[\da-f]{2}-([\da-f]{32})-([\da-f]{16})-[\da-f]{2}$/);
-	if (!match) return;
-	return {
-		traceId: match[1],
-		parentSpanId: match[2]
-	};
-}
-function buildTraceMetadata(context, otlpEndpoint, traceContext, otlpFormat, requestedModel, modelProvider) {
-	return {
-		...context?.evaluationId ? { "evaluation.id": context.evaluationId } : {},
-		...context?.testCaseId ? { "test.case.id": context.testCaseId } : {},
-		...traceContext?.parentSpanId ? { "promptfoo.parent_span_id": traceContext.parentSpanId } : {},
-		...otlpEndpoint ? { "promptfoo.otlp_endpoint": otlpEndpoint } : {},
-		...otlpFormat === "protobuf" ? { "promptfoo.otlp_format": otlpFormat } : {},
-		...requestedModel ? { "promptfoo.request_model": requestedModel } : {},
-		...modelProvider ? { "promptfoo.model_provider": modelProvider } : {}
-	};
-}
-function getModelProviderName(model) {
-	if (!model || typeof model !== "object") return;
-	const modelRecord = model;
-	for (const value of [
-		modelRecord.provider,
-		modelRecord.providerName,
-		modelRecord.providerId
-	]) if (typeof value === "string" && value) return value;
-}
-function summarizeUsageDetails(details) {
-	const entries = Array.isArray(details) ? details : details ? [details] : [];
-	const summary = {};
-	for (const entry of entries) for (const [key, value] of Object.entries(entry)) if (typeof value === "number") summary[key] = (summary[key] ?? 0) + value;
-	return summary;
-}
-function parseAgentInputItems(value) {
-	if (Array.isArray(value)) {
-		if (value.length === 0) return;
-		const parsedItems = [];
-		for (const item of value) {
-			const parsedItem = protocol.ModelItem.safeParse(item);
-			if (!parsedItem.success) return;
-			parsedItems.push(parsedItem.data);
-		}
-		return parsedItems;
-	}
-	const parsedItem = protocol.ModelItem.safeParse(value);
-	if (!parsedItem.success) return;
-	return [parsedItem.data];
-}
-function isAgentLike(value) {
-	return !!value && typeof value === "object" && "clone" in value && typeof value.clone === "function" && "tools" in value && Array.isArray(value.tools);
-}
-function shareAgentEventEmitter(source, target) {
-	const sourceWithEmitter = source;
-	if (sourceWithEmitter.eventEmitter) target.eventEmitter = sourceWithEmitter.eventEmitter;
-}
-function validateExecuteTools(value) {
-	if (value !== void 0 && value !== true && value !== false && value !== "real" && value !== "mock") throw new Error("executeTools must be true, false, 'real', or 'mock'");
-}
-function snapshotMockModelSettings(modelSettings) {
-	const snapshot = { ...modelSettings };
-	if (modelSettings.providerData) {
-		const providerData = { ...modelSettings.providerData };
-		for (const key of ["extraBody", "extra_body"]) {
-			const body = providerData[key];
-			if (body && typeof body === "object" && !Array.isArray(body)) providerData[key] = Object.freeze({ ...body });
-		}
-		snapshot.providerData = Object.freeze(providerData);
-	}
-	return Object.freeze(snapshot);
-}
-function assertNoMockToolOverrides(modelSettings, source) {
-	if (!modelSettings || typeof modelSettings !== "object" && typeof modelSettings !== "function") return;
-	const providerData = modelSettings.providerData;
-	if (!providerData || typeof providerData !== "object" && typeof providerData !== "function") return;
-	const providerDataRecord = providerData;
-	const extraBodies = [providerDataRecord.extraBody, providerDataRecord.extra_body];
-	const overridesPrompt = Object.prototype.hasOwnProperty.call(providerDataRecord, "prompt") || extraBodies.some((extraBody) => extraBody != null && Object.prototype.hasOwnProperty.call(extraBody, "prompt"));
-	const overridesTools = Object.prototype.hasOwnProperty.call(providerDataRecord, "tools") || extraBodies.some((extraBody) => extraBody != null && Object.prototype.hasOwnProperty.call(extraBody, "tools"));
-	if (overridesPrompt || overridesTools) throw new Error(`executeTools: false/'mock' cannot safely use providerData ${overridesPrompt ? "prompt" : "tool"} overrides from ${source}`);
-}
-//#endregion
-export { OpenAiAgentsProvider };
-
-//# sourceMappingURL=agents-6hDRNoYD.js.map