promptfoo 0.121.1 → 0.121.3

package/dist/src/{cloudflare-gateway-D6xFc5pa.js → cloudflare-gateway-BwAaUgeW.js}

@@ -1,18 +1,18 @@
-import { b as getEnvString, i as logger } from "./logger-CT3IKMKA.js";
+import { C as getEnvString, a as logger } from "./logger-DO8_zM18.js";
 import { t as invariant } from "./invariant-Ddh24eXh.js";
-import "./esm-Cd1AjG1D.js";
-import "./pythonUtils-D5nxkQ0P.js";
-import "./types-CLKiCBW3.js";
-import "./util-Dlz_Wvgm.js";
-import "./fetch-60Gzydls.js";
-import "./cache-8XhNqPKW.js";
+import "./esm-SUNIX1x3.js";
+import "./pythonUtils-Cpo0Ez1p.js";
+import "./types-q8GXGF65.js";
+import "./util-CMMkIxfU.js";
+import "./fetch-CVAtKnI3.js";
+import "./cache-CaT5tPgo.js";
 import "./genaiTracer-D3fD9dNV.js";
-import { t as OpenAiChatCompletionProvider } from "./chat-CznLWr_D.js";
-import "./transform-DGLazrMm.js";
-import { t as AnthropicMessagesProvider } from "./messages-BLbWdsyt.js";
-import "./util-DaWTWKBK.js";
-import "./openai-DElQ-fPX.js";
-import "./util-Betm42rL.js";
+import { t as OpenAiChatCompletionProvider } from "./chat-pxmiVpWe.js";
+import "./transform-DyDAwEpE.js";
+import { t as AnthropicMessagesProvider } from "./messages-Dy9QecMs.js";
+import "./util-vNmDL5DT.js";
+import "./openai-BcB5KlTk.js";
+import "./util-CgDCK4KI.js";
 //#region src/providers/cloudflare-gateway.ts
 /**
 * Cloudflare AI Gateway Provider
@@ -280,4 +280,4 @@ function createCloudflareGatewayProvider(providerPath, options = {}) {
 //#endregion
 export { createCloudflareGatewayProvider };
 
-//# sourceMappingURL=cloudflare-gateway-D6xFc5pa.js.map
+//# sourceMappingURL=cloudflare-gateway-BwAaUgeW.js.map

package/dist/src/{cloudflare-gateway-D6O7AlYb.js → cloudflare-gateway-D-e9i1Sn.js}

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
-import { C as getEnvString, o as logger } from "./logger-KkObSCzq.js";
-import "./fetch-BMv0O527.js";
+import { E as getEnvString, s as logger } from "./logger-BcJBzSSA.js";
+import "./fetch-DoVRJZhJ.js";
 import { t as invariant } from "./invariant-BtWWVVhl.js";
-import "./cloud-Bc9526yV.js";
-import "./types-CH3Ge2sE.js";
-import "./cache-CG0SlR1d.js";
-import "./util-YT5HPZaS.js";
-import "./esm-C03C-mv3.js";
-import "./pythonUtils-C3py6GC1.js";
+import "./cloud-z8KZpUoa.js";
+import "./types-CIhFeUC4.js";
+import "./cache-DSqR6ezl.js";
+import "./util-Bm3E9jpK.js";
+import "./esm-7UIl0pPM.js";
+import "./pythonUtils-wIqk7zAf.js";
 import "./genaiTracer-C1rxGO8Q.js";
-import { t as OpenAiChatCompletionProvider } from "./chat-CRWNNq73.js";
-import "./transform-Cgi24fJ7.js";
-import { t as AnthropicMessagesProvider } from "./messages-1x9atZmP.js";
-import "./util-B7T3SiBS.js";
-import "./openai-DhbB7eWK.js";
-import "./util-C-PPYSMq.js";
+import { t as OpenAiChatCompletionProvider } from "./chat-BEwdgGEg.js";
+import "./transform-DrleutM3.js";
+import { t as AnthropicMessagesProvider } from "./messages-DJNo37Ko.js";
+import "./util-DMFeUvLz.js";
+import "./openai-BMcwgD5C.js";
+import "./util-DM2rTn_6.js";
 //#region src/providers/cloudflare-gateway.ts
 /**
 * Cloudflare AI Gateway Provider
@@ -282,4 +282,4 @@ function createCloudflareGatewayProvider(providerPath, options = {}) {
 //#endregion
 export { createCloudflareGatewayProvider };
 
-//# sourceMappingURL=cloudflare-gateway-D6O7AlYb.js.map
+//# sourceMappingURL=cloudflare-gateway-D-e9i1Sn.js.map

package/dist/src/{cloudflare-gateway-pXGHxJ47.js → cloudflare-gateway-DXhtXDRb.js}

@@ -1,166 +1,18 @@
-import { b as getEnvString, i as logger } from "./logger-DLcq4dWf.js";
-import "./fetch-4M3YRaqL.js";
+import { C as getEnvString, a as logger } from "./logger-BnkjG2jt.js";
+import "./fetch-BiYv2BZc.js";
 import { t as invariant } from "./invariant-vgHWClmd.js";
-import "./esm-CaIwzWR5.js";
-import "./types-CN_TZ2GJ.js";
-import { a as isCacheEnabled, i as getCache } from "./cache-D3eqDYGU.js";
+import "./esm-CKWP3u_P.js";
+import "./types-Cd3ygw8W.js";
+import "./cache-HP0NP4k3.js";
 import "./genaiTracer-70Z8BIuV.js";
-import "./pythonUtils-D6fwaDSg.js";
-import "./util-5cB-L7U3.js";
-import { t as OpenAiChatCompletionProvider } from "./chat-BKm79wib.js";
-import "./transform-DGxXocjk.js";
-import { t as AnthropicMessagesProvider } from "./messages-D8EA0oDc.js";
-import "./util-ZZH-3QZz.js";
-import "./openai-j-sE2O7r.js";
-import "./util-6-GqIvzS.js";
-import fs from "fs";
-import path from "path";
-import dedent from "dedent";
-import crypto from "crypto";
-//#region src/providers/agentic-utils.ts
-/**
-* Shared utilities for agentic providers (Claude Agent SDK, OpenCode SDK, etc.)
-*
-* These utilities handle common functionality needed by coding agent providers:
-* - Working directory fingerprinting for cache key generation
-* - Response caching with fingerprint support
-*/
-/**
-* Timeout for working directory fingerprint generation (ms)
-* Prevents hanging on extremely large directories
-*/
-const FINGERPRINT_TIMEOUT_MS = 2e3;
-/**
-* Get a fingerprint for a working directory to use as a cache key.
-* Checks directory mtime and descendant file mtimes recursively.
-*
-* This allows for caching prompts that use the same working directory
-* when the files haven't changed.
-*
-* @param workingDir - Absolute path to the working directory
-* @returns SHA-256 hash fingerprint of the directory state
-* @throws Error if fingerprinting times out or directory is inaccessible
-*/
-async function getWorkingDirFingerprint(workingDir) {
-	const dirMtime = fs.statSync(workingDir).mtimeMs;
-	const startTime = Date.now();
-	const getAllFiles = (dir, files = []) => {
-		if (Date.now() - startTime > FINGERPRINT_TIMEOUT_MS) throw new Error("Working directory fingerprint timed out");
-		const entries = fs.readdirSync(dir, { withFileTypes: true });
-		for (const entry of entries) {
-			const fullPath = path.join(dir, entry.name);
-			if (entry.isDirectory()) getAllFiles(fullPath, files);
-			else if (entry.isFile()) files.push(fullPath);
-		}
-		return files;
-	};
-	const fingerprintData = `dir:${dirMtime};files:${getAllFiles(workingDir).map((file) => {
-		const stat = fs.statSync(file);
-		return `${path.relative(workingDir, file)}:${stat.mtimeMs}`;
-	}).sort().join(",")}`;
-	return crypto.createHash("sha256").update(fingerprintData).digest("hex");
-}
-/**
-* Generate a cache key from arbitrary data using SHA-256 hash
-*
-* @param prefix - Cache key prefix (provider identifier)
-* @param data - Data to hash for the cache key
-* @returns Prefixed SHA-256 hash cache key
-*/
-function generateCacheKey(prefix, data) {
-	const stringified = JSON.stringify(data);
-	return `${prefix}:${crypto.createHash("sha256").update(stringified).digest("hex")}`;
-}
-/**
-* Initialize cache and check for cached response
-*
-* This handles the common caching pattern used by agentic providers:
-* 1. Check if caching is enabled
-* 2. Generate working directory fingerprint if needed
-* 3. Generate cache key
-* 4. Return cache configuration for use by the provider
-*
-* @param options - Cache options including prefix and working directory
-* @param cacheKeyData - Data to include in the cache key
-* @returns Cache configuration and optional cached response
-*/
-async function initializeAgenticCache(options, cacheKeyData) {
-	if (!isCacheEnabled()) return {
-		shouldCache: false,
-		shouldReadCache: false,
-		shouldWriteCache: false
-	};
-	if (options.mcp && !options.cacheMcp) return {
-		shouldCache: false,
-		shouldReadCache: false,
-		shouldWriteCache: false
-	};
-	let workingDirFingerprint = null;
-	if (options.workingDir) try {
-		workingDirFingerprint = await getWorkingDirFingerprint(options.workingDir);
-	} catch (error) {
-		logger.error(dedent`Error getting working directory fingerprint for cache key - ${options.workingDir}: ${String(error)}
-
-        Caching is disabled.`);
-		return {
-			shouldCache: false,
-			shouldReadCache: false,
-			shouldWriteCache: false
-		};
-	}
-	const cache = await getCache();
-	const cacheKey = generateCacheKey(options.cacheKeyPrefix, {
-		...cacheKeyData,
-		workingDirFingerprint,
-		...options.mcp ? { mcp: options.mcp } : {}
-	});
-	return {
-		shouldCache: true,
-		shouldReadCache: !options.bustCache,
-		shouldWriteCache: true,
-		cache,
-		cacheKey,
-		workingDirFingerprint
-	};
-}
-/**
-* Try to get a cached response
-*
-* @param cacheResult - Result from initializeAgenticCache
-* @param debugContext - Context for debug logging (e.g., prompt preview)
-* @returns Cached ProviderResponse if found, undefined otherwise
-*/
-async function getCachedResponse(cacheResult, debugContext) {
-	if (!cacheResult.shouldReadCache || !cacheResult.cache || !cacheResult.cacheKey) return;
-	try {
-		const cachedResponse = await cacheResult.cache.get(cacheResult.cacheKey);
-		if (cachedResponse) {
-			logger.debug(`Returning cached response${debugContext ? ` for ${debugContext}` : ""} (cache key: ${cacheResult.cacheKey})`);
-			return {
-				...JSON.parse(cachedResponse),
-				cached: true
-			};
-		}
-	} catch (error) {
-		logger.error(`Error getting cached response: ${String(error)}`);
-	}
-}
-/**
-* Cache a provider response
-*
-* @param cacheResult - Result from initializeAgenticCache
-* @param response - The ProviderResponse to cache
-* @param debugContext - Context for debug logging
-*/
-async function cacheResponse(cacheResult, response, debugContext) {
-	if (!cacheResult.shouldWriteCache || !cacheResult.cache || !cacheResult.cacheKey) return;
-	try {
-		await cacheResult.cache.set(cacheResult.cacheKey, JSON.stringify(response));
-	} catch (error) {
-		logger.error(`Error caching response${debugContext ? ` for ${debugContext}` : ""}: ${String(error)}`);
-	}
-}
-//#endregion
+import "./pythonUtils-Bzwbgpbg.js";
+import "./util-BLvy9qfE.js";
+import { t as OpenAiChatCompletionProvider } from "./chat-B0iaWhoh.js";
+import "./transform-B2-jIv68.js";
+import { t as AnthropicMessagesProvider } from "./messages-biC_ex-p.js";
+import "./util-DbVG-yZU.js";
+import "./openai-D6wITiVn.js";
+import "./util-BtoGs5Cb.js";
 //#region src/providers/cloudflare-gateway.ts
 /**
 * Cloudflare AI Gateway Provider
@@ -426,6 +278,6 @@ function createCloudflareGatewayProvider(providerPath, options = {}) {
 	return new CloudflareGatewayOpenAiProvider(underlyingProvider, modelName, options);
 }
 //#endregion
-export { createCloudflareGatewayProvider, initializeAgenticCache as i, generateCacheKey as n, getCachedResponse as r, cacheResponse as t };
+export { createCloudflareGatewayProvider };
 
-//# sourceMappingURL=cloudflare-gateway-pXGHxJ47.js.map
+//# sourceMappingURL=cloudflare-gateway-DXhtXDRb.js.map

package/dist/src/{cloudflare-gateway-C2_-KG5o.cjs → cloudflare-gateway-Dx36ftqF.cjs}

@@ -1,18 +1,18 @@
-const require_logger = require("./logger-Cp1GPUjj.cjs");
+const require_logger = require("./logger-D5iKBpu_.cjs");
 const require_invariant = require("./invariant-kfQ8Bu82.cjs");
-require("./esm-CnNt7sI4.cjs");
-require("./pythonUtils-CTU3Y3lw.cjs");
-require("./types-LJ0r3wbR.cjs");
-require("./util-Yz-1aEhW.cjs");
-require("./fetch-BxUk8odA.cjs");
-require("./cache-COish3-W.cjs");
-require("./genaiTracer-DN4dQywX.cjs");
-const require_chat = require("./chat-DaqekjFr.cjs");
-require("./transform-DOcQeLld.cjs");
-const require_messages = require("./messages-1JrJs91T.cjs");
-require("./util-CchiqXh_.cjs");
-require("./openai-Cuif0GEt.cjs");
-require("./util-Db0a0AFH.cjs");
+require("./esm-CipptfDu.cjs");
+require("./pythonUtils-dAVigVK-.cjs");
+require("./types-D8cGDZbL.cjs");
+require("./util-CuLo2pMR.cjs");
+require("./fetch-BnR9wSnm.cjs");
+require("./cache-C5yFZ4gC.cjs");
+require("./genaiTracer-BfxrvSUb.cjs");
+const require_chat = require("./chat-CM8qWR3_.cjs");
+require("./transform-0BwoBsvO.cjs");
+const require_messages = require("./messages-HJsyEh4o.cjs");
+require("./util--9u9UVCt.cjs");
+require("./openai-CoxGAQwn.cjs");
+require("./util-CFj4YKIn.cjs");
 //#region src/providers/cloudflare-gateway.ts
 /**
 * Cloudflare AI Gateway Provider
@@ -280,4 +280,4 @@ function createCloudflareGatewayProvider(providerPath, options = {}) {
 //#endregion
 exports.createCloudflareGatewayProvider = createCloudflareGatewayProvider;
 
-//# sourceMappingURL=cloudflare-gateway-C2_-KG5o.cjs.map
+//# sourceMappingURL=cloudflare-gateway-Dx36ftqF.cjs.map

package/dist/src/{codex-sdk-DUwKWezN.js → codex-sdk-BQEw16R_.js}

@@ -1,5 +1,5 @@
-import { b as getEnvString, i as logger, w as state } from "./logger-DLcq4dWf.js";
-import { i as resolvePackageEntryPoint, r as importModule } from "./esm-CaIwzWR5.js";
+import { C as getEnvString, D as state, a as logger, c as REDACTED, l as normalizeFieldName, u as sanitizeObject } from "./logger-BnkjG2jt.js";
+import { i as resolvePackageEntryPoint, r as importModule } from "./esm-CKWP3u_P.js";
 import { n as withGenAISpan, t as getTraceparent } from "./genaiTracer-70Z8BIuV.js";
 import fs from "fs";
 import path from "path";
@@ -7,12 +7,43 @@ import dedent from "dedent";
 import crypto from "crypto";
 import { SpanKind, SpanStatusCode, trace } from "@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 codexPath = resolvePackageEntryPoint("@openai/codex-sdk", state.basePath && path.isAbsolute(state.basePath) ? state.basePath : process.cwd());
+	const basePaths = [state.basePath && path.isAbsolute(state.basePath) ? state.basePath : void 0, process.cwd()].filter((candidate) => Boolean(candidate));
+	let codexPath = null;
+	for (const basePath of new Set(basePaths)) {
+		codexPath = resolvePackageEntryPoint("@openai/codex-sdk", basePath);
+		if (codexPath) break;
+	}
 	if (!codexPath) throw new Error(dedent`The @openai/codex-sdk package is required but not installed.
 
       To use the OpenAI Codex SDK provider, install it with:
@@ -163,7 +194,10 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 		}
 	}
 	prepareEnvironment(config, traceparent) {
-		const env = config.cli_env ? { ...config.cli_env } : { ...process.env };
+		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) {
@@ -192,6 +226,83 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 		} 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.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 {
@@ -230,7 +341,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 			...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.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 } : {}
@@ -259,7 +370,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 		if (config.persist_threads && cacheKey) this.threads.set(cacheKey, thread);
 		return thread;
 	}
-	async runStreaming(thread, prompt, runOptions, callOptions) {
+	async runStreaming(thread, prompt, runOptions, callOptions, skillRootPrefixes = []) {
 		const { events } = await thread.runStreamed(prompt, runOptions);
 		const items = [];
 		let usage = void 0;
@@ -338,7 +449,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 								}
 							});
 						}
-						const completionAttrs = this.getCompletionAttributesForItem(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);
@@ -367,7 +478,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 							const itemId = String(item.id);
 							const span = activeSpans.get(itemId);
 							if (span) {
-								const updatedAttrs = this.getCompletionAttributesForItem(item);
+								const updatedAttrs = this.getCompletionAttributesForItem(item, skillRootPrefixes);
 								for (const [key, value] of Object.entries(updatedAttrs)) span.setAttribute(key, value);
 							}
 						}
@@ -434,6 +545,25 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 	/**
 	* 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) {
@@ -443,6 +573,10 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 			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;
@@ -461,16 +595,40 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 		}
 		return attrs;
 	}
+	serializeItemValue(value) {
+		if (typeof value === "string") {
+			const trimmed = value.trim();
+			if (!trimmed) return;
+			try {
+				return JSON.stringify(this.redactTracePii(sanitizeObject(JSON.parse(trimmed))));
+			} catch {
+				return this.redactTracePii(sanitizeObject(trimmed, { context: "Codex MCP trace input" }));
+			}
+		}
+		if (value === void 0 || value === null) return;
+		try {
+			return JSON.stringify(this.redactTracePii(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 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, normalizeFieldName(key).includes("email") ? REDACTED : this.redactTracePii(entryValue)]));
+		return value;
+	}
 	/**
 	* Get attributes for a Codex item at completion
 	*/
-	getCompletionAttributesForItem(item) {
+	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;
@@ -482,6 +640,10 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 			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;
@@ -571,6 +733,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 	async callApiInternal(prompt, _context, callOptions, config) {
 		const currentTraceparent = 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" };
@@ -610,9 +773,14 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 		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) : await thread.run(prompt, runOptions);
+			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,
@@ -638,6 +806,7 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 				output,
 				tokenUsage,
 				cost,
+				metadata,
 				raw,
 				sessionId: thread.id || "unknown"
 			};
@@ -662,4 +831,4 @@ var OpenAICodexSDKProvider = class OpenAICodexSDKProvider {
 //#endregion
 export { OpenAICodexSDKProvider };
 
-//# sourceMappingURL=codex-sdk-DUwKWezN.js.map
+//# sourceMappingURL=codex-sdk-BQEw16R_.js.map