promptfoo 0.122.1 → 0.122.2

package/dist/src/render-zarxdXS7.js

@@ -0,0 +1,347 @@
+import { R as state, j as getEnvBool, o as logger } from "./logger-BKiOczgq.js";
+import nunjucks from "nunjucks";
+//#region src/util/templates.ts
+function isNunjucksAstNode(value) {
+	return Boolean(value && typeof value === "object" && typeof value.typename === "string");
+}
+function getNunjucksParser() {
+	return nunjucks.parser;
+}
+function parseNunjucksTemplate(template) {
+	const parser = getNunjucksParser();
+	if (!parser || typeof parser.parse !== "function") {
+		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) {
+		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 && getEnvBool("PROMPTFOO_DISABLE_TEMPLATING")) return { renderString: (template) => template };
+	const env = nunjucks.configure({
+		autoescape: false,
+		throwOnUndefined
+	});
+	const envGlobals = {
+		...getEnvBool("PROMPTFOO_DISABLE_TEMPLATE_ENV_VARS", getEnvBool("PROMPTFOO_SELF_HOSTED", false)) ? {} : process.env,
+		...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 (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) {
+				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 || 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
+export { extractVariablesFromTemplates as a, extractVariablesFromTemplate as i, renderVarsInObject as n, getNunjucksEngine as o, analyzeTemplateReference as r, renderEnvOnlyInObject as t };
+
+//# sourceMappingURL=render-zarxdXS7.js.map

package/dist/src/{responses-Cf45MBI8.js → responses-B72c3dpg.js}

@@ -1,14 +1,15 @@
 import { M as getEnvFloat, N as getEnvInt, P as getEnvString, o as logger, u as isSecretField, v as sanitizeUrl } from "./logger-BKiOczgq.js";
-import { X as maybeLoadResponseFormatFromExternalFile, Z as maybeLoadToolsFromExternalFile, ct as renderVarsInObject } from "./util-DdGIEAK_.js";
-import { S as LONG_RUNNING_MODEL_TIMEOUT_MS, T as getRequestTimeoutMs, f as HttpRateLimitError, g as isAbortError, h as formatRateLimitErrorMessage, n as fetchWithRetries } from "./fetch-BjXG13jC.js";
+import { X as maybeLoadResponseFormatFromExternalFile, Z as maybeLoadToolsFromExternalFile } from "./util-BnytsHEr.js";
+import { C as LONG_RUNNING_MODEL_TIMEOUT_MS, E as getRequestTimeoutMs, _ as isAbortError, g as formatRateLimitErrorMessage, n as fetchWithRetries, p as HttpRateLimitError } from "./fetch-tOnj-VPG.js";
 import { n as sleep } from "./time-BPNW8jwJ.js";
 import { f as withGenAISpan, i as buildChatSpanContext, s as extractProviderResponseAttributes } from "./genaiTracer-Ch7k9W3C.js";
 import { n as sha256 } from "./createHash-D7vud8fe.js";
-import { c as getScopedCacheKey, i as fetchWithCache, l as isCacheEnabled, n as claimCacheKeyOnce } from "./cache-Bwj_lNIo.js";
-import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-CVbeMrg1.js";
-import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-CXk1T-EF.js";
+import { c as getScopedCacheKey, i as fetchWithCache, l as isCacheEnabled, n as claimCacheKeyOnce } from "./cache-DTOVFNqA.js";
+import { n as renderVarsInObject } from "./render-zarxdXS7.js";
+import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-DHtnWbEL.js";
+import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-BhTrP4CT.js";
 import "./tracing-Dq2SYDNR.js";
-import { t as FunctionCallbackHandler } from "./functionCallbackUtils-Ck1qbh7p.js";
+import { t as FunctionCallbackHandler } from "./functionCallbackUtils-B-fNUZ4T.js";
 import { n as OpenAiGenericProvider } from "./openai-D05D9Qqa.js";
 //#region src/providers/responses/processor.ts
 /**
@@ -1142,4 +1143,4 @@ var OpenAiResponsesProvider = class extends OpenAiGenericProvider {
 //#endregion
 export { readResponsesStream as n, ResponsesProcessor as r, OpenAiResponsesProvider as t };
 
-//# sourceMappingURL=responses-Cf45MBI8.js.map
+//# sourceMappingURL=responses-B72c3dpg.js.map

package/dist/src/{responses-CB2IgICL.js → responses-DVF5R5Il.js}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import { I as getEnvFloat, L as getEnvInt, R as getEnvString, c as logger, f as isSecretField, x as sanitizeUrl } from "./logger-YzVIwMVq.js";
-import { E as LONG_RUNNING_MODEL_TIMEOUT_MS, b as isAbortError, g as HttpRateLimitError, i as fetchWithRetries, k as getRequestTimeoutMs, y as formatRateLimitErrorMessage } from "./fetch-Bnj1JCJi.js";
+import { A as getRequestTimeoutMs, D as LONG_RUNNING_MODEL_TIMEOUT_MS, _ as HttpRateLimitError, b as formatRateLimitErrorMessage, i as fetchWithRetries, x as isAbortError } from "./fetch-KD8O9oZZ.js";
 import { n as sleep } from "./time-Ct6CnABs.js";
 import { f as withGenAISpan, i as buildChatSpanContext, s as extractProviderResponseAttributes } from "./genaiTracer-BRW5P2xD.js";
-import { B as maybeLoadResponseFormatFromExternalFile, Q as renderVarsInObject, V as maybeLoadToolsFromExternalFile } from "./util-BdAsuWmv.js";
 import { n as sha256 } from "./createHash-DqA6GWxE.js";
-import { c as getScopedCacheKey, i as fetchWithCache, l as isCacheEnabled, t as claimCacheKeyOnce } from "./cache-NhFSRGTI.js";
-import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-DtOvD10k.js";
-import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-_izMSTD8.js";
+import { i as fetchWithCache, l as getScopedCacheKey, t as claimCacheKeyOnce, u as isCacheEnabled } from "./cache-xL5UULpy.js";
+import { B as maybeLoadResponseFormatFromExternalFile, V as maybeLoadToolsFromExternalFile } from "./util-CZyLhvIk.js";
+import { n as renderVarsInObject } from "./render-BRIaR8VG.js";
+import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-DlT2H1W5.js";
+import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-D0eg28TA.js";
 import "./tracing-D7QJcXmX.js";
-import { t as FunctionCallbackHandler } from "./functionCallbackUtils-BJ2I_9tt.js";
+import { t as FunctionCallbackHandler } from "./functionCallbackUtils-B7KGl5xQ.js";
 import { n as OpenAiGenericProvider } from "./openai-2MxDZEzF.js";
 //#region src/providers/responses/processor.ts
 /**
@@ -1143,4 +1144,4 @@ var OpenAiResponsesProvider = class extends OpenAiGenericProvider {
 //#endregion
 export { readResponsesStream as n, ResponsesProcessor as r, OpenAiResponsesProvider as t };
 
-//# sourceMappingURL=responses-CB2IgICL.js.map
+//# sourceMappingURL=responses-DVF5R5Il.js.map

package/dist/src/{responses-Doa5xhY1.cjs → responses-DiZCcd1S.cjs}

@@ -1,14 +1,15 @@
 const require_logger = require("./logger-BN3n9c1R.cjs");
-const require_util = require("./util-L5T81aJ0.cjs");
-const require_fetch = require("./fetch-DTnUr1aF.cjs");
+const require_util = require("./util-BPkxeLuk.cjs");
+const require_fetch = require("./fetch-D54lzFcD.cjs");
 const require_time = require("./time-B7AqDy5g.cjs");
 const require_genaiTracer = require("./genaiTracer-D_3mCxrD.cjs");
 const require_createHash = require("./createHash-sm6Q6LWg.cjs");
-const require_cache = require("./cache-DU82DyKI.cjs");
-const require_util$1 = require("./util-CeP1x2P-.cjs");
-const require_billing = require("./billing-K5i9I9vT.cjs");
+const require_cache = require("./cache-g3VTrtsd.cjs");
+const require_render = require("./render-C1VJjFT2.cjs");
+const require_util$1 = require("./util-Cadd9fGT.cjs");
+const require_billing = require("./billing-Q1c9C5Or.cjs");
 require("./tracing-DFewlCzC.cjs");
-const require_functionCallbackUtils = require("./functionCallbackUtils-VbcI1Aub.cjs");
+const require_functionCallbackUtils = require("./functionCallbackUtils-BDroEgNs.cjs");
 const require_openai = require("./openai-D6d29SL8.cjs");
 //#region src/providers/responses/processor.ts
 /**
@@ -768,8 +769,8 @@ var OpenAiResponsesProvider = class extends require_openai.OpenAiGenericProvider
 		const maxOutputTokensDefault = config.omitDefaults ? require_logger.getEnvString("OPENAI_MAX_TOKENS") === void 0 ? void 0 : require_logger.getEnvInt("OPENAI_MAX_TOKENS") : require_logger.getEnvInt("OPENAI_MAX_TOKENS", 1024);
 		const reasoningMaxOutputTokensDefault = require_logger.getEnvInt("OPENAI_MAX_COMPLETION_TOKENS") ?? require_logger.getEnvInt("OPENAI_MAX_TOKENS");
 		const maxOutputTokens = config.max_output_tokens ?? (isReasoningModel ? reasoningMaxOutputTokensDefault : maxOutputTokensDefault);
-		const renderedReasoning = require_util.renderVarsInObject(config.reasoning, context?.vars);
-		const renderedReasoningEffort = isReasoningModel ? require_util.renderVarsInObject(config.reasoning_effort, context?.vars) : void 0;
+		const renderedReasoning = require_render.renderVarsInObject(config.reasoning, context?.vars);
+		const renderedReasoningEffort = isReasoningModel ? require_render.renderVarsInObject(config.reasoning_effort, context?.vars) : void 0;
 		const effectiveReasoningEffort = renderedReasoning?.effort ?? renderedReasoningEffort;
 		const hasAzureReasoningEffort = isAzureResponsesDeploymentWithReasoningConfig && effectiveReasoningEffort !== void 0 && effectiveReasoningEffort !== "none";
 		const temperatureDefault = config.omitDefaults ? require_logger.getEnvString("OPENAI_TEMPERATURE") === void 0 ? void 0 : require_logger.getEnvFloat("OPENAI_TEMPERATURE") : require_logger.getEnvFloat("OPENAI_TEMPERATURE", 0);
@@ -1159,4 +1160,4 @@ Object.defineProperty(exports, "readResponsesStream", {
 	}
 });
 
-//# sourceMappingURL=responses-Doa5xhY1.cjs.map
+//# sourceMappingURL=responses-DiZCcd1S.cjs.map

package/dist/src/{responses-Ci3OK0i0.js → responses-ykcvZ0oE.js}

@@ -1,14 +1,15 @@
 import { F as getEnvInt, I as getEnvString, P as getEnvFloat, o as logger, u as isSecretField, y as sanitizeUrl } from "./logger-D4ion89i.js";
-import { Et as renderVarsInObject, ft as maybeLoadResponseFormatFromExternalFile, pt as maybeLoadToolsFromExternalFile } from "./util-uYYKYi7_.js";
-import { A as getRequestTimeoutMs, D as LONG_RUNNING_MODEL_TIMEOUT_MS, _ as HttpRateLimitError, b as formatRateLimitErrorMessage, n as fetchWithRetries, x as isAbortError } from "./fetch-BdWQKDMj.js";
+import { ft as maybeLoadResponseFormatFromExternalFile, pt as maybeLoadToolsFromExternalFile } from "./util-BPtpPW4O.js";
+import { O as LONG_RUNNING_MODEL_TIMEOUT_MS, S as isAbortError, j as getRequestTimeoutMs, n as fetchWithRetries, v as HttpRateLimitError, x as formatRateLimitErrorMessage } from "./fetch-DnDg-Ics.js";
 import { n as sleep } from "./time-BPNW8jwJ.js";
 import { f as withGenAISpan, i as buildChatSpanContext, s as extractProviderResponseAttributes } from "./genaiTracer-Cp9O3qLz.js";
 import { n as sha256 } from "./createHash-D7vud8fe.js";
-import { c as getScopedCacheKey, i as fetchWithCache, l as isCacheEnabled, n as claimCacheKeyOnce } from "./cache-C41JuZ74.js";
-import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-CZ9shpIL.js";
-import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-nlGj2fi4.js";
+import { c as getScopedCacheKey, i as fetchWithCache, l as isCacheEnabled, n as claimCacheKeyOnce } from "./cache-ePPAC5hy.js";
+import { n as renderVarsInObject } from "./render-DIhuKgcQ.js";
+import { _ as hasSensitiveOpenAiCacheString, c as appendOpenAiApiPath, f as formatOpenAiError, g as hasSensitiveOpenAiCachePath, h as getTokenUsage$1, l as assertOpenAiApiModel, m as getOpenAICompletionTokenDetails } from "./util-CJi6Bgno.js";
+import { n as calculateOpenAIUsageCost, t as calculateObservableOpenAIToolCost } from "./billing-eFe0xWZw.js";
 import "./tracing-Ct2HWfTt.js";
-import { t as FunctionCallbackHandler } from "./functionCallbackUtils-BGXXxhrC.js";
+import { t as FunctionCallbackHandler } from "./functionCallbackUtils-EjWy67uz.js";
 import { n as OpenAiGenericProvider } from "./openai-lWgF8NfI.js";
 //#region src/providers/responses/processor.ts
 /**
@@ -1142,4 +1143,4 @@ var OpenAiResponsesProvider = class extends OpenAiGenericProvider {
 //#endregion
 export { readResponsesStream as n, ResponsesProcessor as r, OpenAiResponsesProvider as t };
 
-//# sourceMappingURL=responses-Ci3OK0i0.js.map
+//# sourceMappingURL=responses-ykcvZ0oE.js.map

package/dist/src/{runtimeTransform-BiANYoNE.cjs → runtimeTransform-6aaLbaUN.cjs}

@@ -1,6 +1,6 @@
 const require_logger = require("./logger-BN3n9c1R.cjs");
 const require_tokenUsageUtils = require("./tokenUsageUtils-BbqyaBi4.cjs");
-const require_remoteGeneration = require("./remoteGeneration-PxK1EefI.cjs");
+const require_remoteGeneration = require("./remoteGeneration-C0Ev99MO.cjs");
 //#region src/redteam/shared/runtimeTransform.ts
 /**
 * Runtime transform utility for applying strategy transforms per-turn.
@@ -158,4 +158,4 @@ Object.defineProperty(exports, "applyRuntimeTransforms", {
 	}
 });
 
-//# sourceMappingURL=runtimeTransform-BiANYoNE.cjs.map
+//# sourceMappingURL=runtimeTransform-6aaLbaUN.cjs.map

package/dist/src/{runtimeTransform-DCRyBnI7.js → runtimeTransform-Bf5Aif-g.js}

@@ -1,6 +1,6 @@
 import { o as logger } from "./logger-D4ion89i.js";
 import { c as accumulateTokenUsage } from "./tokenUsageUtils-T-dUB6UI.js";
-import { p as remoteGenerationContextPayload } from "./remoteGeneration-CwQ0KBdC.js";
+import { p as remoteGenerationContextPayload } from "./remoteGeneration-DGJxSMYI.js";
 //#region src/redteam/shared/runtimeTransform.ts
 /**
 * Runtime transform utility for applying strategy transforms per-turn.
@@ -153,4 +153,4 @@ async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategie
 //#endregion
 export { applyRuntimeTransforms as t };
 
-//# sourceMappingURL=runtimeTransform-DCRyBnI7.js.map
+//# sourceMappingURL=runtimeTransform-Bf5Aif-g.js.map

package/dist/src/{runtimeTransform-Dvxqdevg.js → runtimeTransform-DVpy5lDj.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { c as logger } from "./logger-YzVIwMVq.js";
 import { c as accumulateTokenUsage } from "./tokenUsageUtils-Cf6nFV6z.js";
-import { p as remoteGenerationContextPayload } from "./remoteGeneration-B0eQSIHo.js";
+import { p as remoteGenerationContextPayload } from "./remoteGeneration-Cc78LDjQ.js";
 //#region src/redteam/shared/runtimeTransform.ts
 /**
 * Runtime transform utility for applying strategy transforms per-turn.
@@ -154,4 +154,4 @@ async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategie
 //#endregion
 export { applyRuntimeTransforms as t };
 
-//# sourceMappingURL=runtimeTransform-Dvxqdevg.js.map
+//# sourceMappingURL=runtimeTransform-DVpy5lDj.js.map

package/dist/src/{runtimeTransform-PGM7l51H.js → runtimeTransform-rEgJC2VZ.js}

@@ -1,6 +1,6 @@
 import { o as logger } from "./logger-BKiOczgq.js";
 import { c as accumulateTokenUsage } from "./tokenUsageUtils-BCYRro5h.js";
-import { p as remoteGenerationContextPayload } from "./remoteGeneration-CopIeiNI.js";
+import { p as remoteGenerationContextPayload } from "./remoteGeneration-DnSGqkoH.js";
 //#region src/redteam/shared/runtimeTransform.ts
 /**
 * Runtime transform utility for applying strategy transforms per-turn.
@@ -153,4 +153,4 @@ async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategie
 //#endregion
 export { applyRuntimeTransforms as t };
 
-//# sourceMappingURL=runtimeTransform-PGM7l51H.js.map
+//# sourceMappingURL=runtimeTransform-rEgJC2VZ.js.map

package/dist/src/{sagemaker-D8O3f2bO.js → sagemaker-BzAkO4HL.js}

@@ -2,7 +2,7 @@ import { n as StringOrFunctionSchema } from "./shared-BED4JRhV.js";
 import { M as getEnvFloat, N as getEnvInt, P as getEnvString, o as logger } from "./logger-BKiOczgq.js";
 import "./fileExtensions-ISrPd1Hs.js";
 import { i as getTransformErrorMessage, o as transform, r as TransformInputType } from "./transform-Ccf_EBqd.js";
-import { t as telemetry } from "./telemetry-CIaL2pmn.js";
+import { t as telemetry } from "./telemetry-CJdYAcRk.js";
 import { z as z$1 } from "zod";
 import crypto from "crypto";
 //#region src/providers/sagemaker.ts
@@ -409,7 +409,7 @@ var SageMakerCompletionProvider = class extends SageMakerGenericProvider {
 	* Invoke SageMaker endpoint for text generation with caching, delay support, and transformations
 	*/
 	async callApi(prompt, context, _options) {
-		const { isCacheEnabled, getCache } = await import("./cache-Bwj_lNIo.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-DTOVFNqA.js").then((n) => n.t);
 		const delayMs = context?.originalProvider?.delay || this.delay;
 		const transformResult = await this.runTransformSafely(prompt, context, "SageMaker transform error");
 		if (!transformResult.ok) return { error: transformResult.error };
@@ -423,7 +423,7 @@ var SageMakerCompletionProvider = class extends SageMakerGenericProvider {
 		const bustCache = context?.bustCache ?? context?.debug === true;
 		if (isCacheEnabled() && !bustCache) {
 			const cacheKey = this.getCacheKey(transformedPrompt);
-			const cachedResult = await (getCache ? getCache() : await import("./cache-Bwj_lNIo.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
+			const cachedResult = await (getCache ? getCache() : await import("./cache-DTOVFNqA.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
 			if (cachedResult) {
 				logger.debug(`Using cached SageMaker response for ${this.getEndpointName()}`);
 				try {
@@ -497,7 +497,7 @@ var SageMakerCompletionProvider = class extends SageMakerGenericProvider {
 			};
 			if (isCacheEnabled() && !bustCache && result.output && !result.error) {
 				const cacheKey = this.getCacheKey(transformedPrompt);
-				const cache = getCache ? getCache() : await import("./cache-Bwj_lNIo.js").then((n) => n.t).then((m) => m.getCache());
+				const cache = getCache ? getCache() : await import("./cache-DTOVFNqA.js").then((n) => n.t).then((m) => m.getCache());
 				const resultToCache = JSON.stringify(result);
 				try {
 					await cache.set(cacheKey, resultToCache);
@@ -542,7 +542,7 @@ var SageMakerEmbeddingProvider = class extends SageMakerGenericProvider {
 	* Invoke SageMaker endpoint for embeddings with caching, delay support, and transformations
 	*/
 	async callEmbeddingApi(text, context) {
-		const { isCacheEnabled, getCache } = await import("./cache-Bwj_lNIo.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-DTOVFNqA.js").then((n) => n.t);
 		const delayMs = context?.originalProvider?.delay || this.delay;
 		const transformResult = await this.runTransformSafely(text, context, "SageMaker embedding transform error");
 		if (!transformResult.ok) return { error: transformResult.error };
@@ -556,7 +556,7 @@ var SageMakerEmbeddingProvider = class extends SageMakerGenericProvider {
 		const bustCache = context?.debug === true;
 		if (isCacheEnabled() && !bustCache) {
 			const cacheKey = this.getCacheKey(transformedText);
-			const cachedResult = await (await getCache ? await getCache() : await import("./cache-Bwj_lNIo.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
+			const cachedResult = await (await getCache ? await getCache() : await import("./cache-DTOVFNqA.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
 			if (cachedResult) {
 				logger.debug(`Using cached SageMaker embedding response for ${this.getEndpointName()}`);
 				try {
@@ -668,11 +668,11 @@ var SageMakerEmbeddingProvider = class extends SageMakerGenericProvider {
 	* Helper method to cache embedding results
 	*/
 	async cacheEmbeddingResult(result, text, context, isTransformed = false, originalText) {
-		const { isCacheEnabled, getCache } = await import("./cache-Bwj_lNIo.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-DTOVFNqA.js").then((n) => n.t);
 		const bustCache = context?.debug === true;
 		if (isCacheEnabled() && !bustCache && result.embedding && !result.error) {
 			const cacheKey = this.getCacheKey(text);
-			const cache = await getCache ? await getCache() : await import("./cache-Bwj_lNIo.js").then((n) => n.t).then((m) => m.getCache());
+			const cache = await getCache ? await getCache() : await import("./cache-DTOVFNqA.js").then((n) => n.t).then((m) => m.getCache());
 			if (isTransformed && originalText && !result.metadata) result.metadata = {
 				transformed: true,
 				originalText
@@ -694,4 +694,4 @@ var SageMakerEmbeddingProvider = class extends SageMakerGenericProvider {
 //#endregion
 export { SageMakerCompletionProvider, SageMakerEmbeddingProvider };
 
-//# sourceMappingURL=sagemaker-D8O3f2bO.js.map
+//# sourceMappingURL=sagemaker-BzAkO4HL.js.map