promptfoo 0.125.0 → 0.125.1

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

@@ -1,1588 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
-const require_logger = require("./logger-DXUHJBHJ.cjs");
-const require_fetch = require("./fetch-DYte6oQX.cjs");
-const require_esm = require("./esm-DITT-qdS.cjs");
-const require_render = require("./render-j-UNQw7s.cjs");
-const require_packageVersion = require("./packageVersion-CJ4hVGlE.cjs");
-const require_credentials = require("./credentials-CFfK32uY.cjs");
-const require_providerRegistry = require("./providerRegistry-CAn7vpBJ.cjs");
-const require_resourceAttributes = require("./resourceAttributes-DLxFq_6t.cjs");
-const require_genaiTracer = require("./genaiTracer-C32xFIB8.cjs");
-const require_agentic_utils = require("./agentic-utils-D23qtOlx.cjs");
-const require_agenticRunQueue = require("./agenticRunQueue-Cd8lOVSn.cjs");
-const require_agentWorkspace = require("./agentWorkspace-B8A_wuMR.cjs");
-const require_billing = require("./billing-ZA1NkqAK.cjs");
-require("./codex-runtime-Cd55T6a8.cjs");
-const require_codexSkillMetadata = require("./codexSkillMetadata-B5SLnY2i.cjs");
-let zod = require("zod");
-let path = require("path");
-path = require_rolldown_runtime.__toESM(path, 1);
-let node_fs = require("node:fs");
-node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
-let node_path = require("node:path");
-node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let fs = require("fs");
-fs = require_rolldown_runtime.__toESM(fs, 1);
-let dedent = require("dedent");
-dedent = require_rolldown_runtime.__toESM(dedent, 1);
-let _opentelemetry_api = require("@opentelemetry/api");
-let semver_functions_satisfies_js = require("semver/functions/satisfies.js");
-semver_functions_satisfies_js = require_rolldown_runtime.__toESM(semver_functions_satisfies_js, 1);
-let crypto = require("crypto");
-crypto = require_rolldown_runtime.__toESM(crypto, 1);
-let node_child_process = require("node:child_process");
-let semver = require("semver");
-semver = require_rolldown_runtime.__toESM(semver, 1);
-//#region src/providers/openai/codexCliCompatibility.ts
-const CODEX_SDK_PACKAGE = "@openai/codex-sdk";
-const CODEX_CLI_PACKAGE = "@openai/codex";
-const CODEX_SDK_DOCS_URL = "https://www.promptfoo.dev/docs/providers/openai-codex-sdk/";
-const CODEX_VERSION_PATTERN = /\bcodex-cli(?:-exec)?\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)/;
-const VERSION_PROBE_TIMEOUT_MS = 1e4;
-const VERSION_PROBE_MAX_OUTPUT_BYTES = 1048576;
-const VERSION_PROBE_MAX_STATUS_BYTES = 8192;
-const VERSION_PROBE_SUPERVISOR = `
-const { writeSync } = require('node:fs');
-let child;
-let stopping = false;
-let finalized = false;
-let commandExit;
-const finalize = (result) => {
-  if (finalized) return;
-  finalized = true;
-  try {
-    writeSync(3, JSON.stringify(result));
-  } catch {
-    // The owning process may already have closed its end of the status pipe.
-  } finally {
-    process.kill(-process.pid, 'SIGKILL');
-  }
-};
-const finish = (result) => {
-  if (stopping) return;
-  stopping = true;
-  if (!child || child.pid === undefined || commandExit) return finalize(result);
-
-  // Keep the direct CLI's reaper alive until its exit has been collected. Do
-  // not wait for close: descendants can retain its output pipes until group cleanup.
-  child.once('exit', () => finalize(result));
-  const terminationFailed = (error) => {
-    if (error.code === 'ESRCH') return; // Its exit notification may still be pending.
-    finalize({ error: (result.error ?? 'Could not finish Codex CLI version command') +
-      '; could not terminate the direct CLI process' });
-  };
-  child.on('error', terminationFailed);
-  try {
-    child.kill('SIGKILL');
-  } catch (error) {
-    terminationFailed(error);
-  }
-};
-const timeout = () => finish(commandExit ?? { error: 'Codex CLI version check timed out after ${VERSION_PROBE_TIMEOUT_MS}ms' });
-process.once('SIGTERM', timeout);
-process.stdin.once('end', () => finish({ error: 'Codex CLI version check owner disconnected' }));
-process.stdin.once('error', () => finish({ error: 'Codex CLI version check owner channel failed' }));
-const outputFailed = () => finish({ error: 'Could not capture Codex CLI version output' });
-process.stdout.once('error', outputFailed);
-process.stderr.once('error', outputFailed);
-const { spawn } = require('node:child_process');
-const { createInterface } = require('node:readline');
-let deadline = setTimeout(timeout, ${VERSION_PROBE_TIMEOUT_MS});
-createInterface({ input: process.stdin }).once('line', (line) => {
-  if (stopping) return;
-  let options;
-  try {
-    options = JSON.parse(line);
-  } catch {
-    return finish({ error: 'Codex CLI version check initialization failed' });
-  }
-  // process.ppid is a startup snapshot, so check the known owner as well as EOF.
-  try {
-    process.kill(options.ownerPid, 0);
-  } catch {
-    return finish({ error: 'Codex CLI version check owner exited before initialization' });
-  }
-  if (Date.now() >= options.deadlineAt) return timeout();
-  clearTimeout(deadline);
-  deadline = setTimeout(timeout, options.deadlineAt - Date.now());
-  try {
-    const { NODE_CHANNEL_FD, NODE_CHANNEL_SERIALIZATION_MODE, ...env } = options.env;
-    child = spawn(options.command, ['exec', '--experimental-json', '--version'], {
-      env,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    child.stdout.once('error', outputFailed);
-    child.stderr.once('error', outputFailed);
-    child.stdout.pipe(process.stdout, { end: false });
-    child.stderr.pipe(process.stderr, { end: false });
-    child.once('error', () => finish({ error: 'Could not start Codex CLI version command' }));
-    child.once('exit', (code, signal) => { commandExit = { code, signal }; });
-    child.once('close', (code, signal) => {
-      // Descendants can finish writing after the launcher exits. Drain both
-      // capture pipes and forwarding queues before ending the owned group.
-      const result = commandExit ?? { code, signal };
-      let pending = 2;
-      const flushed = (error) => {
-        if (error) outputFailed();
-        else if (--pending === 0) finish(result);
-      };
-      try {
-        process.stdout.write('', flushed);
-        process.stderr.write('', flushed);
-      } catch {
-        outputFailed();
-      }
-    });
-  } catch {
-    // Spawn/JSON diagnostics can include environment values. Keep these private.
-    finish({ error: 'Could not start Codex CLI version command' });
-  }
-});
-`;
-var CodexCliCompatibilityError = class extends Error {
-	name = "CodexCliCompatibilityError";
-};
-function getSupportedCliVersion(sdkEntryPoint) {
-	let directory = node_path.default.dirname(sdkEntryPoint);
-	while (true) {
-		const manifestPath = node_path.default.join(directory, "package.json");
-		if (node_fs.default.existsSync(manifestPath)) {
-			const manifest = JSON.parse(node_fs.default.readFileSync(manifestPath, "utf8"));
-			if (manifest.name === CODEX_SDK_PACKAGE) {
-				const version = manifest.dependencies?.[CODEX_CLI_PACKAGE];
-				if (!version || !semver.default.valid(version)) throw new Error(`${CODEX_SDK_PACKAGE} does not declare an exact ${CODEX_CLI_PACKAGE} version`);
-				return version;
-			}
-		}
-		const parent = node_path.default.dirname(directory);
-		if (parent === directory) throw new Error(`Could not find ${CODEX_SDK_PACKAGE}/package.json for ${sdkEntryPoint}`);
-		directory = parent;
-	}
-}
-/** Stop the trusted supervisor, or the direct Windows CLI process tree. */
-async function terminateProbe(child) {
-	if (process.platform !== "win32") {
-		child.stdin?.end();
-		return;
-	}
-	const pid = child.pid;
-	if (pid === void 0) return;
-	if (child.exitCode !== null || child.signalCode !== null) return;
-	const hostWindowsDir = process.env.SystemRoot;
-	if (!hostWindowsDir || !/^[a-z]:[\\/]/i.test(hostWindowsDir) || hostWindowsDir.includes("\0")) {
-		child.kill("SIGKILL");
-		throw new Error("Cannot locate the Windows system directory for Codex version cleanup");
-	}
-	const windowsDir = node_path.default.win32.normalize(hostWindowsDir);
-	const systemDir = node_path.default.win32.join(windowsDir, "System32");
-	try {
-		await new Promise((resolve, reject) => {
-			(0, node_child_process.execFile)(node_path.default.win32.join(systemDir, "taskkill.exe"), [
-				"/pid",
-				String(pid),
-				"/t",
-				"/f"
-			], {
-				windowsHide: true,
-				timeout: 1e3,
-				killSignal: "SIGKILL",
-				cwd: systemDir,
-				env: {
-					SystemRoot: windowsDir,
-					WINDIR: windowsDir,
-					PATH: systemDir
-				}
-			}, (error) => {
-				if (error && child.exitCode === null && child.signalCode === null) reject(error);
-				else resolve();
-			});
-		});
-	} catch (error) {
-		if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
-		throw error;
-	}
-}
-function parseProbeStatus(status) {
-	const result = JSON.parse(status);
-	if (result && typeof result === "object") {
-		const keys = Object.keys(result);
-		if (keys.length === 1 && "error" in result && typeof result.error === "string" && result.error.length > 0) return { error: result.error };
-		if (keys.length === 2 && "code" in result && "signal" in result && (typeof result.code === "number" && Number.isInteger(result.code) && result.code >= 0 && result.code <= 255 && result.signal === null || result.code === null && typeof result.signal === "string" && result.signal.length > 0)) return {
-			code: result.code,
-			signal: result.signal
-		};
-	}
-	throw new Error("Invalid Codex CLI version check status");
-}
-function runVersionProbe(options) {
-	options.signal?.throwIfAborted();
-	return new Promise((resolve, reject) => {
-		const deadlineAt = Date.now() + VERSION_PROBE_TIMEOUT_MS;
-		const supervised = process.platform !== "win32";
-		let initialization;
-		if (supervised) try {
-			initialization = `${JSON.stringify({
-				command: options.codexPathOverride,
-				env: options.env,
-				ownerPid: process.pid,
-				deadlineAt
-			})}\n`;
-		} catch {
-			throw new Error("Codex CLI version check initialization failed");
-		}
-		const child = supervised ? (0, node_child_process.spawn)(process.execPath, [
-			"--input-type=commonjs",
-			"--eval",
-			VERSION_PROBE_SUPERVISOR
-		], {
-			env: {},
-			detached: true,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		}) : (0, node_child_process.spawn)(options.codexPathOverride, [
-			"exec",
-			"--experimental-json",
-			"--version"
-		], {
-			env: options.env,
-			windowsHide: true,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		});
-		const stdout = [];
-		const stderr = [];
-		let stdoutBytes = 0;
-		let stderrBytes = 0;
-		let failure;
-		let termination;
-		let commandExit;
-		let deadlineReached = false;
-		const stop = (error) => {
-			failure ??= error;
-			termination ??= terminateProbe(child).catch((cleanupError) => {
-				failure = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
-			}).finally(() => {
-				child.stdout?.destroy();
-				child.stderr?.destroy();
-			});
-		};
-		const timeout = setTimeout(() => {
-			if (supervised) {
-				deadlineReached = true;
-				child.kill("SIGTERM");
-				return;
-			}
-			if (!supervised && commandExit) {
-				child.stdout?.destroy();
-				child.stderr?.destroy();
-				return;
-			}
-			stop(/* @__PURE__ */ new Error(`Codex CLI version check timed out after ${VERSION_PROBE_TIMEOUT_MS}ms`));
-		}, Math.max(0, deadlineAt - Date.now()));
-		const onAbort = () => stop(new DOMException("Codex compatibility check aborted", "AbortError"));
-		if (!supervised) child.once("exit", (code, signal) => {
-			commandExit = {
-				code,
-				signal
-			};
-		});
-		child.stdout?.on("data", (chunk) => {
-			stdoutBytes += chunk.length;
-			if (stdoutBytes > VERSION_PROBE_MAX_OUTPUT_BYTES) stop(/* @__PURE__ */ new Error("Codex CLI version stdout exceeded the maximum buffer length"));
-			else if (!failure) stdout.push(chunk);
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderrBytes += chunk.length;
-			if (stderrBytes > VERSION_PROBE_MAX_OUTPUT_BYTES) stop(/* @__PURE__ */ new Error("Codex CLI version stderr exceeded the maximum buffer length"));
-			else if (!failure) stderr.push(chunk);
-		});
-		child.once("error", stop);
-		child.stdin?.on("error", () => stop(/* @__PURE__ */ new Error("Codex CLI version check owner channel failed")));
-		if (supervised) {
-			const statusPipe = child.stdio[3];
-			const status = [];
-			let statusBytes = 0;
-			let statusRead = false;
-			const invalidStatus = () => {
-				if (statusRead) return;
-				statusRead = true;
-				failure ??= /* @__PURE__ */ new Error(deadlineReached ? `Codex CLI version check timed out after ${VERSION_PROBE_TIMEOUT_MS}ms` : "Codex CLI version supervisor exited without a valid command status");
-				termination = Promise.resolve().then(() => {
-					if (child.pid !== void 0) try {
-						process.kill(-child.pid, "SIGKILL");
-					} catch (error) {
-						if (error.code !== "ESRCH") throw error;
-					}
-				}).catch((error) => {
-					failure = error instanceof Error ? error : /* @__PURE__ */ new Error("Codex version probe cleanup failed");
-				}).finally(() => {
-					child.stdout?.destroy();
-					child.stderr?.destroy();
-				});
-			};
-			statusPipe?.on("data", (chunk) => {
-				statusBytes += chunk.length;
-				if (statusBytes > VERSION_PROBE_MAX_STATUS_BYTES) stop(/* @__PURE__ */ new Error("Codex CLI version check status exceeded the maximum buffer length"));
-				else status.push(chunk);
-			});
-			statusPipe?.once("error", invalidStatus);
-			statusPipe?.once("end", () => {
-				if (statusRead) return;
-				try {
-					if (statusBytes > VERSION_PROBE_MAX_STATUS_BYTES) throw new Error("Oversized status");
-					const result = parseProbeStatus(Buffer.concat(status).toString("utf8"));
-					statusRead = true;
-					if ("error" in result) failure ??= new Error(result.error);
-					else commandExit = result;
-				} catch {
-					invalidStatus();
-				}
-			});
-			child.stdin?.write(initialization);
-		}
-		child.once("close", async (code, signal) => {
-			clearTimeout(timeout);
-			options.signal?.removeEventListener("abort", onAbort);
-			try {
-				await (termination ?? (supervised ? void 0 : terminateProbe(child)));
-			} catch (error) {
-				failure = error instanceof Error ? error : new Error(String(error));
-			}
-			const exit = commandExit ?? (supervised ? void 0 : {
-				code,
-				signal
-			});
-			if (failure) reject(failure);
-			else if (exit?.code === 0) resolve(`${Buffer.concat(stdout).toString("utf8")}\n${Buffer.concat(stderr).toString("utf8")}`);
-			else reject(/* @__PURE__ */ new Error(`Codex CLI version check exited with ${exit?.signal ?? exit?.code ?? "no command status"}: ${Buffer.concat(stderr).toString("utf8")}`));
-		});
-		options.signal?.addEventListener("abort", onAbort, { once: true });
-		if (options.signal?.aborted) onAbort();
-	});
-}
-async function runCompatibilityCheck(options) {
-	let supportedVersion;
-	try {
-		supportedVersion = getSupportedCliVersion(options.sdkEntryPoint);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new CodexCliCompatibilityError(`Could not verify Codex CLI compatibility for ${options.codexPathOverride}: ${message}. For more information, see: ${CODEX_SDK_DOCS_URL}`);
-	}
-	let output;
-	try {
-		output = await runVersionProbe(options);
-	} catch (error) {
-		if (options.signal?.aborted) throw new DOMException("Codex compatibility check aborted", "AbortError");
-		const message = error instanceof Error ? error.message : String(error);
-		throw new CodexCliCompatibilityError(`Could not verify Codex CLI compatibility for ${options.codexPathOverride}: ${message}. For more information, see: ${CODEX_SDK_DOCS_URL}`);
-	}
-	const version = CODEX_VERSION_PATTERN.exec(output)?.[1];
-	if (!version || !semver.default.valid(version) || semver.default.compareBuild(version, supportedVersion) !== 0) throw new CodexCliCompatibilityError(`${CODEX_SDK_PACKAGE} supports Codex CLI/event schema ${supportedVersion}, but ${options.codexPathOverride} reports ${version ?? "an unknown version"}. For more information, see: ${CODEX_SDK_DOCS_URL}`);
-}
-function checkCodexCliCompatibility(options) {
-	return runCompatibilityCheck(options);
-}
-//#endregion
-//#region src/providers/openai/codex-sdk.ts
-var codex_sdk_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
-	CODEX_SDK_VERSION_RANGE: () => CODEX_SDK_VERSION_RANGE,
-	OpenAICodexSDKProvider: () => OpenAICodexSDKProvider,
-	resolveCodexSdkPackage: () => resolveCodexSdkPackage
-});
-function appendPromptfooResourceAttrs(existing, traceId, parentSpanId) {
-	const traceKey = require_resourceAttributes.PROMPTFOO_RESOURCE_ATTR_TRACE_ID;
-	const parentSpanKey = require_resourceAttributes.PROMPTFOO_RESOURCE_ATTR_PARENT_SPAN_ID;
-	const incoming = `${traceKey}=${traceId},${parentSpanKey}=${parentSpanId}`;
-	if (!existing) return incoming;
-	const cleaned = existing.split(",").map((pair) => pair.trim()).filter((pair) => pair.length > 0 && !pair.startsWith(`${traceKey}=`) && !pair.startsWith(`${parentSpanKey}=`)).join(",");
-	return cleaned.length > 0 ? `${cleaned},${incoming}` : incoming;
-}
-const ZERO_TRACE_ID = "00000000000000000000000000000000";
-const ZERO_SPAN_ID = "0000000000000000";
-function isValidTraceparent(traceparent) {
-	if (!traceparent) return false;
-	const [, traceId, spanId] = traceparent.split("-");
-	return Boolean(traceId && spanId && traceId !== ZERO_TRACE_ID && spanId !== ZERO_SPAN_ID);
-}
-const CodexCliEnvValueSchema = zod.z.union([
-	zod.z.string(),
-	zod.z.number(),
-	zod.z.boolean()
-]).transform(String);
-const OpenAICodexSDKConfigShape = {
-	basePath: zod.z.string().optional(),
-	prefix: zod.z.string().optional(),
-	suffix: zod.z.string().optional(),
-	provider: zod.z.unknown().optional(),
-	linkedTargetId: zod.z.string().optional(),
-	apiKey: zod.z.string().min(1).optional(),
-	base_url: zod.z.string().min(1).optional(),
-	maxRetries: zod.z.number().int().nonnegative().optional(),
-	working_dir: zod.z.string().min(1).optional(),
-	copy_working_dir: zod.z.union([zod.z.boolean(), zod.z.enum(["git", "copy"])]).optional(),
-	additional_directories: zod.z.array(zod.z.string().min(1)).optional(),
-	skip_git_repo_check: zod.z.boolean().optional(),
-	codex_path_override: zod.z.string().min(1).optional(),
-	skip_codex_version_check: zod.z.boolean().optional(),
-	model: zod.z.string().min(1).optional(),
-	model_provider: zod.z.string().min(1).optional(),
-	sandbox_mode: zod.z.enum([
-		"read-only",
-		"workspace-write",
-		"danger-full-access"
-	]).optional(),
-	model_reasoning_effort: zod.z.enum([
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		"xhigh",
-		"max",
-		"ultra"
-	]).optional(),
-	network_access_enabled: zod.z.boolean().optional(),
-	web_search_enabled: zod.z.boolean().optional(),
-	web_search_mode: zod.z.enum([
-		"disabled",
-		"cached",
-		"live"
-	]).optional(),
-	collaboration_mode: zod.z.enum(["coding", "plan"]).optional(),
-	approval_policy: zod.z.enum([
-		"never",
-		"on-request",
-		"on-failure",
-		"untrusted"
-	]).optional(),
-	thread_id: zod.z.string().min(1).optional(),
-	persist_threads: zod.z.boolean().optional(),
-	thread_pool_size: zod.z.number().int().positive().optional(),
-	output_schema: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-	cli_env: zod.z.record(zod.z.string(), CodexCliEnvValueSchema).optional(),
-	inherit_process_env: zod.z.boolean().optional(),
-	enable_streaming: zod.z.boolean().optional(),
-	deep_tracing: zod.z.boolean().optional(),
-	cli_config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-};
-const OpenAICodexSDKConfigSchema = zod.z.object(OpenAICodexSDKConfigShape).strict();
-const OpenAICodexSDKMergedPromptConfigSchema = zod.z.object(OpenAICodexSDKConfigShape).strip();
-function parseCodexConfig(config, options = {}) {
-	const schema = options.stripUnknownKeys ? OpenAICodexSDKMergedPromptConfigSchema : OpenAICodexSDKConfigSchema;
-	try {
-		return schema.parse(config ?? {});
-	} catch (error) {
-		if (error instanceof zod.z.ZodError) {
-			const issues = error.issues.map((issue) => {
-				return `${issue.path.length > 0 ? issue.path.join(".") : "(root)"}: ${issue.message}`;
-			}).join("; ");
-			throw new Error(`Invalid OpenAI Codex SDK config: ${issues}`);
-		}
-		throw error;
-	}
-}
-const CODEX_RATE_LIMIT_CODES = ["rate_limit_exceeded", ...require_fetch.HARD_QUOTA_ERROR_CODES];
-const CODEX_DEFAULT_RATE_LIMIT_WAIT_MS = 6e4;
-const CODEX_RATE_LIMIT_PATTERNS = [
-	/\b429\b/,
-	/\brate[\s_-]*limit(?:ed|ing| reached| exceeded)?\b/i,
-	/\btoo many requests\b/i,
-	/\btokens per (?:minute|min)\b/i,
-	/\brequests per (?:minute|min)\b/i,
-	/\bexceeded your current quota\b/i
-];
-function extractCodexRateLimitCode(message) {
-	const lowerMessage = message.toLowerCase();
-	const billingCode = CODEX_RATE_LIMIT_CODES.find((code) => require_fetch.isDefinitiveBillingCode(code) && lowerMessage.includes(code));
-	if (billingCode) return billingCode;
-	if (/\bno credits remaining\b/i.test(message)) return "credit_balance_exhausted";
-	const explicitCode = CODEX_RATE_LIMIT_CODES.find((code) => lowerMessage.includes(code));
-	if (explicitCode) return explicitCode;
-	if (/\bexceeded your current quota\b/i.test(message) || /\bcheck your plan and billing details\b/i.test(message)) return "insufficient_quota";
-}
-function extractCodexRetryAfterMs(message) {
-	const match = message.match(/\b(?:please\s+)?(?:try\s+again\s+in|retry(?:\s+again)?\s+(?:after|in))\s+(\d+(?:\.\d+)?)\s*(milliseconds?|ms|seconds?|secs?|s|minutes?|mins?|m)\b/i);
-	if (!match) return;
-	const amount = Number(match[1]);
-	if (!Number.isFinite(amount) || amount < 0) return;
-	const unit = match[2].toLowerCase();
-	const multiplier = unit.startsWith("m") && unit !== "ms" && !unit.startsWith("milli") ? 6e4 : unit.startsWith("s") ? 1e3 : 1;
-	return Math.ceil(amount * multiplier);
-}
-function buildCodexRateLimitResponse(error, message) {
-	const errorRecord = typeof error === "object" && error !== null ? error : void 0;
-	const status = typeof errorRecord?.status === "number" ? errorRecord.status : typeof errorRecord?.statusCode === "number" ? errorRecord.statusCode : void 0;
-	const rawCode = typeof errorRecord?.code === "string" ? errorRecord.code.toLowerCase() : void 0;
-	const rawType = typeof errorRecord?.type === "string" ? errorRecord.type.toLowerCase() : void 0;
-	const code = rawCode && CODEX_RATE_LIMIT_CODES.some((knownCode) => knownCode === rawCode) ? rawCode : extractCodexRateLimitCode(message);
-	if (status !== 429 && code === void 0 && !require_fetch.isHardQuotaCode(rawType) && !CODEX_RATE_LIMIT_PATTERNS.some((pattern) => pattern.test(message))) return;
-	const retryAfterMs = extractCodexRetryAfterMs(message);
-	const rateLimitError = new require_fetch.HttpRateLimitError({
-		status: status ?? 429,
-		retryAfterMs,
-		code: code ?? rawCode,
-		type: rawType
-	});
-	const schedulerRetryAfterMs = rateLimitError.kind === "rate_limit" ? retryAfterMs ?? CODEX_DEFAULT_RATE_LIMIT_WAIT_MS : void 0;
-	const headers = schedulerRetryAfterMs === void 0 ? {} : { "retry-after-ms": String(schedulerRetryAfterMs) };
-	return {
-		error: require_fetch.formatRateLimitErrorMessage(rateLimitError, message),
-		metadata: {
-			rateLimitKind: rateLimitError.kind,
-			http: {
-				status: rateLimitError.status,
-				statusText: rateLimitError.statusText,
-				headers
-			}
-		}
-	};
-}
-const CODEX_SDK_VERSION_RANGE = "^0.156.1";
-function resolveCodexSdkPackage() {
-	const basePaths = [
-		require_logger.state.basePath ? path.default.resolve(require_logger.state.basePath) : void 0,
-		process.cwd(),
-		path.default.resolve(require_esm.getDirectory(), ".."),
-		path.default.resolve(require_esm.getDirectory(), "../..")
-	].filter((candidate) => Boolean(candidate));
-	for (const basePath of new Set(basePaths)) {
-		const entryPoint = require_esm.resolvePackageEntryPoint("@openai/codex-sdk", basePath);
-		if (entryPoint) return entryPoint;
-	}
-	return null;
-}
-async function loadCodexSDK() {
-	const codexPath = resolveCodexSdkPackage();
-	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 promptfoo @openai/codex-sdk@${CODEX_SDK_VERSION_RANGE}
-
-      Requires Node.js >=22.22.0.
-
-      For more information, see: https://www.promptfoo.dev/docs/providers/openai-codex-sdk/`);
-	const version = require_packageVersion.getPackageVersion("@openai/codex-sdk", codexPath);
-	if (!version || !(0, semver_functions_satisfies_js.default)(version, "^0.156.1")) throw new Error(`The OpenAI Codex SDK provider requires @openai/codex-sdk@${CODEX_SDK_VERSION_RANGE} (found ${version ?? "unknown"}). Install it with: npm install promptfoo @openai/codex-sdk@${CODEX_SDK_VERSION_RANGE}`);
-	try {
-		return {
-			entryPoint: codexPath,
-			module: 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 >=22.22.0)
-      - Corrupted installation
-
-      Try reinstalling:
-        npm install promptfoo @openai/codex-sdk@${CODEX_SDK_VERSION_RANGE}
-
-      For more information, see: https://www.promptfoo.dev/docs/providers/openai-codex-sdk/`);
-	}
-}
-var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
-	cleanupGeneration = 0;
-	static OPENAI_MODELS = [
-		"gpt-6-astra",
-		"gpt-6-sol",
-		"gpt-6-luna",
-		"gpt-5.6-sol",
-		"gpt-5.6-terra",
-		"gpt-5.6-luna",
-		"gpt-5.5",
-		"gpt-5.5-pro",
-		"gpt-5.4",
-		"gpt-5.4-pro",
-		"gpt-5.4-mini",
-		"gpt-5.3-codex",
-		"gpt-5.3-codex-spark",
-		"gpt-5.2",
-		"gpt-5-codex-mini",
-		"gpt-5"
-	];
-	config;
-	env;
-	apiKey;
-	providerId = "openai:codex-sdk";
-	codexSdk;
-	codexInstances = /* @__PURE__ */ new Map();
-	threads = /* @__PURE__ */ new Map();
-	threadRunQueues = new require_agenticRunQueue.AgenticRunQueue("Codex thread turn wait aborted");
-	deepTracingWarningShown = false;
-	ignoredProviderEnvWarningShown = false;
-	omittedProcessEnvWarningShown = false;
-	compatibilitySkipWarningShown = false;
-	compatibilityChecks = /* @__PURE__ */ new Map();
-	constructor(options = {}) {
-		const { config, env, id } = options;
-		this.config = parseCodexConfig(config);
-		this.env = env;
-		this.apiKey = this.getApiKey();
-		this.providerId = id ?? this.providerId;
-		require_providerRegistry.providerRegistry.register(this);
-		if (this.config.model && !require_codexSkillMetadata.usesCustomModelProvider(this.config) && !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(config = this.config) {
-		return require_credentials.resolveProviderApiKey(config, this.env, ["OPENAI_API_KEY", "CODEX_API_KEY"]);
-	}
-	requiresApiKey() {
-		return false;
-	}
-	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.cleanupGeneration++;
-		require_providerRegistry.providerRegistry.unregister(this);
-		const compatibilityChecks = [...this.compatibilityChecks.entries()];
-		for (const [controller] of compatibilityChecks) controller.abort(require_agenticRunQueue.createAbortError("Codex compatibility check interrupted by cleanup"));
-		const instances = [...this.codexInstances.values()];
-		this.codexInstances.clear();
-		this.threads.clear();
-		this.threadRunQueues.clear();
-		for (const instance of instances) try {
-			await this.destroyInstance(instance);
-		} catch (error) {
-			require_logger.logger.warn("[CodexSDK] Error during cleanup", { error });
-		}
-		if (compatibilityChecks.length > 0) await Promise.allSettled(compatibilityChecks.map(([, pending]) => pending));
-	}
-	async shutdown() {
-		await this.cleanup();
-	}
-	prepareEnvironment(config, traceparent, apiKey = this.getApiKey(config)) {
-		const inheritProcessEnv = config.inherit_process_env === true;
-		const cliEnv = Object.fromEntries(Object.entries(config.cli_env ?? {}).map(([key, value]) => [key, String(value)]));
-		const env = {
-			...inheritProcessEnv ? require_logger.getProcessEnv() : require_codexSkillMetadata.getMinimalProcessEnv(),
-			...cliEnv
-		};
-		const ignoredProviderEnvKeys = Object.keys(this.env ?? {}).filter((key) => key !== "OPENAI_API_KEY" && key !== "CODEX_API_KEY" && !(key in (config.cli_env ?? {}))).sort();
-		if (ignoredProviderEnvKeys.length > 0 && !this.ignoredProviderEnvWarningShown) {
-			require_logger.logger.warn("[CodexSDK] Ignoring promptfoo-level env overrides for the Codex CLI process. Move these keys into config.cli_env if Codex shell commands need them.", { envKeys: ignoredProviderEnvKeys });
-			this.ignoredProviderEnvWarningShown = true;
-		}
-		if (!inheritProcessEnv && !this.omittedProcessEnvWarningShown) {
-			const omittedProcessEnvKeys = this.getOmittedOptionalProcessEnvKeys(config, env);
-			if (omittedProcessEnvKeys.length > 0) {
-				require_logger.logger.warn("[CodexSDK] Optional Codex CLI process env vars are not inherited by default. Move these keys into config.cli_env or set inherit_process_env: true if Codex CLI commands need them.", { envKeys: omittedProcessEnvKeys });
-				this.omittedProcessEnvWarningShown = true;
-			}
-		}
-		const sortedEnv = {};
-		for (const key of Object.keys(env).sort()) if (env[key] !== void 0) sortedEnv[key] = env[key];
-		require_codexSkillMetadata.applyApiKeyToCliEnv(sortedEnv, config, apiKey);
-		if (config.deep_tracing) {
-			if (!sortedEnv.OTEL_EXPORTER_OTLP_ENDPOINT) sortedEnv.OTEL_EXPORTER_OTLP_ENDPOINT = require_codexSkillMetadata.getCodexTraceEndpoint();
-			if (!sortedEnv.OTEL_EXPORTER_OTLP_PROTOCOL) sortedEnv.OTEL_EXPORTER_OTLP_PROTOCOL = require_codexSkillMetadata.getCodexTraceProtocol();
-			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;
-				const [, tpTraceId, tpSpanId] = traceparent.split("-");
-				if (tpTraceId && tpSpanId) sortedEnv.OTEL_RESOURCE_ATTRIBUTES = appendPromptfooResourceAttrs(sortedEnv.OTEL_RESOURCE_ATTRIBUTES, tpTraceId, tpSpanId);
-			}
-			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;
-	}
-	getOmittedOptionalProcessEnvKeys(config, env) {
-		const shouldWarnForSshEnv = config.network_access_enabled === true || config.web_search_enabled === true || config.web_search_mode === "live";
-		return require_codexSkillMetadata.COMMON_OPTIONAL_PROCESS_ENV_KEYS.filter((key) => typeof process.env[key] === "string" && !(key in env) && (shouldWarnForSshEnv || key !== "SSH_AUTH_SOCK" && key !== "GIT_SSH_COMMAND"));
-	}
-	getResolvedCliConfig(config, env = {}) {
-		if (!config.cli_config && !config.collaboration_mode && !config.model_provider && !config.deep_tracing) return;
-		const cliConfig = {
-			...config.cli_config ?? {},
-			...config.model_provider ? { model_provider: config.model_provider } : {},
-			...config.collaboration_mode ? { collaboration_mode: config.collaboration_mode } : {}
-		};
-		return require_codexSkillMetadata.withCodexTraceExporter(cliConfig, env, config.deep_tracing === true);
-	}
-	getSkillRootPrefixes(env, workingDir) {
-		const resolvedWorkingDir = workingDir ? path.default.resolve(workingDir).replace(/\\/g, "/") : void 0;
-		return require_codexSkillMetadata.getCodexSkillRootPrefixes({
-			codexHome: env.CODEX_HOME,
-			gitRepositoryRoot: resolvedWorkingDir ? this.findGitRepositoryRoot(resolvedWorkingDir) : void 0,
-			homeDir: env.HOME || env.USERPROFILE || process.env.HOME || process.env.USERPROFILE,
-			workingDir: resolvedWorkingDir
-		});
-	}
-	buildSkillMetadata(items, skillRootPrefixes = []) {
-		return require_codexSkillMetadata.buildCodexSkillMetadata(items, skillRootPrefixes, {
-			getCommand: (item) => item?.type === "command_execution" && typeof item.command === "string" && item.command.trim() ? item.command : void 0,
-			isSuccessfulCommand: (item) => this.isSuccessfulCommandExecution(item)
-		});
-	}
-	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 && !this.isInsideGitRepository(workingDir)) throw new Error(dedent.default`Working directory ${workingDir} is not inside 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.`);
-	}
-	isInsideGitRepository(workingDir) {
-		return this.findGitRepositoryRoot(workingDir) !== void 0;
-	}
-	findGitRepositoryRoot(workingDir) {
-		return require_codexSkillMetadata.findGitRepositoryRoot(workingDir);
-	}
-	/**
-	* Build Codex constructor options from provider config.
-	* Used when creating both local (deep-tracing) and cached instances.
-	*/
-	buildCodexOptions(env, config, apiKey = this.getApiKey(config)) {
-		const cliConfig = this.getResolvedCliConfig(config, env);
-		return {
-			env,
-			...require_codexSkillMetadata.shouldInjectApiKey(config, apiKey) ? { apiKey } : {},
-			...config.codex_path_override ? { codexPathOverride: config.codex_path_override } : {},
-			...config.base_url ? { baseUrl: config.base_url } : {},
-			...cliConfig ? { config: cliConfig } : {}
-		};
-	}
-	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, instanceKey, instance) {
-		const threadOptions = this.buildThreadOptions(config);
-		if (config.deep_tracing) return instance.startThread(threadOptions);
-		if (config.thread_id) {
-			const threadIdCacheKey = this.getExplicitThreadCacheKey(config, instanceKey);
-			const cached = this.threads.get(threadIdCacheKey);
-			if (cached) return cached;
-			const thread = instance.resumeThread(config.thread_id, threadOptions);
-			if (config.persist_threads) {
-				const explicitThreadCachePrefix = this.getExplicitThreadCachePrefix(config);
-				for (const cacheKey of this.threads.keys()) if (cacheKey !== threadIdCacheKey && cacheKey.startsWith(explicitThreadCachePrefix)) this.threads.delete(cacheKey);
-				this.threads.set(threadIdCacheKey, 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 tracer = _opentelemetry_api.trace.getTracer("promptfoo.codex-sdk");
-		const state = this.createCodexStreamingState(prompt);
-		try {
-			for await (const event of events) {
-				const eventTime = Date.now();
-				if (callOptions?.abortSignal?.aborted) throw require_agenticRunQueue.createAbortError("OpenAI Codex SDK call aborted");
-				this.handleStreamingEvent(event, state, tracer, eventTime, skillRootPrefixes);
-				state.lastEventTime = eventTime;
-			}
-			if (!state.turnCompleted) {
-				if (state.lastStreamError) {
-					if (!state.activeTurnSpan) this.startTurnSpan(state, tracer, state.lastEventTime);
-					this.endTurnSpan(state, state.lastEventTime, void 0, state.lastStreamError);
-					throw new Error(`Codex stream ended after error: ${state.lastStreamError}`);
-				}
-				throw new Error("Codex stream ended before turn completion");
-			}
-		} finally {
-			this.endUnclosedStreamingSpans(state);
-		}
-		return this.buildStreamingTurnResult(state);
-	}
-	createCodexStreamingState(prompt) {
-		return {
-			items: [],
-			usage: void 0,
-			turnCompleted: false,
-			lastStreamError: void 0,
-			activeSpans: /* @__PURE__ */ new Map(),
-			itemStartTimes: /* @__PURE__ */ new Map(),
-			lastEventTime: Date.now(),
-			reasoningTexts: [],
-			conversationMessages: [{
-				role: "user",
-				content: this.formatPromptInputForTrace(prompt)
-			}],
-			turnCount: 0,
-			activeTurnSpan: void 0,
-			activeTurnIndex: 0
-		};
-	}
-	handleStreamingEvent(event, state, tracer, eventTime, skillRootPrefixes) {
-		switch (event.type) {
-			case "item.started":
-				this.handleStreamingItemStarted(event, state, tracer, eventTime);
-				return;
-			case "item.completed":
-				this.handleStreamingItemCompleted(event, state, tracer, eventTime, skillRootPrefixes);
-				return;
-			case "item.updated":
-				this.handleStreamingItemUpdated(event, state, skillRootPrefixes);
-				return;
-			case "turn.completed":
-				state.usage = event.usage;
-				state.turnCompleted = true;
-				if (!state.activeTurnSpan) this.startTurnSpan(state, tracer, state.lastEventTime);
-				this.endTurnSpan(state, eventTime, event.usage);
-				require_logger.logger.debug("Codex turn completed", { usage: state.usage });
-				return;
-			case "turn.failed": {
-				const errorMsg = event.error?.message || "Turn failed";
-				if (!state.activeTurnSpan) this.startTurnSpan(state, tracer, state.lastEventTime);
-				this.endTurnSpan(state, eventTime, void 0, errorMsg);
-				require_logger.logger.error("Codex turn failed", { error: errorMsg });
-				const previousStreamError = state.lastStreamError && state.lastStreamError !== errorMsg ? ` Previous stream error: ${state.lastStreamError}` : "";
-				throw new Error(`Codex turn failed: ${errorMsg}${previousStreamError}`);
-			}
-			case "error": {
-				const errorMsg = typeof event.message === "string" && event.message ? event.message : "Stream failed";
-				state.lastStreamError = errorMsg;
-				require_logger.logger.debug("Codex stream error event received; waiting for terminal event", { error: errorMsg });
-				return;
-			}
-			case "thread.started": return;
-			case "turn.started":
-				this.startTurnSpan(state, tracer, eventTime);
-				return;
-			default: require_logger.logger.debug("Codex unknown event type", { type: event.type });
-		}
-	}
-	handleStreamingItemStarted(event, state, tracer, eventTime) {
-		const item = event.item;
-		if (!item) {
-			require_logger.logger.warn("Codex item.started event missing item", { event });
-			return;
-		}
-		if (!state.activeTurnSpan) this.startTurnSpan(state, tracer, eventTime);
-		if (!item.id) {
-			require_logger.logger.debug("Codex item.started without id, will create span at completion", { type: item.type });
-			return;
-		}
-		const itemId = String(item.id);
-		const span = this.startStreamingItemSpan(tracer, item, itemId, void 0, state.activeTurnIndex > 0 ? state.activeTurnIndex : void 0);
-		state.activeSpans.set(itemId, span);
-		state.itemStartTimes.set(itemId, eventTime);
-		require_logger.logger.debug("Codex item started", {
-			itemId,
-			type: item.type
-		});
-	}
-	handleStreamingItemCompleted(event, state, tracer, eventTime, skillRootPrefixes) {
-		const item = event.item;
-		if (!item) {
-			require_logger.logger.warn("Codex item.completed event missing item", { event });
-			return;
-		}
-		if (!state.activeTurnSpan) this.startTurnSpan(state, tracer, state.lastEventTime);
-		const itemId = item.id ? String(item.id) : crypto.default.randomUUID();
-		state.items.push(item);
-		this.collectStreamingItemText(item, state);
-		const span = state.activeSpans.get(itemId) ?? this.startStreamingItemSpan(tracer, item, itemId, state.lastEventTime, state.activeTurnIndex > 0 ? state.activeTurnIndex : void 0);
-		const hadStartEvent = state.activeSpans.has(itemId);
-		const startTime = state.itemStartTimes.get(itemId) ?? state.lastEventTime;
-		const durationMs = eventTime - startTime;
-		this.applyStreamingCompletionAttributes(span, item, skillRootPrefixes, eventTime, startTime, hadStartEvent);
-		span.end();
-		state.activeSpans.delete(itemId);
-		state.itemStartTimes.delete(itemId);
-		require_logger.logger.debug("Codex item completed", {
-			itemId,
-			type: item.type,
-			durationMs
-		});
-	}
-	handleStreamingItemUpdated(event, state, skillRootPrefixes) {
-		const item = event.item;
-		if (item?.id) {
-			const itemId = String(item.id);
-			const span = state.activeSpans.get(itemId);
-			if (span) this.setStreamingCompletionAttributes(span, item, skillRootPrefixes);
-		}
-		require_logger.logger.debug("Codex item updated", {
-			itemId: item?.id,
-			type: item?.type
-		});
-	}
-	startStreamingItemSpan(tracer, item, itemId, startTime, turnIndex) {
-		return tracer.startSpan(this.getSpanNameForItem(item), {
-			kind: _opentelemetry_api.SpanKind.INTERNAL,
-			...startTime === void 0 ? {} : { startTime },
-			attributes: require_genaiTracer.addActiveSpanRoleAttribute({
-				"codex.item.id": itemId,
-				"codex.item.type": item.type,
-				...startTime === void 0 ? {} : { "codex.timing.estimated": true },
-				...typeof turnIndex === "number" ? { "gen_ai.turn.index": turnIndex } : {},
-				...this.getAttributesForItem(item)
-			})
-		});
-	}
-	startTurnSpan(state, tracer, eventTime) {
-		require_genaiTracer.openTurnSpan(state, {
-			tracer,
-			eventTime,
-			system: "openai",
-			logLabel: "CodexSDK"
-		});
-	}
-	endTurnSpan(state, eventTime, usage, errorMessage) {
-		const attributes = {};
-		if (usage) {
-			const inputTokens = usage.input_tokens ?? usage.inputTokens;
-			const outputTokens = usage.output_tokens ?? usage.outputTokens;
-			const cachedTokens = usage.cached_input_tokens ?? usage.cachedInputTokens;
-			const cacheWriteTokens = usage.cache_write_input_tokens ?? usage.cacheWriteInputTokens;
-			const reasoningTokens = usage.reasoning_output_tokens ?? usage.reasoningOutputTokens;
-			if (typeof inputTokens === "number") attributes["gen_ai.usage.input_tokens"] = inputTokens;
-			if (typeof outputTokens === "number") attributes["gen_ai.usage.output_tokens"] = outputTokens;
-			if (typeof cachedTokens === "number") attributes[require_genaiTracer.GenAIAttributes.USAGE_CACHE_READ_INPUT_TOKENS] = cachedTokens;
-			if (typeof cacheWriteTokens === "number") attributes[require_genaiTracer.GenAIAttributes.USAGE_CACHE_CREATION_INPUT_TOKENS] = cacheWriteTokens;
-			if (typeof reasoningTokens === "number") attributes[require_genaiTracer.GenAIAttributes.USAGE_REASONING_OUTPUT_TOKENS] = reasoningTokens;
-		}
-		require_genaiTracer.closeTurnSpan(state, {
-			eventTime,
-			attributes,
-			errorMessage,
-			logLabel: "CodexSDK"
-		});
-	}
-	collectStreamingItemText(item, state) {
-		if (item.type === "reasoning" && typeof item.text === "string") {
-			const sanitizedReasoning = this.sanitizeTraceText(item.text, "Codex reasoning trace event");
-			if (sanitizedReasoning) state.reasoningTexts.push(sanitizedReasoning);
-		}
-		if (item.type === "agent_message" && typeof item.text === "string") state.conversationMessages.push({
-			role: "assistant",
-			content: this.sanitizeTraceText(item.text, "Codex agent message trace event") ?? ""
-		});
-	}
-	applyStreamingCompletionAttributes(span, item, skillRootPrefixes, eventTime, startTime, hadStartEvent) {
-		this.setStreamingCompletionAttributes(span, item, skillRootPrefixes);
-		span.setAttribute("codex.duration_ms", eventTime - startTime);
-		span.setAttribute("codex.had_start_event", hadStartEvent);
-		this.addStreamingSpanEvents(span, item);
-		this.setStreamingSpanStatus(span, item);
-	}
-	setStreamingCompletionAttributes(span, item, skillRootPrefixes) {
-		const completionAttrs = this.getCompletionAttributesForItem(item, skillRootPrefixes);
-		for (const [key, value] of Object.entries(completionAttrs)) span.setAttribute(key, value);
-	}
-	addStreamingSpanEvents(span, item) {
-		if (item.type === "reasoning" && typeof item.text === "string") span.addEvent("reasoning", { "codex.reasoning.text": this.sanitizeTraceText(item.text, "Codex reasoning span event") ?? "" });
-		if (item.type === "agent_message" && typeof item.text === "string") span.addEvent("message", { "codex.message.text": this.sanitizeTraceText(item.text, "Codex agent message span event") ?? "" });
-		if (item.type === "command_execution" && typeof item.aggregated_output === "string") span.addEvent("output", { "codex.command.output": this.sanitizeTraceText(item.aggregated_output, "Codex command output span event") ?? "" });
-	}
-	setStreamingSpanStatus(span, item) {
-		if (!this.isStreamingItemError(item)) {
-			span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
-			return;
-		}
-		span.setStatus({
-			code: _opentelemetry_api.SpanStatusCode.ERROR,
-			message: this.getStreamingItemErrorMessage(item)
-		});
-	}
-	isStreamingItemError(item) {
-		return item.status === "failed" || item.type === "error" || item.error !== void 0 || item.type === "command_execution" && typeof item.exit_code === "number" && item.exit_code !== 0;
-	}
-	getStreamingItemErrorMessage(item) {
-		return (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";
-	}
-	endUnclosedStreamingSpans(state) {
-		for (const [itemId, span] of state.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();
-		}
-		state.activeSpans.clear();
-		state.itemStartTimes.clear();
-		require_genaiTracer.closeTurnSpan(state, {
-			errorMessage: "Turn span not properly closed",
-			logLabel: "CodexSDK"
-		});
-	}
-	buildStreamingTurnResult(state) {
-		return {
-			finalResponse: [...state.items.filter((item) => item.type === "agent_message")].reverse().find((item) => typeof item.text === "string")?.text ?? "",
-			items: state.items,
-			usage: state.usage,
-			reasoningTexts: state.reasoningTexts,
-			conversationMessages: state.conversationMessages
-		};
-	}
-	parsePromptInput(prompt) {
-		let parsedPrompt;
-		try {
-			parsedPrompt = JSON.parse(prompt);
-		} catch {
-			return prompt;
-		}
-		if (!Array.isArray(parsedPrompt) || parsedPrompt.length === 0 || !parsedPrompt.every((item) => this.isCodexPromptInputItem(item))) return prompt;
-		return parsedPrompt;
-	}
-	isCodexPromptInputItem(item) {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return false;
-		const keys = Object.keys(item);
-		if ("type" in item && item.type === "text") return keys.length === 2 && keys.includes("type") && "text" in item && typeof item.text === "string";
-		if ("type" in item && item.type === "local_image") return keys.length === 2 && keys.includes("type") && "path" in item && typeof item.path === "string";
-		return false;
-	}
-	formatPromptInputForTrace(prompt) {
-		if (typeof prompt === "string") return prompt;
-		return prompt.map((item) => item.type === "text" ? item.text : `[local_image: ${item.path}]`).join("\n");
-	}
-	/**
-	* 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" ? (this.sanitizeTraceText(item.query, "Codex web search span name") ?? "").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 require_codexSkillMetadata.extractCodexSkillPathCandidates(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"] = this.sanitizeTraceText(item.command, "Codex command trace attribute") ?? "";
-				break;
-			case "mcp_tool_call":
-				if (typeof item.server === "string") attrs["codex.mcp.server"] = item.server;
-				if (typeof item.tool === "string") {
-					attrs["gen_ai.operation.name"] = "execute_tool";
-					attrs["gen_ai.tool.name"] = item.tool;
-					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"] = this.sanitizeTraceText(item.query, "Codex web search query trace attribute") ?? "";
-				break;
-			case "collaboration_tool_call":
-				if (typeof item.tool === "string") {
-					attrs["gen_ai.operation.name"] = "execute_tool";
-					attrs["gen_ai.tool.name"] = item.tool;
-					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;
-		}
-		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;
-		}
-	}
-	sanitizeTraceText(value, context) {
-		const sanitized = this.redactTracePii(require_logger.sanitizeObject(value, { context }));
-		if (typeof sanitized === "string") return sanitized;
-		if (sanitized === void 0 || sanitized === null) return;
-		try {
-			return JSON.stringify(sanitized);
-		} catch {
-			return;
-		}
-	}
-	redactTracePii(value) {
-		if (typeof value === "string") return value.replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, require_logger.REDACTED).replace(/\b(?:sk-(?:proj-)?[A-Za-z0-9_-]{20,}|sk-ant-[A-Za-z0-9_-]{20,}|AKIA[A-Z0-9]{16}|AIza[A-Za-z0-9_-]{35}|Bearer\s+[A-Za-z0-9._~+/-]{20,}|Basic\s+[A-Za-z0-9+/=]{20,})\b/g, require_logger.REDACTED).replace(/\b(api[_-]?key|token|password|secret|authorization|auth)\s*([=:])(\s*)(["']?)[^\s"'`]+(\4)/gi, (_match, key, separator, spacing, quote) => `${key}${separator}${spacing}${quote}${require_logger.REDACTED}${quote}`);
-		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"] = this.sanitizeTraceText(item.aggregated_output, "Codex command output trace attribute") ?? "";
-				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"] = this.sanitizeTraceText(item.error.message, "Codex MCP error trace attribute") ?? "";
-				{
-					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"] = this.sanitizeTraceText(item.text, "Codex agent message trace attribute") ?? "";
-				break;
-			case "reasoning":
-				if (typeof item.text === "string") attrs["codex.reasoning"] = this.sanitizeTraceText(item.text, "Codex reasoning trace attribute") ?? "";
-				break;
-			case "error": if (typeof item.message === "string") attrs["codex.error"] = this.sanitizeTraceText(item.message, "Codex error trace attribute") ?? "";
-		}
-		return attrs;
-	}
-	generateInstanceKey(env, config) {
-		const keyData = {
-			env,
-			base_url: config.base_url,
-			cli_config: this.getResolvedCliConfig(config, env),
-			codex_path_override: config.codex_path_override
-		};
-		return `openai:codex-sdk:instance:${crypto.default.createHash("sha256").update(JSON.stringify(keyData)).digest("hex")}`;
-	}
-	generateCacheKey(config, prompt, instanceKey) {
-		const keyData = {
-			instanceKey,
-			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")}`;
-	}
-	getThreadRunQueueKey(config, cacheKey) {
-		if (config.deep_tracing) return;
-		if (config.thread_id) return `explicit:${this.getExplicitThreadIdentity(config)}`;
-		if (config.persist_threads && cacheKey) return cacheKey;
-	}
-	getExplicitThreadCacheKey(config, instanceKey) {
-		const variant = crypto.default.createHash("sha256").update(JSON.stringify({
-			instanceKey,
-			threadOptions: this.buildThreadOptions(config)
-		})).digest("hex");
-		return `${this.getExplicitThreadCachePrefix(config)}${variant}`;
-	}
-	getExplicitThreadCachePrefix(config) {
-		return `explicit:${this.getExplicitThreadIdentity(config)}:`;
-	}
-	getExplicitThreadIdentity(config) {
-		return crypto.default.createHash("sha256").update(config.thread_id ?? "").digest("hex");
-	}
-	async callApi(prompt, context, callOptions) {
-		const cleanupGeneration = this.cleanupGeneration;
-		const mergedConfig = {
-			...this.config,
-			...context?.prompt?.config
-		};
-		delete mergedConfig.provider;
-		const config = require_render.renderVarsInObject(mergedConfig, context?.vars);
-		const inIsolatedWorkspace = require_agentWorkspace.assertIsolatedWorkingDir(config);
-		const requestedModel = typeof config.model === "string" && config.model ? config.model : void 0;
-		return require_genaiTracer.withGenAISpan(this.buildCodexSpanContext(prompt, context, requestedModel), () => this.callApiInternal(prompt, context, callOptions, config, inIsolatedWorkspace, cleanupGeneration), (response) => this.extractCodexSpanResult(response, requestedModel));
-	}
-	buildCodexSpanContext(prompt, context, requestedModel) {
-		return {
-			system: "openai",
-			operationName: "invoke_agent",
-			model: requestedModel ?? "Codex",
-			agentName: "Codex",
-			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
-		};
-	}
-	extractCodexSpanResult(response, requestedModel) {
-		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;
-		if (requestedModel) result.responseModel = requestedModel;
-		this.setCodexSpanResponseBody(result, response.output);
-		this.setCodexSpanRawAttributes(result, response.raw);
-		return result;
-	}
-	setCodexSpanResponseBody(result, output) {
-		if (output === void 0) return;
-		try {
-			result.responseBody = typeof output === "string" ? output : JSON.stringify(output);
-		} catch {
-			result.responseBody = "[unable to serialize output]";
-		}
-	}
-	setCodexSpanRawAttributes(result, raw) {
-		if (!raw) return;
-		try {
-			const rawData = typeof raw === "string" ? JSON.parse(raw) : raw;
-			if (rawData.reasoningTexts?.length > 0) result.additionalAttributes = {
-				...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) result.additionalAttributes = {
-				...result.additionalAttributes,
-				"codex.items.total": rawData.items.length,
-				"codex.items.breakdown": JSON.stringify(this.getCodexItemCounts(rawData.items))
-			};
-		} catch {}
-	}
-	getCodexItemCounts(items) {
-		const itemCounts = {};
-		for (const item of items) itemCounts[item.type] = (itemCounts[item.type] || 0) + 1;
-		return itemCounts;
-	}
-	/**
-	* 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, rawConfig, inIsolatedWorkspace, cleanupGeneration) {
-		let config;
-		try {
-			config = parseCodexConfig(rawConfig, { stripUnknownKeys: true });
-		} catch (error) {
-			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}` };
-		}
-		const activeTraceparent = require_genaiTracer.getTraceparent();
-		const currentTraceparent = isValidTraceparent(activeTraceparent) ? activeTraceparent : context?.traceparent;
-		const apiKey = this.getApiKey(config);
-		const workingDirectory = require_agentic_utils.resolveAgenticWorkingDir(config.working_dir, require_logger.state.basePath) ?? process.cwd();
-		const additionalDirectories = config.additional_directories?.map((directory) => require_agentic_utils.resolveAgenticWorkingDir(directory, require_logger.state.basePath) ?? directory);
-		const resolvedConfig = {
-			...config,
-			working_dir: workingDirectory,
-			...additionalDirectories ? { additional_directories: additionalDirectories } : {}
-		};
-		const env = this.prepareEnvironment(resolvedConfig, currentTraceparent, apiKey);
-		if (inIsolatedWorkspace) require_agentWorkspace.clearRepositoryEnv(env);
-		const skillRootPrefixes = this.getSkillRootPrefixes(env, resolvedConfig.working_dir);
-		const promptInput = this.parsePromptInput(prompt);
-		if (apiKey) require_logger.logger.debug("[CodexSDK] Using explicit API credentials from promptfoo config/environment");
-		else require_logger.logger.debug("[CodexSDK] No explicit API credentials configured; deferring auth resolution to Codex SDK login state");
-		if (callOptions?.abortSignal?.aborted) return { error: "OpenAI Codex SDK call aborted before it started" };
-		let localInstance = void 0;
-		let useLocalInstance = false;
-		let cacheKey = void 0;
-		try {
-			this.validateWorkingDirectory(resolvedConfig.working_dir, resolvedConfig.skip_git_repo_check);
-			const codexInstance = await this.getCodexInstanceForTurn(env, resolvedConfig, apiKey, cleanupGeneration, callOptions?.abortSignal);
-			const activeInstance = codexInstance.activeInstance;
-			localInstance = codexInstance.localInstance;
-			useLocalInstance = codexInstance.useLocalInstance;
-			const promptCacheBasis = context?.prompt?.raw ?? prompt;
-			cacheKey = this.generateCacheKey(resolvedConfig, promptCacheBasis, codexInstance.instanceKey);
-			const { turn, sessionId } = await this.executeCodexTurn(activeInstance, codexInstance.instanceKey, cacheKey, promptInput, resolvedConfig, callOptions, skillRootPrefixes, cleanupGeneration);
-			return this.buildCodexProviderResponse(turn, sessionId, skillRootPrefixes, resolvedConfig);
-		} 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" };
-			}
-			if (error instanceof CodexCliCompatibilityError) return { error: `Error calling OpenAI Codex SDK: ${error.message}` };
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			require_logger.logger.error("Error calling OpenAI Codex SDK", { error: errorMessage });
-			return buildCodexRateLimitResponse(error, errorMessage) ?? { error: `Error calling OpenAI Codex SDK: ${errorMessage}` };
-		} finally {
-			await this.cleanupCodexTurn(resolvedConfig, cacheKey, useLocalInstance, localInstance);
-		}
-	}
-	buildCodexRunOptions(config, callOptions) {
-		return {
-			...config.output_schema ? { outputSchema: config.output_schema } : {},
-			...callOptions?.abortSignal ? { signal: callOptions.abortSignal } : {}
-		};
-	}
-	async getCodexInstanceForTurn(env, resolvedConfig, apiKey, cleanupGeneration, abortSignal) {
-		if (!this.codexSdk) this.codexSdk = await loadCodexSDK();
-		const codexSdk = this.codexSdk;
-		if (cleanupGeneration !== this.cleanupGeneration) throw new Error("Codex SDK call was interrupted by cleanup");
-		await this.ensureCodexCompatibility(env, resolvedConfig, codexSdk.entryPoint, abortSignal);
-		if (cleanupGeneration !== this.cleanupGeneration) throw new Error("Codex SDK call was interrupted by cleanup");
-		require_providerRegistry.providerRegistry.register(this);
-		const stableEnv = { ...env };
-		delete stableEnv.TRACEPARENT;
-		const instanceKey = this.generateInstanceKey(stableEnv, resolvedConfig);
-		if (resolvedConfig.deep_tracing) {
-			this.warnOnceForDeepTracingThreadOptions(resolvedConfig);
-			const localInstance = new codexSdk.module.Codex(this.buildCodexOptions(env, resolvedConfig, apiKey));
-			return {
-				activeInstance: localInstance,
-				instanceKey,
-				localInstance,
-				useLocalInstance: true
-			};
-		}
-		let activeInstance = this.codexInstances.get(instanceKey);
-		if (!activeInstance) {
-			activeInstance = new codexSdk.module.Codex(this.buildCodexOptions(env, resolvedConfig, apiKey));
-			this.codexInstances.set(instanceKey, activeInstance);
-		}
-		return {
-			activeInstance,
-			instanceKey,
-			localInstance: void 0,
-			useLocalInstance: false
-		};
-	}
-	async ensureCodexCompatibility(env, resolvedConfig, sdkEntryPoint, abortSignal) {
-		const codexPathOverride = resolvedConfig.codex_path_override;
-		if (!codexPathOverride) return;
-		if (resolvedConfig.skip_codex_version_check) {
-			if (!this.compatibilitySkipWarningShown) {
-				require_logger.logger.warn("[CodexSDK] Skipping custom Codex binary version compatibility check by explicit configuration.", { codexPathOverride });
-				this.compatibilitySkipWarningShown = true;
-			}
-			return;
-		}
-		const preflightEnv = { ...env };
-		delete preflightEnv.CODEX_API_KEY;
-		delete preflightEnv.OPENAI_API_KEY;
-		delete preflightEnv.TRACEPARENT;
-		delete preflightEnv.OTEL_RESOURCE_ATTRIBUTES;
-		if (abortSignal?.aborted) throw require_agenticRunQueue.createAbortError("Codex compatibility check aborted");
-		const controller = new AbortController();
-		const signal = abortSignal ? AbortSignal.any([abortSignal, controller.signal]) : controller.signal;
-		const compatibilityCheck = Promise.resolve().then(() => checkCodexCliCompatibility({
-			sdkEntryPoint,
-			codexPathOverride,
-			env: preflightEnv,
-			signal
-		}));
-		this.compatibilityChecks.set(controller, compatibilityCheck);
-		try {
-			await compatibilityCheck;
-		} finally {
-			this.compatibilityChecks.delete(controller);
-		}
-	}
-	warnOnceForDeepTracingThreadOptions(resolvedConfig) {
-		if (this.deepTracingWarningShown || !resolvedConfig.persist_threads && !resolvedConfig.thread_id && (resolvedConfig.thread_pool_size ?? 0) <= 1) return;
-		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;
-	}
-	async executeCodexTurn(activeInstance, instanceKey, cacheKey, promptInput, resolvedConfig, callOptions, skillRootPrefixes, cleanupGeneration) {
-		const queueKey = this.getThreadRunQueueKey(resolvedConfig, cacheKey);
-		const runOptions = this.buildCodexRunOptions(resolvedConfig, callOptions);
-		return this.threadRunQueues.run(queueKey, callOptions?.abortSignal, async () => {
-			if (cleanupGeneration !== this.cleanupGeneration) throw new Error("Codex SDK call was interrupted by cleanup");
-			const thread = await this.getOrCreateThread(resolvedConfig, cacheKey, instanceKey, activeInstance);
-			if (cleanupGeneration !== this.cleanupGeneration) throw new Error("Codex SDK call was interrupted by cleanup");
-			return {
-				turn: resolvedConfig.enable_streaming ? await this.runStreaming(thread, promptInput, runOptions, callOptions, skillRootPrefixes) : await thread.run(promptInput, runOptions),
-				sessionId: thread.id || "unknown"
-			};
-		});
-	}
-	buildCodexProviderResponse(turn, sessionId, skillRootPrefixes, resolvedConfig) {
-		const output = turn.finalResponse || "";
-		const tokenUsage = this.buildCodexTokenUsage(turn.usage);
-		require_logger.logger.debug("OpenAI Codex SDK response", {
-			output,
-			usage: turn.usage
-		});
-		return {
-			output,
-			tokenUsage,
-			cost: this.calculateCodexResponseCost(tokenUsage, this.getCodexBillingModelName(resolvedConfig), Boolean(resolvedConfig.codex_path_override)),
-			metadata: this.buildCodexResponseMetadata(turn.items, skillRootPrefixes),
-			raw: JSON.stringify(turn),
-			sessionId
-		};
-	}
-	buildCodexResponseMetadata(items, skillRootPrefixes) {
-		const skillMetadata = this.buildSkillMetadata(items, skillRootPrefixes);
-		if (!skillMetadata) return;
-		return require_codexSkillMetadata.getCodexSkillMetadataFields(skillMetadata);
-	}
-	buildCodexTokenUsage(turnUsage) {
-		if (!turnUsage) return;
-		const reasoningTokens = turnUsage.reasoning_output_tokens;
-		const cacheWriteTokens = turnUsage.cache_write_input_tokens;
-		const hasCompletionDetails = typeof reasoningTokens === "number" || typeof cacheWriteTokens === "number";
-		return {
-			prompt: turnUsage.input_tokens,
-			completion: turnUsage.output_tokens,
-			total: turnUsage.input_tokens + turnUsage.output_tokens,
-			cached: turnUsage.cached_input_tokens || 0,
-			...hasCompletionDetails ? { completionDetails: {
-				...typeof reasoningTokens === "number" ? { reasoning: reasoningTokens } : {},
-				...typeof cacheWriteTokens === "number" ? { cacheCreationInputTokens: cacheWriteTokens } : {}
-			} } : {}
-		};
-	}
-	calculateCodexResponseCost(tokenUsage, model, usesCustomCodexBinary) {
-		const normalizedModel = model?.replace(/^bedrock:/, "");
-		if (usesCustomCodexBinary && normalizedModel?.startsWith("gpt-5.6")) {
-			const cacheWriteTokens = tokenUsage?.completionDetails?.cacheCreationInputTokens;
-			if (typeof cacheWriteTokens !== "number" || !Number.isFinite(cacheWriteTokens) || cacheWriteTokens <= 0) return;
-		}
-		return require_billing.calculateOpenAIUsageCostFromTokenUsage(model, tokenUsage);
-	}
-	getCodexBillingModelName(config) {
-		const cliConfigProvider = config.cli_config?.model_provider;
-		if ((config.model_provider ?? (typeof cliConfigProvider === "string" ? cliConfigProvider : void 0))?.trim().toLowerCase() === "amazon-bedrock" && config.model !== void 0 && /^openai\.gpt-5\.6(?:-|$)/.test(config.model)) return `bedrock:${config.model.slice(7)}`;
-		return config.model;
-	}
-	async cleanupCodexTurn(resolvedConfig, cacheKey, useLocalInstance, localInstance) {
-		if (!resolvedConfig.deep_tracing && !resolvedConfig.persist_threads && !resolvedConfig.thread_id && cacheKey) this.threads.delete(cacheKey);
-		if (!useLocalInstance || !localInstance) return;
-		try {
-			await this.destroyInstance(localInstance);
-		} catch (cleanupError) {
-			require_logger.logger.debug("[CodexSDK] Error cleaning up local instance", { error: cleanupError });
-		}
-	}
-};
-//#endregion
-Object.defineProperty(exports, "CODEX_SDK_VERSION_RANGE", {
-	enumerable: true,
-	get: function() {
-		return CODEX_SDK_VERSION_RANGE;
-	}
-});
-Object.defineProperty(exports, "OpenAICodexSDKProvider", {
-	enumerable: true,
-	get: function() {
-		return OpenAICodexSDKProvider;
-	}
-});
-Object.defineProperty(exports, "codex_sdk_exports", {
-	enumerable: true,
-	get: function() {
-		return codex_sdk_exports;
-	}
-});
-Object.defineProperty(exports, "resolveCodexSdkPackage", {
-	enumerable: true,
-	get: function() {
-		return resolveCodexSdkPackage;
-	}
-});
-
-//# sourceMappingURL=codex-sdk-BbxjBvBk.cjs.map