promptfoo 0.121.3 → 0.121.5

package/dist/src/codex-sdk-ZLKfDjqP.cjs

@@ -1,838 +0,0 @@
-const require_logger = require("./logger-D5iKBpu_.cjs");
-const require_esm = require("./esm-CipptfDu.cjs");
-const require_genaiTracer = require("./genaiTracer-BfxrvSUb.cjs");
-let fs = require("fs");
-fs = require_logger.__toESM(fs);
-let path = require("path");
-path = require_logger.__toESM(path);
-let dedent = require("dedent");
-dedent = require_logger.__toESM(dedent);
-let crypto = require("crypto");
-crypto = require_logger.__toESM(crypto);
-let _opentelemetry_api = require("@opentelemetry/api");
-//#region src/providers/openai/codex-sdk.ts
-const MINIMAL_CLI_ENV_KEYS = [
-	"PATH",
-	"Path",
-	"HOME",
-	"USER",
-	"USERNAME",
-	"USERPROFILE",
-	"TMPDIR",
-	"TMP",
-	"TEMP",
-	"SHELL",
-	"COMSPEC",
-	"SystemRoot",
-	"PATHEXT",
-	"LANG",
-	"LC_ALL",
-	"TERM"
-];
-function getMinimalProcessEnv() {
-	const env = {};
-	for (const key of MINIMAL_CLI_ENV_KEYS) {
-		const value = process.env[key];
-		if (typeof value === "string" && value.length > 0) env[key] = value;
-	}
-	return env;
-}
-/**
-* Helper to load the OpenAI Codex SDK ESM module
-* Uses resolvePackageEntryPoint to handle ESM-only packages with restrictive exports
-*/
-async function loadCodexSDK() {
-	const basePaths = [require_logger.state.basePath && path.default.isAbsolute(require_logger.state.basePath) ? require_logger.state.basePath : void 0, process.cwd()].filter((candidate) => Boolean(candidate));
-	let codexPath = null;
-	for (const basePath of new Set(basePaths)) {
-		codexPath = require_esm.resolvePackageEntryPoint("@openai/codex-sdk", basePath);
-		if (codexPath) break;
-	}
-	if (!codexPath) throw new Error(dedent.default`The @openai/codex-sdk package is required but not installed.
-
-      To use the OpenAI Codex SDK provider, install it with:
-        npm install @openai/codex-sdk
-
-      Requires Node.js 18+.
-
-      For more information, see: https://www.promptfoo.dev/docs/providers/openai-codex-sdk/`);
-	try {
-		return await require_esm.importModule(codexPath);
-	} catch (err) {
-		require_logger.logger.error(`Failed to load OpenAI Codex SDK: ${err}`);
-		if (err.stack) require_logger.logger.error(err.stack);
-		throw new Error(dedent.default`Failed to load @openai/codex-sdk.
-
-      The package was found but could not be loaded. This may be due to:
-      - Incompatible Node.js version (requires Node.js 18+)
-      - Corrupted installation
-
-      Try reinstalling:
-        npm install @openai/codex-sdk
-
-      For more information, see: https://www.promptfoo.dev/docs/providers/openai-codex-sdk/`);
-	}
-}
-const CODEX_MODEL_PRICING = {
-	"gpt-5.4": {
-		input: 2.5,
-		output: 15,
-		cache_read: .25
-	},
-	"gpt-5.4-pro": {
-		input: 30,
-		output: 180,
-		cache_read: 30
-	},
-	"gpt-5.3-codex": {
-		input: 1.75,
-		output: 14,
-		cache_read: .175
-	},
-	"gpt-5.3-codex-spark": {
-		input: .5,
-		output: 4,
-		cache_read: .05
-	},
-	"gpt-5.2": {
-		input: 1.75,
-		output: 14,
-		cache_read: .175
-	},
-	"gpt-5.2-codex": {
-		input: 1.75,
-		output: 14,
-		cache_read: .175
-	},
-	"gpt-5.1-codex": {
-		input: 2,
-		output: 8,
-		cache_read: .2
-	},
-	"gpt-5.1-codex-max": {
-		input: 3,
-		output: 12,
-		cache_read: .3
-	},
-	"gpt-5.1-codex-mini": {
-		input: .5,
-		output: 2,
-		cache_read: .05
-	},
-	"gpt-5-codex": {
-		input: 2,
-		output: 8,
-		cache_read: .2
-	},
-	"gpt-5-codex-mini": {
-		input: .5,
-		output: 2,
-		cache_read: .05
-	},
-	"gpt-5": {
-		input: 2,
-		output: 8,
-		cache_read: .2
-	}
-};
-var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
-	static OPENAI_MODELS = [
-		"gpt-5.4",
-		"gpt-5.4-pro",
-		"gpt-5.3-codex",
-		"gpt-5.3-codex-spark",
-		"gpt-5.2",
-		"gpt-5.2-codex",
-		"gpt-5.1-codex",
-		"gpt-5.1-codex-max",
-		"gpt-5.1-codex-mini",
-		"gpt-5-codex",
-		"gpt-5-codex-mini",
-		"gpt-5"
-	];
-	config;
-	env;
-	apiKey;
-	providerId = "openai:codex-sdk";
-	codexModule;
-	codexInstance;
-	codexInstanceEnvHash;
-	threads = /* @__PURE__ */ new Map();
-	deepTracingWarningShown = false;
-	constructor(options = {}) {
-		const { config, env, id } = options;
-		this.config = config ?? {};
-		this.env = env;
-		this.apiKey = this.getApiKey();
-		this.providerId = id ?? this.providerId;
-		if (this.config.model && !OpenAICodexSDKProvider.OPENAI_MODELS.includes(this.config.model)) require_logger.logger.warn(`Using unknown model for OpenAI Codex SDK: ${this.config.model}`);
-	}
-	id() {
-		return this.providerId;
-	}
-	getApiKey() {
-		return this.config?.apiKey || this.env?.OPENAI_API_KEY || this.env?.CODEX_API_KEY || require_logger.getEnvString("OPENAI_API_KEY") || require_logger.getEnvString("CODEX_API_KEY");
-	}
-	toString() {
-		return "[OpenAI Codex SDK Provider]";
-	}
-	/**
-	* Safely tear down a Codex instance by calling its cleanup method
-	* (destroy, cleanup, or close -- whichever is available).
-	*/
-	async destroyInstance(instance) {
-		if (typeof instance.destroy === "function") await instance.destroy();
-		else if (typeof instance.cleanup === "function") await instance.cleanup();
-		else if (typeof instance.close === "function") await instance.close();
-	}
-	async cleanup() {
-		this.threads.clear();
-		if (this.codexInstance) {
-			try {
-				await this.destroyInstance(this.codexInstance);
-			} catch (error) {
-				require_logger.logger.warn("[CodexSDK] Error during cleanup", { error });
-			}
-			this.codexInstance = void 0;
-			this.codexInstanceEnvHash = void 0;
-		}
-	}
-	prepareEnvironment(config, traceparent) {
-		const env = {
-			...config.cli_env === void 0 || config.inherit_process_env === true ? process.env : getMinimalProcessEnv(),
-			...config.cli_env ?? {}
-		};
-		const sortedEnv = {};
-		for (const key of Object.keys(env).sort()) if (env[key] !== void 0) sortedEnv[key] = env[key];
-		if (this.apiKey) {
-			sortedEnv.OPENAI_API_KEY = this.apiKey;
-			sortedEnv.CODEX_API_KEY = this.apiKey;
-		}
-		if (this.env) for (const key of Object.keys(this.env).sort()) {
-			const value = this.env[key];
-			if (value !== void 0) sortedEnv[key] = value;
-		}
-		if (config.deep_tracing) {
-			if (!sortedEnv.OTEL_EXPORTER_OTLP_ENDPOINT) sortedEnv.OTEL_EXPORTER_OTLP_ENDPOINT = "http://127.0.0.1:4318";
-			if (!sortedEnv.OTEL_EXPORTER_OTLP_PROTOCOL) sortedEnv.OTEL_EXPORTER_OTLP_PROTOCOL = "http/json";
-			if (!sortedEnv.OTEL_SERVICE_NAME) sortedEnv.OTEL_SERVICE_NAME = "codex-cli";
-			if (!sortedEnv.OTEL_TRACES_EXPORTER) sortedEnv.OTEL_TRACES_EXPORTER = "otlp";
-			if (traceparent) sortedEnv.TRACEPARENT = traceparent;
-			require_logger.logger.debug("[CodexSDK] Injecting OTEL config for deep tracing", {
-				traceparent: traceparent || "(none - CLI will start own trace)",
-				endpoint: sortedEnv.OTEL_EXPORTER_OTLP_ENDPOINT,
-				userConfigured: {
-					endpoint: !!env.OTEL_EXPORTER_OTLP_ENDPOINT,
-					protocol: !!env.OTEL_EXPORTER_OTLP_PROTOCOL,
-					serviceName: !!env.OTEL_SERVICE_NAME
-				}
-			});
-		} else delete sortedEnv.TRACEPARENT;
-		return sortedEnv;
-	}
-	getSkillRootPrefixes(env) {
-		const prefixes = /* @__PURE__ */ new Set();
-		const addPrefix = (candidate) => {
-			if (!candidate) return;
-			const normalized = candidate.replace(/\\/g, "/").replace(/\/+$/g, "");
-			if (normalized) prefixes.add(normalized);
-		};
-		addPrefix(env.CODEX_HOME);
-		addPrefix("/etc/codex");
-		const homeDir = env.HOME || process.env.HOME;
-		if (homeDir) addPrefix(path.default.posix.join(homeDir.replace(/\\/g, "/"), ".codex"));
-		return Array.from(prefixes);
-	}
-	isValidCodexSkillName(name) {
-		return /^[A-Za-z0-9._:-]+$/.test(name);
-	}
-	extractSkillPathCandidates(text, skillRootPrefixes = []) {
-		const matches = /* @__PURE__ */ new Map();
-		for (const rawToken of text.split(/\s+/)) {
-			const token = rawToken.replace(/^[`"'([{<]+|[`"',;:)\]}>]+$/g, "").trim();
-			if (!token) continue;
-			const normalizedPath = token.replace(/\\/g, "/");
-			const repoMatch = normalizedPath.match(/^\.agents\/skills\/([^/\s]+)\/SKILL\.md$/);
-			if (repoMatch) {
-				if (this.isValidCodexSkillName(repoMatch[1])) matches.set(normalizedPath, {
-					name: repoMatch[1],
-					path: normalizedPath
-				});
-				continue;
-			}
-			const matchingRoot = skillRootPrefixes.find((prefix) => normalizedPath.startsWith(`${prefix}/skills/`));
-			if (!matchingRoot) continue;
-			const customRootMatch = normalizedPath.slice(matchingRoot.length + 1).match(/^skills\/([^/\s]+)\/SKILL\.md$/);
-			if (customRootMatch && this.isValidCodexSkillName(customRootMatch[1])) matches.set(normalizedPath, {
-				name: customRootMatch[1],
-				path: normalizedPath
-			});
-		}
-		return Array.from(matches.values());
-	}
-	extractSkillCallsFromItems(items, skillRootPrefixes = [], options = {}) {
-		const skillCalls = /* @__PURE__ */ new Map();
-		for (const item of items) {
-			if (item?.type !== "command_execution") continue;
-			if (options.requireSuccessfulCommand && !this.isSuccessfulCommandExecution(item)) continue;
-			const command = typeof item.command === "string" && item.command.trim() ? item.command : void 0;
-			if (!command) continue;
-			for (const skillPath of this.extractSkillPathCandidates(command, skillRootPrefixes)) {
-				const existing = skillCalls.get(skillPath.path) ?? {
-					name: skillPath.name,
-					path: skillPath.path
-				};
-				skillCalls.set(skillPath.path, existing);
-			}
-		}
-		return Array.from(skillCalls.values()).map((skillCall) => ({
-			name: skillCall.name,
-			path: skillCall.path,
-			source: "heuristic"
-		}));
-	}
-	buildSkillMetadata(items, skillRootPrefixes = []) {
-		if (!Array.isArray(items) || items.length === 0) return;
-		const attemptedSkillCalls = this.extractSkillCallsFromItems(items, skillRootPrefixes);
-		const skillCalls = this.extractSkillCallsFromItems(items, skillRootPrefixes, { requireSuccessfulCommand: true });
-		if (skillCalls.length === 0 && attemptedSkillCalls.length <= skillCalls.length) return;
-		return {
-			attemptedSkillCalls,
-			skillCalls
-		};
-	}
-	isSuccessfulCommandExecution(item) {
-		if (item?.type !== "command_execution") return false;
-		if (typeof item.status === "string" && item.status !== "completed") return false;
-		if (typeof item.exit_code === "number" && item.exit_code !== 0) return false;
-		return true;
-	}
-	validateWorkingDirectory(workingDir, skipGitCheck = false) {
-		let stats;
-		try {
-			stats = fs.default.statSync(workingDir);
-		} catch (err) {
-			throw new Error(`Working directory ${workingDir} does not exist or isn't accessible: ${err.message}`);
-		}
-		if (!stats.isDirectory()) throw new Error(`Working directory ${workingDir} is not a directory`);
-		if (!skipGitCheck) {
-			const gitDir = path.default.join(workingDir, ".git");
-			if (!fs.default.existsSync(gitDir)) throw new Error(dedent.default`Working directory ${workingDir} is not a Git repository.
-
-          Codex requires a Git repository by default to prevent unrecoverable errors.
-
-          To bypass this check, set skip_git_repo_check: true in your provider config.`);
-		}
-	}
-	/**
-	* Build Codex constructor options from provider config.
-	* Used when creating both local (deep-tracing) and cached instances.
-	*/
-	buildCodexOptions(env, config) {
-		return {
-			env,
-			...this.apiKey ? { apiKey: this.apiKey } : {},
-			...config.codex_path_override ? { codexPathOverride: config.codex_path_override } : {},
-			...config.base_url ? { baseUrl: config.base_url } : {},
-			...config.cli_config ? { config: config.cli_config } : {}
-		};
-	}
-	buildThreadOptions(config) {
-		return {
-			workingDirectory: config.working_dir,
-			skipGitRepoCheck: config.skip_git_repo_check ?? false,
-			...config.model ? { model: config.model } : {},
-			...config.additional_directories?.length ? { additionalDirectories: config.additional_directories } : {},
-			...config.sandbox_mode ? { sandboxMode: config.sandbox_mode } : {},
-			...config.model_reasoning_effort ? { modelReasoningEffort: config.model_reasoning_effort } : {},
-			...config.network_access_enabled === void 0 ? {} : { networkAccessEnabled: config.network_access_enabled },
-			...config.web_search_mode ? { webSearchMode: config.web_search_mode } : {},
-			...config.web_search_enabled !== void 0 && !config.web_search_mode ? { webSearchEnabled: config.web_search_enabled } : {},
-			...config.approval_policy ? { approvalPolicy: config.approval_policy } : {}
-		};
-	}
-	async getOrCreateThread(config, cacheKey, instance) {
-		const threadOptions = this.buildThreadOptions(config);
-		if (config.deep_tracing) return instance.startThread(threadOptions);
-		if (config.thread_id) {
-			const cached = this.threads.get(config.thread_id);
-			if (cached) return cached;
-			const thread = instance.resumeThread(config.thread_id, threadOptions);
-			if (config.persist_threads) this.threads.set(config.thread_id, thread);
-			return thread;
-		}
-		if (config.persist_threads && cacheKey) {
-			const cached = this.threads.get(cacheKey);
-			if (cached) return cached;
-			const poolSize = config.thread_pool_size ?? 1;
-			if (this.threads.size >= poolSize) {
-				const oldestKey = this.threads.keys().next().value;
-				if (oldestKey) this.threads.delete(oldestKey);
-			}
-		}
-		const thread = instance.startThread(threadOptions);
-		if (config.persist_threads && cacheKey) this.threads.set(cacheKey, thread);
-		return thread;
-	}
-	async runStreaming(thread, prompt, runOptions, callOptions, skillRootPrefixes = []) {
-		const { events } = await thread.runStreamed(prompt, runOptions);
-		const items = [];
-		let usage = void 0;
-		const tracer = _opentelemetry_api.trace.getTracer("promptfoo.codex-sdk");
-		const activeSpans = /* @__PURE__ */ new Map();
-		const itemStartTimes = /* @__PURE__ */ new Map();
-		let lastEventTime = Date.now();
-		const reasoningTexts = [];
-		const conversationMessages = [];
-		conversationMessages.push({
-			role: "user",
-			content: prompt
-		});
-		try {
-			for await (const event of events) {
-				const eventTime = Date.now();
-				if (callOptions?.abortSignal?.aborted) {
-					const abortError = /* @__PURE__ */ new Error("AbortError");
-					abortError.name = "AbortError";
-					throw abortError;
-				}
-				switch (event.type) {
-					case "item.started": {
-						const item = event.item;
-						if (!item) {
-							require_logger.logger.warn("Codex item.started event missing item", { event });
-							break;
-						}
-						if (!item.id) {
-							require_logger.logger.debug("Codex item.started without id, will create span at completion", { type: item.type });
-							break;
-						}
-						const itemId = String(item.id);
-						const spanName = this.getSpanNameForItem(item);
-						const span = tracer.startSpan(spanName, {
-							kind: _opentelemetry_api.SpanKind.INTERNAL,
-							attributes: {
-								"codex.item.id": itemId,
-								"codex.item.type": item.type,
-								...this.getAttributesForItem(item)
-							}
-						});
-						activeSpans.set(itemId, span);
-						itemStartTimes.set(itemId, eventTime);
-						require_logger.logger.debug("Codex item started", {
-							itemId,
-							type: item.type
-						});
-						break;
-					}
-					case "item.completed": {
-						const item = event.item;
-						if (!item) {
-							require_logger.logger.warn("Codex item.completed event missing item", { event });
-							break;
-						}
-						const itemId = item.id ? String(item.id) : crypto.default.randomUUID();
-						items.push(item);
-						if (item.type === "reasoning" && typeof item.text === "string") reasoningTexts.push(item.text);
-						if (item.type === "agent_message" && typeof item.text === "string") conversationMessages.push({
-							role: "assistant",
-							content: item.text
-						});
-						let span = activeSpans.get(itemId);
-						const hadStartEvent = span !== void 0;
-						if (!span) {
-							const spanName = this.getSpanNameForItem(item);
-							span = tracer.startSpan(spanName, {
-								kind: _opentelemetry_api.SpanKind.INTERNAL,
-								startTime: lastEventTime,
-								attributes: {
-									"codex.item.id": itemId,
-									"codex.item.type": item.type,
-									"codex.timing.estimated": true,
-									...this.getAttributesForItem(item)
-								}
-							});
-						}
-						const completionAttrs = this.getCompletionAttributesForItem(item, skillRootPrefixes);
-						for (const [key, value] of Object.entries(completionAttrs)) span.setAttribute(key, value);
-						const durationMs = eventTime - (itemStartTimes.get(itemId) || lastEventTime);
-						span.setAttribute("codex.duration_ms", durationMs);
-						span.setAttribute("codex.had_start_event", hadStartEvent);
-						if (item.type === "reasoning" && typeof item.text === "string") span.addEvent("reasoning", { "codex.reasoning.text": item.text });
-						if (item.type === "agent_message" && typeof item.text === "string") span.addEvent("message", { "codex.message.text": item.text });
-						if (item.type === "command_execution" && typeof item.aggregated_output === "string") span.addEvent("output", { "codex.command.output": item.aggregated_output });
-						if (item.status === "failed" || item.type === "error" || item.error !== void 0 || item.type === "command_execution" && typeof item.exit_code === "number" && item.exit_code !== 0) span.setStatus({
-							code: _opentelemetry_api.SpanStatusCode.ERROR,
-							message: (typeof item.message === "string" ? item.message : null) || (typeof item.error?.message === "string" ? item.error.message : null) || (item.type === "command_execution" && item.exit_code !== 0 ? `Command exited with code ${item.exit_code}` : null) || "Item failed"
-						});
-						else span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
-						span.end();
-						activeSpans.delete(itemId);
-						itemStartTimes.delete(itemId);
-						require_logger.logger.debug("Codex item completed", {
-							itemId,
-							type: item.type,
-							durationMs
-						});
-						break;
-					}
-					case "item.updated": {
-						const item = event.item;
-						if (item?.id) {
-							const itemId = String(item.id);
-							const span = activeSpans.get(itemId);
-							if (span) {
-								const updatedAttrs = this.getCompletionAttributesForItem(item, skillRootPrefixes);
-								for (const [key, value] of Object.entries(updatedAttrs)) span.setAttribute(key, value);
-							}
-						}
-						require_logger.logger.debug("Codex item updated", {
-							itemId: item?.id,
-							type: item?.type
-						});
-						break;
-					}
-					case "turn.completed":
-						usage = event.usage;
-						require_logger.logger.debug("Codex turn completed", { usage });
-						break;
-					case "turn.failed": {
-						const errorMsg = event.error?.message || "Turn failed";
-						require_logger.logger.error("Codex turn failed", { error: errorMsg });
-						throw new Error(`Codex turn failed: ${errorMsg}`);
-					}
-					default: require_logger.logger.debug("Codex unknown event type", { type: event.type });
-				}
-				lastEventTime = eventTime;
-			}
-		} finally {
-			for (const [itemId, span] of activeSpans) {
-				require_logger.logger.warn("Codex item span not properly closed", { itemId });
-				span.setStatus({
-					code: _opentelemetry_api.SpanStatusCode.ERROR,
-					message: "Span not properly closed"
-				});
-				span.end();
-			}
-			activeSpans.clear();
-			itemStartTimes.clear();
-		}
-		const agentMessages = items.filter((i) => i.type === "agent_message");
-		return {
-			finalResponse: agentMessages.length > 0 ? agentMessages.map((i) => i.text).join("\n") : "",
-			items,
-			usage,
-			reasoningTexts,
-			conversationMessages
-		};
-	}
-	/**
-	* Get a descriptive span name for a Codex item
-	*/
-	getSpanNameForItem(item) {
-		switch (item.type) {
-			case "command_execution": return `exec ${typeof item.command === "string" ? item.command.split(" ")[0] || "command" : "command"}`;
-			case "file_change": return `file ${item.changes?.[0]?.kind || "change"}`;
-			case "mcp_tool_call": return `mcp ${typeof item.server === "string" ? item.server : "unknown"}/${typeof item.tool === "string" ? item.tool : "unknown"}`;
-			case "agent_message": return "agent response";
-			case "reasoning": return "reasoning";
-			case "web_search": return `search "${typeof item.query === "string" ? item.query.slice(0, 30) : ""}"`;
-			case "todo_list": return "todo update";
-			case "error": return "error";
-			case "collaboration_tool_call": return `collab ${typeof item.tool === "string" ? item.tool : "unknown"}`;
-			case "spawn_agent": return `spawn ${typeof item.role === "string" ? item.role : "agent"}`;
-			case "send_input": return "send input";
-			case "agent_wait": return "wait";
-			default: return `codex.${item.type || "unknown"}`;
-		}
-	}
-	/**
-	* Get attributes for a Codex item at start
-	*/
-	getSkillTraceAttributes(item, skillRootPrefixes = [], options = {}) {
-		if (item?.type !== "command_execution") return {};
-		if (options.requireSuccessfulCommand && !this.isSuccessfulCommandExecution(item)) return {};
-		const command = typeof item.command === "string" && item.command.trim() ? item.command : void 0;
-		const skillCandidates = /* @__PURE__ */ new Map();
-		if (command) for (const skill of this.extractSkillPathCandidates(command, skillRootPrefixes)) skillCandidates.set(skill.path, skill);
-		if (skillCandidates.size === 0) return {};
-		const skills = Array.from(skillCandidates.values());
-		const attrs = {
-			"promptfoo.skill.count": skills.length,
-			"promptfoo.skill.names": skills.map((skill) => skill.name).join(","),
-			"promptfoo.skill.paths": skills.map((skill) => skill.path).join(",")
-		};
-		if (skills.length === 1) {
-			attrs["promptfoo.skill.name"] = skills[0].name;
-			attrs["promptfoo.skill.path"] = skills[0].path;
-		}
-		return attrs;
-	}
-	getAttributesForItem(item) {
-		const attrs = {};
-		switch (item.type) {
-			case "command_execution":
-				if (typeof item.command === "string") attrs["codex.command"] = item.command;
-				break;
-			case "mcp_tool_call":
-				if (typeof item.server === "string") attrs["codex.mcp.server"] = item.server;
-				if (typeof item.tool === "string") attrs["codex.mcp.tool"] = item.tool;
-				{
-					const serializedArgs = this.serializeItemValue(item.arguments ?? item.args ?? item.input);
-					if (serializedArgs) attrs["codex.mcp.input"] = serializedArgs;
-				}
-				break;
-			case "web_search":
-				if (typeof item.query === "string") attrs["codex.search.query"] = item.query;
-				break;
-			case "collaboration_tool_call":
-				if (typeof item.tool === "string") attrs["codex.collab.tool"] = item.tool;
-				if (typeof item.target_thread_id === "string") attrs["codex.collab.target_thread"] = item.target_thread_id;
-				break;
-			case "spawn_agent":
-				if (typeof item.role === "string") attrs["codex.collab.role"] = item.role;
-				if (typeof item.thread_id === "string") attrs["codex.collab.spawned_thread"] = item.thread_id;
-				break;
-			case "send_input":
-				if (typeof item.target_thread_id === "string") attrs["codex.collab.target_thread"] = item.target_thread_id;
-				break;
-		}
-		return attrs;
-	}
-	serializeItemValue(value) {
-		if (typeof value === "string") {
-			const trimmed = value.trim();
-			if (!trimmed) return;
-			try {
-				return JSON.stringify(this.redactTracePii(require_logger.sanitizeObject(JSON.parse(trimmed))));
-			} catch {
-				return this.redactTracePii(require_logger.sanitizeObject(trimmed, { context: "Codex MCP trace input" }));
-			}
-		}
-		if (value === void 0 || value === null) return;
-		try {
-			return JSON.stringify(this.redactTracePii(require_logger.sanitizeObject(value, { context: "Codex MCP trace input" })));
-		} catch {
-			return;
-		}
-	}
-	redactTracePii(value) {
-		if (typeof value === "string" && /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.test(value)) return require_logger.REDACTED;
-		if (Array.isArray(value)) return value.map((item) => this.redactTracePii(item));
-		if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, require_logger.normalizeFieldName(key).includes("email") ? require_logger.REDACTED : this.redactTracePii(entryValue)]));
-		return value;
-	}
-	/**
-	* Get attributes for a Codex item at completion
-	*/
-	getCompletionAttributesForItem(item, skillRootPrefixes = []) {
-		const attrs = {};
-		switch (item.type) {
-			case "command_execution":
-				if (typeof item.exit_code === "number") attrs["codex.exit_code"] = item.exit_code;
-				if (typeof item.status === "string") attrs["codex.status"] = item.status;
-				if (typeof item.aggregated_output === "string") attrs["codex.output"] = item.aggregated_output;
-				Object.assign(attrs, this.getSkillTraceAttributes(item, skillRootPrefixes, { requireSuccessfulCommand: true }));
-				break;
-			case "file_change":
-				if (typeof item.status === "string") attrs["codex.status"] = item.status;
-				if (Array.isArray(item.changes) && item.changes.length) {
-					attrs["codex.files_changed"] = item.changes.length;
-					attrs["codex.files"] = item.changes.map((c) => typeof c?.path === "string" ? c.path : "").filter(Boolean).join(", ");
-				}
-				break;
-			case "mcp_tool_call":
-				if (typeof item.status === "string") attrs["codex.status"] = item.status;
-				if (typeof item.error?.message === "string") attrs["codex.error"] = item.error.message;
-				{
-					const serializedArgs = this.serializeItemValue(item.arguments ?? item.args ?? item.input);
-					if (serializedArgs) attrs["codex.mcp.input"] = serializedArgs;
-				}
-				break;
-			case "agent_message":
-				if (typeof item.text === "string") attrs["codex.message"] = item.text;
-				break;
-			case "reasoning":
-				if (typeof item.text === "string") attrs["codex.reasoning"] = item.text;
-				break;
-			case "error":
-				if (typeof item.message === "string") attrs["codex.error"] = item.message;
-				break;
-		}
-		return attrs;
-	}
-	generateCacheKey(config, prompt) {
-		const keyData = {
-			working_dir: config.working_dir,
-			additional_directories: config.additional_directories,
-			model: config.model,
-			output_schema: config.output_schema,
-			sandbox_mode: config.sandbox_mode,
-			model_reasoning_effort: config.model_reasoning_effort,
-			network_access_enabled: config.network_access_enabled,
-			web_search_enabled: config.web_search_enabled,
-			web_search_mode: config.web_search_mode,
-			approval_policy: config.approval_policy,
-			prompt
-		};
-		return `openai:codex-sdk:${crypto.default.createHash("sha256").update(JSON.stringify(keyData)).digest("hex")}`;
-	}
-	async callApi(prompt, context, callOptions) {
-		const config = {
-			...this.config,
-			...context?.prompt?.config
-		};
-		const modelName = config.model || "codex";
-		const spanContext = {
-			system: "openai",
-			operationName: "chat",
-			model: modelName,
-			providerId: this.id(),
-			evalId: context?.evaluationId || context?.test?.metadata?.evaluationId,
-			testIndex: typeof context?.test?.vars?.__testIdx === "number" ? context.test.vars.__testIdx : void 0,
-			promptLabel: context?.prompt?.label,
-			traceparent: context?.traceparent,
-			requestBody: prompt
-		};
-		const resultExtractor = (response) => {
-			const result = {};
-			if (response.tokenUsage) result.tokenUsage = response.tokenUsage;
-			if (response.sessionId) result.responseId = response.sessionId;
-			if (response.cached !== void 0) result.cacheHit = response.cached;
-			result.responseModel = modelName;
-			if (response.output !== void 0) try {
-				result.responseBody = typeof response.output === "string" ? response.output : JSON.stringify(response.output);
-			} catch {
-				result.responseBody = "[unable to serialize output]";
-			}
-			if (response.raw) try {
-				const rawData = typeof response.raw === "string" ? JSON.parse(response.raw) : response.raw;
-				if (rawData.reasoningTexts?.length > 0) result.additionalAttributes = {
-					"codex.reasoning.count": rawData.reasoningTexts.length,
-					"codex.reasoning.summary": rawData.reasoningTexts.join("\n---\n").slice(0, 2e3)
-				};
-				if (rawData.conversationMessages?.length > 0) result.additionalAttributes = {
-					...result.additionalAttributes,
-					"codex.conversation.message_count": rawData.conversationMessages.length
-				};
-				if (rawData.items?.length > 0) {
-					const itemCounts = {};
-					for (const item of rawData.items) itemCounts[item.type] = (itemCounts[item.type] || 0) + 1;
-					result.additionalAttributes = {
-						...result.additionalAttributes,
-						"codex.items.total": rawData.items.length,
-						"codex.items.breakdown": JSON.stringify(itemCounts)
-					};
-				}
-			} catch {}
-			return result;
-		};
-		return require_genaiTracer.withGenAISpan(spanContext, () => this.callApiInternal(prompt, context, callOptions, config), resultExtractor);
-	}
-	/**
-	* Internal implementation of callApi without tracing wrapper.
-	* Context is available for future use (e.g., _context?.vars for template rendering,
-	* _context?.bustCache for cache control, _context?.debug for debug mode).
-	*/
-	async callApiInternal(prompt, _context, callOptions, config) {
-		const currentTraceparent = require_genaiTracer.getTraceparent();
-		const env = this.prepareEnvironment(config, currentTraceparent);
-		const skillRootPrefixes = this.getSkillRootPrefixes(env);
-		if (!this.apiKey && !env.OPENAI_API_KEY && !env.CODEX_API_KEY) throw new Error("OpenAI API key is not set. Set OPENAI_API_KEY or CODEX_API_KEY environment variable or add \"apiKey\" to provider config.");
-		if (config.working_dir) this.validateWorkingDirectory(config.working_dir, config.skip_git_repo_check);
-		if (callOptions?.abortSignal?.aborted) return { error: "OpenAI Codex SDK call aborted before it started" };
-		if (!this.codexModule) this.codexModule = await loadCodexSDK();
-		let localInstance = void 0;
-		const useLocalInstance = config.deep_tracing;
-		if (useLocalInstance) {
-			if ((config.persist_threads || config.thread_id || (config.thread_pool_size ?? 0) > 1) && !this.deepTracingWarningShown) {
-				require_logger.logger.warn("[CodexSDK] deep_tracing is incompatible with thread persistence. Thread options (persist_threads, thread_id, thread_pool_size) are ignored when deep_tracing is enabled.");
-				this.deepTracingWarningShown = true;
-			}
-			localInstance = new this.codexModule.Codex(this.buildCodexOptions(env, config));
-		} else {
-			const stableEnv = { ...env };
-			delete stableEnv.TRACEPARENT;
-			const envHash = crypto.default.createHash("sha256").update(JSON.stringify(stableEnv)).digest("hex");
-			const envChanged = this.codexInstanceEnvHash !== envHash;
-			if (!this.codexInstance || envChanged) {
-				if (envChanged && this.codexInstance) {
-					require_logger.logger.debug("[CodexSDK] Recreating instance due to configuration change");
-					try {
-						await this.destroyInstance(this.codexInstance);
-					} catch (cleanupError) {
-						require_logger.logger.warn("[CodexSDK] Error cleaning up old instance", { error: cleanupError });
-					}
-					this.threads.clear();
-				}
-				this.codexInstance = new this.codexModule.Codex(this.buildCodexOptions(env, config));
-				this.codexInstanceEnvHash = envHash;
-			}
-		}
-		const activeInstance = useLocalInstance ? localInstance : this.codexInstance;
-		if (!activeInstance) throw new Error("Failed to create Codex instance - SDK module may have failed to load");
-		const cacheKey = this.generateCacheKey(config, prompt);
-		const thread = await this.getOrCreateThread(config, cacheKey, activeInstance);
-		const runOptions = {};
-		if (config.output_schema) runOptions.outputSchema = config.output_schema;
-		if (callOptions?.abortSignal) runOptions.signal = callOptions.abortSignal;
-		try {
-			const turn = config.enable_streaming ? await this.runStreaming(thread, prompt, runOptions, callOptions, skillRootPrefixes) : await thread.run(prompt, runOptions);
-			const output = turn.finalResponse || "";
-			const raw = JSON.stringify(turn);
-			const skillMetadata = this.buildSkillMetadata(turn.items, skillRootPrefixes);
-			const metadata = skillMetadata ? {
-				...skillMetadata.skillCalls.length > 0 ? { skillCalls: skillMetadata.skillCalls } : {},
-				...skillMetadata.attemptedSkillCalls.length > skillMetadata.skillCalls.length ? { attemptedSkillCalls: skillMetadata.attemptedSkillCalls } : {}
-			} : void 0;
-			const tokenUsage = turn.usage ? {
-				prompt: turn.usage.input_tokens,
-				completion: turn.usage.output_tokens,
-				total: turn.usage.input_tokens + turn.usage.output_tokens,
-				cached: turn.usage.cached_input_tokens || 0
-			} : void 0;
-			let cost = 0;
-			if (tokenUsage && config.model) {
-				const pricing = CODEX_MODEL_PRICING[config.model];
-				if (pricing) {
-					const cachedTokens = tokenUsage.cached || 0;
-					const inputCost = ((tokenUsage.prompt || 0) - cachedTokens) * (pricing.input / 1e6);
-					const cacheReadCost = cachedTokens * (pricing.cache_read / 1e6);
-					const outputCost = (tokenUsage.completion || 0) * (pricing.output / 1e6);
-					cost = inputCost + cacheReadCost + outputCost;
-				}
-			}
-			require_logger.logger.debug("OpenAI Codex SDK response", {
-				output,
-				usage: turn.usage
-			});
-			return {
-				output,
-				tokenUsage,
-				cost,
-				metadata,
-				raw,
-				sessionId: thread.id || "unknown"
-			};
-		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError" || callOptions?.abortSignal?.aborted) {
-				require_logger.logger.warn("OpenAI Codex SDK call aborted");
-				return { error: "OpenAI Codex SDK call aborted" };
-			}
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			require_logger.logger.error("Error calling OpenAI Codex SDK", { error: errorMessage });
-			return { error: `Error calling OpenAI Codex SDK: ${errorMessage}` };
-		} finally {
-			if (!config.deep_tracing && !config.persist_threads && !config.thread_id && cacheKey) this.threads.delete(cacheKey);
-			if (useLocalInstance && localInstance) try {
-				await this.destroyInstance(localInstance);
-			} catch (cleanupError) {
-				require_logger.logger.debug("[CodexSDK] Error cleaning up local instance", { error: cleanupError });
-			}
-		}
-	}
-};
-//#endregion
-exports.OpenAICodexSDKProvider = OpenAICodexSDKProvider;
-
-//# sourceMappingURL=codex-sdk-ZLKfDjqP.cjs.map