promptfoo 0.121.5 → 0.121.7

package/dist/src/remoteGeneration-DsaSwmG2.js

@@ -0,0 +1,217 @@
+import { S as getEnvBool, T as getEnvString, k as state } from "./logger-Ct2S6Yx-.js";
+import { w as CloudConfig } from "./fetch-It34O8Ur.js";
+import { o as isLoggedIntoCloud } from "./accounts-Ca7WIoPY.js";
+import { i as resolvePackageEntryPoint, t as getDirectory } from "./esm-BTK1W7lG.js";
+import { t as OpenAICodexSDKProvider } from "./codex-sdk-D2d54RL8.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+//#region src/providers/openai/codexDefaults.ts
+const CODEX_AUTH_FILENAME = "auth.json";
+const CODEX_SDK_PACKAGE_NAME = "@openai/codex-sdk";
+let codexDefaultWorkingDir;
+const CODEX_GRADING_OUTPUT_SCHEMA = {
+	type: "object",
+	properties: {
+		pass: { type: "boolean" },
+		score: { type: "number" },
+		reason: { type: "string" }
+	},
+	required: [
+		"pass",
+		"score",
+		"reason"
+	],
+	additionalProperties: false
+};
+const codexDefaultProvidersByCacheKey = /* @__PURE__ */ new Map();
+const codexSdkAvailabilityByBaseDir = /* @__PURE__ */ new Map();
+function getCodexEnvString(env, key) {
+	return env?.[key] || getEnvString(key);
+}
+function getCodexHome(env) {
+	const homeDir = os.homedir?.();
+	const defaultHome = typeof homeDir === "string" && homeDir ? path.join(homeDir, ".codex") : void 0;
+	const codexHome = getCodexEnvString(env, "CODEX_HOME") || defaultHome || ".codex";
+	return path.resolve(codexHome);
+}
+function getTempDirectory() {
+	const tempDir = os.tmpdir?.();
+	return typeof tempDir === "string" && tempDir ? tempDir : process.cwd();
+}
+function getCodexDefaultWorkingDir() {
+	if (!codexDefaultWorkingDir) codexDefaultWorkingDir = fs.mkdtempSync(path.join(getTempDirectory(), "promptfoo-codex-default-"));
+	return codexDefaultWorkingDir;
+}
+function hasCodexAuthFile(env) {
+	try {
+		const stats = fs.statSync(path.join(getCodexHome(env), CODEX_AUTH_FILENAME));
+		return stats.isFile() && stats.size > 0;
+	} catch {
+		return false;
+	}
+}
+function hasCodexSdkPackage(baseDir) {
+	const cached = codexSdkAvailabilityByBaseDir.get(baseDir);
+	if (cached !== void 0) return cached;
+	const hasPackage = resolvePackageEntryPoint(CODEX_SDK_PACKAGE_NAME, baseDir) !== null;
+	codexSdkAvailabilityByBaseDir.set(baseDir, hasPackage);
+	return hasPackage;
+}
+function canLoadCodexSdkPackage() {
+	return [process.cwd(), getDirectory()].some((baseDir) => hasCodexSdkPackage(baseDir));
+}
+function hasCodexDefaultCredentials(env) {
+	return (Boolean(getCodexEnvString(env, "CODEX_API_KEY")) || hasCodexAuthFile(env)) && canLoadCodexSdkPackage();
+}
+function getCodexDefaultProviderConfig(env, config, defaultWorkingDir = getCodexDefaultWorkingDir()) {
+	const codexHome = getCodexEnvString(env, "CODEX_HOME");
+	const workingDir = config?.working_dir || defaultWorkingDir;
+	fs.mkdirSync(workingDir, { recursive: true });
+	const cliEnv = {
+		...codexHome ? { CODEX_HOME: path.resolve(codexHome) } : {},
+		...config?.cli_env
+	};
+	return {
+		approval_policy: "never",
+		sandbox_mode: "read-only",
+		skip_git_repo_check: true,
+		working_dir: workingDir,
+		...config,
+		...Object.keys(cliEnv).length > 0 ? { cli_env: cliEnv } : {}
+	};
+}
+function getCodexDefaultProvidersCacheKey(env) {
+	return JSON.stringify({
+		CODEX_HOME: getCodexEnvString(env, "CODEX_HOME"),
+		hasCodexApiKey: Boolean(getCodexEnvString(env, "CODEX_API_KEY")),
+		hasOpenAiApiKey: Boolean(getCodexEnvString(env, "OPENAI_API_KEY"))
+	});
+}
+function getCodexDefaultProviders(env) {
+	const cacheKey = getCodexDefaultProvidersCacheKey(env);
+	const cachedProviders = codexDefaultProvidersByCacheKey.get(cacheKey);
+	if (cachedProviders) return cachedProviders;
+	const defaultWorkingDir = getCodexDefaultWorkingDir();
+	const gradingProvider = new OpenAICodexSDKProvider({
+		config: getCodexDefaultProviderConfig(env, void 0, defaultWorkingDir),
+		env
+	});
+	const gradingJsonProvider = new OpenAICodexSDKProvider({
+		config: getCodexDefaultProviderConfig(env, { output_schema: CODEX_GRADING_OUTPUT_SCHEMA }, defaultWorkingDir),
+		env
+	});
+	const providers = {
+		gradingJsonProvider,
+		gradingProvider,
+		llmRubricProvider: gradingJsonProvider,
+		suggestionsProvider: gradingProvider,
+		synthesizeProvider: gradingProvider,
+		webSearchProvider: new OpenAICodexSDKProvider({
+			config: getCodexDefaultProviderConfig(env, {
+				network_access_enabled: true,
+				output_schema: CODEX_GRADING_OUTPUT_SCHEMA,
+				web_search_mode: "live"
+			}, defaultWorkingDir),
+			env
+		})
+	};
+	codexDefaultProvidersByCacheKey.set(cacheKey, providers);
+	return providers;
+}
+//#endregion
+//#region src/redteam/remoteGeneration.ts
+/**
+* Gets the remote generation API endpoint URL.
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The remote generation URL
+*/
+function getRemoteGenerationUrl() {
+	const envUrl = getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) return envUrl;
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task";
+	return "https://api.promptfoo.app/api/v1/task";
+}
+/**
+* Check if remote generation should never be used.
+* Respects both the general and redteam-specific disable flags.
+* @returns true if remote generation is disabled
+*/
+function neverGenerateRemote() {
+	if (getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION")) return true;
+	return getEnvBool("PROMPTFOO_DISABLE_REDTEAM_REMOTE_GENERATION");
+}
+/**
+* Check if remote generation should never be used for non-redteam features.
+* This allows granular control: disable redteam remote generation while allowing
+* regular SimulatedUser to use remote generation.
+* @returns true if ALL remote generation is disabled
+*/
+function neverGenerateRemoteForRegularEvals() {
+	return getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION");
+}
+/**
+* Builds a remote URL with a substituted pathname, honoring env vars / cloud config.
+*/
+function buildRemoteUrl(pathname, fallback) {
+	if (neverGenerateRemote()) return null;
+	const envUrl = getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) try {
+		const url = new URL(envUrl);
+		url.pathname = pathname;
+		return url.toString();
+	} catch {
+		return fallback;
+	}
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return `${cloudConfig.getApiHost()}${pathname}`;
+	return fallback;
+}
+/**
+* Gets the URL for checking remote API health based on configuration.
+* @returns The health check URL, or null if remote generation is disabled.
+*/
+function getRemoteHealthUrl() {
+	return buildRemoteUrl("/health", "https://api.promptfoo.app/health");
+}
+/**
+* Gets the URL for checking remote API version based on configuration.
+* @returns The version check URL, or null if remote generation is disabled.
+*/
+function getRemoteVersionUrl() {
+	return buildRemoteUrl("/version", "https://api.promptfoo.app/version");
+}
+function getRemoteGenerationDisabledError(strategyName) {
+	return `${strategyName} requires remote generation, which is currently disabled for this configuration. To enable it, run with --remote, set PROMPTFOO_REMOTE_GENERATION_URL to a self-hosted endpoint, or log into Promptfoo Cloud with \`promptfoo auth login\`.`;
+}
+function getRemoteGenerationExplicitlyDisabledError(strategyName) {
+	const activeFlags = ["PROMPTFOO_DISABLE_REMOTE_GENERATION", "PROMPTFOO_DISABLE_REDTEAM_REMOTE_GENERATION"].filter((flag) => getEnvBool(flag));
+	return `${strategyName} requires remote generation, which has been explicitly disabled. To enable it, ${activeFlags.length > 0 ? `unset ${activeFlags.join(" and ")}` : "unset PROMPTFOO_DISABLE_REMOTE_GENERATION or PROMPTFOO_DISABLE_REDTEAM_REMOTE_GENERATION (whichever is set)"}. Once re-enabled, you can point at a self-hosted endpoint with PROMPTFOO_REMOTE_GENERATION_URL or use Promptfoo Cloud via \`promptfoo auth login\`.`;
+}
+/**
+* Determines if remote generation should be used based on configuration.
+* @returns true if remote generation should be used
+*/
+function shouldGenerateRemote(options) {
+	if (neverGenerateRemote()) return false;
+	if (getEnvString("PROMPTFOO_REMOTE_GENERATION_URL")) return true;
+	if (isLoggedIntoCloud()) return true;
+	return !(Boolean(getEnvString("OPENAI_API_KEY")) || options?.canUseCodexDefaultProvider && !options?.requireEmbeddingProvider && hasCodexDefaultCredentials()) || (state.remote ?? false);
+}
+/**
+* Gets the URL for unaligned model inference (harmful content generation).
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The unaligned inference URL
+*/
+function getRemoteGenerationUrlForUnaligned() {
+	const envUrl = getEnvString("PROMPTFOO_UNALIGNED_INFERENCE_ENDPOINT");
+	if (envUrl) return envUrl;
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task/harmful";
+	return "https://api.promptfoo.app/api/v1/task/harmful";
+}
+//#endregion
+export { getRemoteHealthUrl as a, neverGenerateRemoteForRegularEvals as c, hasCodexDefaultCredentials as d, getRemoteGenerationUrlForUnaligned as i, shouldGenerateRemote as l, getRemoteGenerationExplicitlyDisabledError as n, getRemoteVersionUrl as o, getRemoteGenerationUrl as r, neverGenerateRemote as s, getRemoteGenerationDisabledError as t, getCodexDefaultProviders as u };
+
+//# sourceMappingURL=remoteGeneration-DsaSwmG2.js.map

package/dist/src/render-BNTrbmBw.cjs

@@ -0,0 +1,384 @@
+const require_rolldown_runtime = require("./rolldown-runtime-D_mwlA32.cjs");
+const require_logger = require("./logger-cfNpzI4o.cjs");
+let nunjucks = require("nunjucks");
+nunjucks = require_rolldown_runtime.__toESM(nunjucks, 1);
+//#region src/util/templates.ts
+function isNunjucksAstNode(value) {
+	return Boolean(value && typeof value === "object" && typeof value.typename === "string");
+}
+function getNunjucksParser() {
+	return nunjucks.default.parser;
+}
+function parseNunjucksTemplate(template) {
+	const parser = getNunjucksParser();
+	if (!parser || typeof parser.parse !== "function") {
+		require_logger.logger.debug("[templates] nunjucks.parser.parse is not available; falling back to conservative detection");
+		return { ok: false };
+	}
+	try {
+		return {
+			ok: true,
+			ast: parser.parse(template)
+		};
+	} catch (err) {
+		require_logger.logger.debug("[templates] nunjucks parse failed; falling back to conservative detection", { error: err instanceof Error ? err.message : String(err) });
+		return { ok: false };
+	}
+}
+function isNonReferenceSymbol(parent) {
+	if (!parent) return false;
+	return parent.node.typename === "Pair" && parent.field === "key" || parent.node.typename === "Filter" && parent.field === "name" || parent.node.typename === "Is" && parent.field === "right" || parent.node.typename === "Set" && parent.field === "targets" || isForLikeNode(parent.node) && parent.field === "name" || parent.node.typename === "Macro" && parent.field === "name" || parent.node.typename === "Import" && parent.field === "target" || parent.node.typename === "FromImport" && parent.field === "names";
+}
+function getSymbolName(node) {
+	return isNunjucksAstNode(node) && node.typename === "Symbol" && typeof node.value === "string" ? node.value : void 0;
+}
+function collectBindingNames(node) {
+	if (Array.isArray(node)) return node.flatMap((item) => collectBindingNames(item));
+	const symbolName = getSymbolName(node);
+	if (symbolName) return [symbolName];
+	if (!isNunjucksAstNode(node) || !Array.isArray(node.children)) return [];
+	return node.children.flatMap((child) => collectBindingNames(child));
+}
+function addBindingNames(scope, node) {
+	const nextScope = new Set(scope);
+	for (const name of collectBindingNames(node)) nextScope.add(name);
+	return nextScope;
+}
+function addNamesToScope(scope, names) {
+	const nextScope = new Set(scope);
+	for (const name of names) nextScope.add(name);
+	return nextScope;
+}
+function collectFromImportBindingNames(namesNode) {
+	if (!isNunjucksAstNode(namesNode) || !Array.isArray(namesNode.children)) return [];
+	const names = [];
+	for (const child of namesNode.children) {
+		const plainImportName = getSymbolName(child);
+		if (plainImportName) {
+			names.push(plainImportName);
+			continue;
+		}
+		if (isNunjucksAstNode(child) && child.typename === "Pair") {
+			const aliasName = getSymbolName(child.value);
+			if (aliasName) names.push(aliasName);
+		}
+	}
+	return names;
+}
+function astNodeListReferencesVariable(nodes, variableName, parent, boundSymbols) {
+	let scope = new Set(boundSymbols);
+	for (const item of nodes) {
+		if (!isNunjucksAstNode(item)) continue;
+		if (astReferencesVariable(item, variableName, parent, scope)) return true;
+		if (item.typename === "Set") scope = addBindingNames(scope, item.targets);
+		else if (item.typename === "Macro") scope = addBindingNames(scope, item.name);
+		else if (item.typename === "Import") scope = addBindingNames(scope, item.target);
+		else if (item.typename === "FromImport") scope = addNamesToScope(scope, collectFromImportBindingNames(item.names));
+	}
+	return false;
+}
+function astChildReferencesVariable(node, field, variableName, boundSymbols) {
+	const child = node[field];
+	if (Array.isArray(child)) return child.some((item) => isNunjucksAstNode(item) && astReferencesVariable(item, variableName, {
+		field,
+		node
+	}, boundSymbols));
+	return isNunjucksAstNode(child) && astReferencesVariable(child, variableName, {
+		field,
+		node
+	}, boundSymbols);
+}
+function isForLikeNode(node) {
+	return node.typename === "For" || node.typename === "AsyncEach" || node.typename === "AsyncAll";
+}
+function forLikeNodeReferencesVariable(node, variableName, boundSymbols) {
+	const loopScope = addBindingNames(boundSymbols, node.name);
+	return astChildReferencesVariable(node, "arr", variableName, boundSymbols) || astChildReferencesVariable(node, "body", variableName, loopScope) || astChildReferencesVariable(node, "else_", variableName, boundSymbols);
+}
+/**
+* Walk a Nunjucks macro/caller signature left-to-right. Positional args and
+* earlier keyword defaults are visible to later defaults, but the current
+* keyword is not bound until its own default value has been evaluated.
+*/
+function analyzeSignatureArgs(argsNode, variableName, boundSymbols) {
+	const paramNames = [];
+	if (!isNunjucksAstNode(argsNode) || !Array.isArray(argsNode.children)) return {
+		paramNames,
+		referencesVariable: false
+	};
+	const defaultScope = new Set(boundSymbols);
+	for (const child of argsNode.children) {
+		if (!isNunjucksAstNode(child)) continue;
+		const positionalParamName = getSymbolName(child);
+		if (positionalParamName) {
+			paramNames.push(positionalParamName);
+			defaultScope.add(positionalParamName);
+			continue;
+		}
+		if (child.typename === "KeywordArgs" && Array.isArray(child.children)) {
+			for (const pair of child.children) {
+				const keywordParamName = isNunjucksAstNode(pair) && pair.typename === "Pair" ? getSymbolName(pair.key) : void 0;
+				if (isNunjucksAstNode(pair) && pair.typename === "Pair" && astChildReferencesVariable(pair, "value", variableName, defaultScope)) return {
+					paramNames,
+					referencesVariable: true
+				};
+				if (keywordParamName) {
+					paramNames.push(keywordParamName);
+					defaultScope.add(keywordParamName);
+				}
+			}
+			continue;
+		}
+		if (astReferencesVariable(child, variableName, {
+			field: "children",
+			node: argsNode
+		}, defaultScope)) return {
+			paramNames,
+			referencesVariable: true
+		};
+	}
+	return {
+		paramNames,
+		referencesVariable: false
+	};
+}
+function macroNodeReferencesVariable(node, variableName, boundSymbols) {
+	const { paramNames, referencesVariable } = analyzeSignatureArgs(node.args, variableName, boundSymbols);
+	if (referencesVariable) return true;
+	const macroScope = addNamesToScope(boundSymbols, paramNames);
+	const macroName = getSymbolName(node.name);
+	if (macroName) macroScope.add(macroName);
+	return astChildReferencesVariable(node, "body", variableName, macroScope);
+}
+function isNodeReferencesVariable(node, variableName, boundSymbols) {
+	if (astChildReferencesVariable(node, "left", variableName, boundSymbols)) return true;
+	const right = node.right;
+	if (!isNunjucksAstNode(right)) return false;
+	if (right.typename === "FunCall") return astChildReferencesVariable(right, "args", variableName, boundSymbols);
+	return right.typename !== "Symbol" && astReferencesVariable(right, variableName, {
+		field: "right",
+		node
+	}, boundSymbols);
+}
+function setNodeReferencesVariable(node, variableName, boundSymbols) {
+	return astChildReferencesVariable(node, "value", variableName, boundSymbols) || astChildReferencesVariable(node, "body", variableName, boundSymbols);
+}
+function fromImportNodeReferencesVariable(node, variableName, boundSymbols) {
+	return astChildReferencesVariable(node, "template", variableName, boundSymbols);
+}
+function blockNodeReferencesVariable(node, variableName, boundSymbols) {
+	return astChildReferencesVariable(node, "body", variableName, boundSymbols);
+}
+function callerNodeReferencesVariable(node, variableName, boundSymbols) {
+	const { paramNames, referencesVariable } = analyzeSignatureArgs(node.args, variableName, boundSymbols);
+	if (referencesVariable) return true;
+	return astChildReferencesVariable(node, "body", variableName, addNamesToScope(boundSymbols, paramNames));
+}
+function astFieldsReferenceVariable(node, variableName, boundSymbols) {
+	return (node.fields ?? []).some((field) => astChildReferencesVariable(node, field, variableName, boundSymbols));
+}
+function astReferencesVariable(node, variableName, parent, boundSymbols = /* @__PURE__ */ new Set()) {
+	if (node.typename === "Symbol" && node.value === variableName) return !boundSymbols.has(variableName) && !isNonReferenceSymbol(parent);
+	if ((node.typename === "Root" || node.typename === "NodeList") && Array.isArray(node.children)) return astNodeListReferencesVariable(node.children, variableName, {
+		field: "children",
+		node
+	}, boundSymbols);
+	if (isForLikeNode(node)) return forLikeNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "Macro") return macroNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "Is") return isNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "Set") return setNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "FromImport") return fromImportNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "Block") return blockNodeReferencesVariable(node, variableName, boundSymbols);
+	if (node.typename === "Caller") return callerNodeReferencesVariable(node, variableName, boundSymbols);
+	return astFieldsReferenceVariable(node, variableName, boundSymbols);
+}
+/**
+* Get a Nunjucks engine instance with optional filters and configuration.
+* @param filters - Optional map of custom Nunjucks filters.
+* @param throwOnUndefined - Whether to throw an error on undefined variables.
+* @param isGrader - Whether this engine is being used in a grader context.
+* Nunjucks is always enabled in grader mode.
+* @returns A configured Nunjucks environment.
+*/
+function getNunjucksEngine(filters, throwOnUndefined = false, isGrader = false) {
+	if (!isGrader && require_logger.getEnvBool("PROMPTFOO_DISABLE_TEMPLATING")) return { renderString: (template) => template };
+	const env = nunjucks.default.configure({
+		autoescape: false,
+		throwOnUndefined
+	});
+	const envGlobals = {
+		...require_logger.getEnvBool("PROMPTFOO_DISABLE_TEMPLATE_ENV_VARS", require_logger.getEnvBool("PROMPTFOO_SELF_HOSTED", false)) ? {} : process.env,
+		...require_logger.state.config?.env
+	};
+	env.addGlobal("env", envGlobals);
+	env.addFilter("load", function(str) {
+		return JSON.parse(str);
+	});
+	if (filters) for (const [name, filter] of Object.entries(filters)) env.addFilter(name, filter);
+	return env;
+}
+/**
+* Parse Nunjucks template to extract variables.
+* @param template - The Nunjucks template string.
+* @returns An array of variables used in the template.
+*/
+function extractVariablesFromTemplate(template) {
+	const variableSet = /* @__PURE__ */ new Set();
+	const regex = /\{\{[\s]*([^{}\s|]+)[\s]*(?:\|[^}]+)?\}\}|\{%[\s]*(?:if|for)[\s]+([^{}\s]+)[\s]*.*?%\}/g;
+	template = template.replace(/\{#[\s\S]*?#\}/g, "");
+	let match;
+	while ((match = regex.exec(template)) !== null) {
+		const variable = match[1] || match[2];
+		if (variable) variableSet.add(variable);
+	}
+	const forLoopRegex = /\{%[\s]*for[\s]+(\w+)[\s]+in[\s]+(\w+)[\s]*%\}/g;
+	while ((match = forLoopRegex.exec(template)) !== null) {
+		variableSet.delete(match[1]);
+		variableSet.add(match[2]);
+	}
+	return Array.from(variableSet);
+}
+/**
+* Extract variables from multiple Nunjucks templates.
+* @param templates - An array of Nunjucks template strings.
+* @returns An array of variables used in the templates.
+*/
+function extractVariablesFromTemplates(templates) {
+	const variableSet = /* @__PURE__ */ new Set();
+	for (const template of templates) extractVariablesFromTemplate(template).forEach((variable) => variableSet.add(variable));
+	return Array.from(variableSet);
+}
+/**
+* Classify whether a template references `variableName` as a real Nunjucks
+* expression symbol, and surface whether the template parsed successfully.
+*
+* Callers that cache results should avoid caching when `parsed` is `false`,
+* otherwise a transient parse failure would poison the cache for the lifetime
+* of the process.
+*/
+function analyzeTemplateReference(template, variableName) {
+	if (!variableName || !template.includes(variableName)) return {
+		referenced: false,
+		parsed: true
+	};
+	const parseResult = parseNunjucksTemplate(template);
+	if (!parseResult.ok) return {
+		referenced: true,
+		parsed: false
+	};
+	return {
+		referenced: astReferencesVariable(parseResult.ast, variableName),
+		parsed: true
+	};
+}
+//#endregion
+//#region src/util/render.ts
+/**
+* Renders ONLY environment variable templates in an object, leaving all other templates untouched.
+* This allows env vars to be resolved at provider load time while preserving runtime var templates.
+*
+* Supports full Nunjucks syntax for env vars including filters and expressions:
+* - {{ env.VAR_NAME }}
+* - {{ env['VAR-NAME'] }}
+* - {{ env["VAR-NAME"] }}
+* - {{ env.VAR | default('fallback') }}
+* - {{ env.VAR | upper }}
+*
+* Preserves non-env templates for runtime rendering:
+* - {{ vars.x }} - preserved as literal
+* - {{ prompt }} - preserved as literal
+*
+* Implementation: Uses regex to find env templates, delegates to Nunjucks for rendering.
+* This ensures full Nunjucks feature support while preserving non-env templates.
+*
+* @param obj - The object to process
+* @param envOverrides - Optional env vars to merge with (or replace) the base env
+* @param replaceBase - If true, envOverrides replaces the base env entirely instead of merging
+* @returns The object with only env templates rendered
+*/
+function renderEnvOnlyInObject(obj, envOverrides, replaceBase) {
+	if (require_logger.getEnvBool("PROMPTFOO_DISABLE_TEMPLATING")) return obj;
+	if (typeof obj === "string") {
+		const nunjucks = getNunjucksEngine();
+		const baseEnvGlobals = nunjucks.getGlobal("env");
+		const envGlobals = replaceBase ? envOverrides ?? {} : envOverrides ? {
+			...baseEnvGlobals,
+			...envOverrides
+		} : baseEnvGlobals;
+		return obj.replace(/\{\{(?:[^}]|\}(?!\}))*\}\}/g, (match) => {
+			if (!match.match(/\benv\.|env\[/)) return match;
+			const varMatch = match.match(/env\.(\w+)|env\[['"]([^'"]+)['"]\]/);
+			const varName = varMatch?.[1] || varMatch?.[2];
+			if (match.includes("|") || varName && varName in envGlobals && envGlobals[varName] !== void 0) try {
+				return nunjucks.renderString(match, { env: envGlobals });
+			} catch (error) {
+				require_logger.logger.debug(`Failed to render env template "${match}": ${error instanceof Error ? error.message : String(error)}`);
+				return match;
+			}
+			return match;
+		});
+	}
+	if (Array.isArray(obj)) return obj.map((item) => renderEnvOnlyInObject(item, envOverrides, replaceBase));
+	if (typeof obj === "object" && obj !== null) {
+		const result = {};
+		for (const key in obj) {
+			if (key === "_conversation") {
+				result[key] = obj[key];
+				continue;
+			}
+			result[key] = renderEnvOnlyInObject(obj[key], envOverrides, replaceBase);
+		}
+		return result;
+	}
+	return obj;
+}
+function renderVarsInObject(obj, vars) {
+	if (!vars || require_logger.getEnvBool("PROMPTFOO_DISABLE_TEMPLATING")) return obj;
+	if (typeof obj === "string") return getNunjucksEngine().renderString(obj, vars);
+	if (Array.isArray(obj)) return obj.map((item) => renderVarsInObject(item, vars));
+	if (typeof obj === "object" && obj !== null) {
+		const result = {};
+		for (const key in obj) result[key] = renderVarsInObject(obj[key], vars);
+		return result;
+	} else if (typeof obj === "function") return renderVarsInObject(obj({ vars }));
+	return obj;
+}
+//#endregion
+Object.defineProperty(exports, "analyzeTemplateReference", {
+	enumerable: true,
+	get: function() {
+		return analyzeTemplateReference;
+	}
+});
+Object.defineProperty(exports, "extractVariablesFromTemplate", {
+	enumerable: true,
+	get: function() {
+		return extractVariablesFromTemplate;
+	}
+});
+Object.defineProperty(exports, "extractVariablesFromTemplates", {
+	enumerable: true,
+	get: function() {
+		return extractVariablesFromTemplates;
+	}
+});
+Object.defineProperty(exports, "getNunjucksEngine", {
+	enumerable: true,
+	get: function() {
+		return getNunjucksEngine;
+	}
+});
+Object.defineProperty(exports, "renderEnvOnlyInObject", {
+	enumerable: true,
+	get: function() {
+		return renderEnvOnlyInObject;
+	}
+});
+Object.defineProperty(exports, "renderVarsInObject", {
+	enumerable: true,
+	get: function() {
+		return renderVarsInObject;
+	}
+});
+
+//# sourceMappingURL=render-BNTrbmBw.cjs.map