promptfoo 0.121.4 → 0.121.7

package/dist/src/tracingOptions-ji2OuXbT.js

@@ -0,0 +1,220 @@
+import { a as logger, k as state } from "./logger-Ct2S6Yx-.js";
+import { l as sleep } from "./fetch-It34O8Ur.js";
+import { t as getTraceStore } from "./store-HpopRVzl.js";
+import { r as getToolNameFromAttributes } from "./toolAttributes-DJ9ZEKXD.js";
+//#region src/tracing/traceContext.ts
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 500;
+const SPAN_KIND_MAP = {
+	0: "unspecified",
+	1: "internal",
+	2: "server",
+	3: "client",
+	4: "producer",
+	5: "consumer"
+};
+function resolveSpanKind(span) {
+	const attributes = span.attributes || {};
+	const attributeKind = attributes["span.kind"] || attributes["otel.span.kind"] || attributes["spanKind"] || attributes["kind"];
+	if (attributeKind) return `${attributeKind}`.toLowerCase();
+	const numericKind = attributes["otel.span.kind_code"];
+	if (typeof numericKind === "number" && numericKind in SPAN_KIND_MAP) return SPAN_KIND_MAP[numericKind];
+	return "unspecified";
+}
+function mapStatusCode(span) {
+	switch (span.statusCode) {
+		case 1: return "ok";
+		case 2: return "error";
+		default: return "unset";
+	}
+}
+function buildSpanTree(spans) {
+	const depthMap = /* @__PURE__ */ new Map();
+	const spansById = new Map(spans.map((span) => [span.spanId, span]));
+	const computeDepth = (span) => {
+		if (depthMap.has(span.spanId)) return depthMap.get(span.spanId);
+		if (!span.parentSpanId || !spansById.has(span.parentSpanId)) {
+			depthMap.set(span.spanId, 0);
+			return 0;
+		}
+		const depth = computeDepth(spansById.get(span.parentSpanId)) + 1;
+		depthMap.set(span.spanId, depth);
+		return depth;
+	};
+	spans.forEach((span) => computeDepth(span));
+	return depthMap;
+}
+function createTraceSpans(spans) {
+	const depthMap = buildSpanTree(spans);
+	return spans.map((span) => {
+		const endTime = span.endTime ?? span.startTime;
+		const durationMs = Math.max(0, endTime - span.startTime);
+		return {
+			spanId: span.spanId,
+			parentSpanId: span.parentSpanId,
+			name: span.name,
+			kind: resolveSpanKind(span),
+			startTime: span.startTime,
+			endTime: span.endTime,
+			durationMs,
+			attributes: span.attributes || {},
+			status: {
+				code: mapStatusCode(span),
+				message: span.statusMessage
+			},
+			depth: depthMap.get(span.spanId) ?? 0,
+			events: []
+		};
+	});
+}
+function deriveInsights(traceSpans) {
+	if (traceSpans.length === 0) return [];
+	const insights = [];
+	traceSpans.filter((span) => span.status.code === "error").forEach((span) => {
+		const statusMessage = span.status.message ? `: ${span.status.message}` : "";
+		insights.push(`Error span "${span.name}" (${span.spanId.slice(0, 8)})${statusMessage}`);
+	});
+	traceSpans.map((span) => ({
+		span,
+		toolName: getToolNameFromAttributes(span.attributes)
+	})).filter((entry) => entry.toolName).forEach(({ span, toolName }) => {
+		insights.push(`Tool call ${toolName} via "${span.name}" (duration ${span.durationMs ?? 0}ms)`);
+	});
+	traceSpans.filter((span) => span.attributes["guardrail.name"] || span.attributes["guardrails.decision"]).forEach((span) => {
+		const decision = span.attributes["guardrails.decision"] ?? span.attributes["guardrail.decision"];
+		insights.push(`Guardrail ${span.attributes["guardrail.name"] ?? span.name} decision: ${decision ?? "unknown"}`);
+	});
+	return insights.slice(0, 20);
+}
+function extractTraceIdFromTraceparent(traceparent) {
+	if (!traceparent) return null;
+	const parts = traceparent.split("-");
+	if (parts.length < 2) return null;
+	return parts[1];
+}
+async function fetchTraceContext(traceId, options = {}) {
+	const { includeInternalSpans = true, sanitizeAttributes = true, maxRetries = DEFAULT_MAX_RETRIES, retryDelayMs = DEFAULT_RETRY_DELAY_MS, ...spanOptions } = options;
+	const traceStore = getTraceStore();
+	for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+		const spans = await traceStore.getSpans(traceId, {
+			includeInternalSpans,
+			sanitizeAttributes,
+			...spanOptions
+		});
+		if (spans.length === 0) {
+			if (attempt === maxRetries) {
+				logger.debug(`[TraceContext] No spans found for trace ${traceId} after ${attempt + 1} attempts`);
+				return null;
+			}
+			logger.debug(`[TraceContext] No spans yet for trace ${traceId}, retrying in ${retryDelayMs}ms (attempt ${attempt + 1}/${maxRetries})`);
+			await sleep(retryDelayMs);
+			continue;
+		}
+		const traceSpans = createTraceSpans(spans);
+		const insights = deriveInsights(traceSpans);
+		const context = {
+			traceId,
+			spans: traceSpans,
+			insights,
+			fetchedAt: Date.now()
+		};
+		logger.debug(`[TraceContext] Resolved ${traceSpans.length} spans for trace ${traceId} with ${insights.length} insights`);
+		return context;
+	} catch (error) {
+		logger.error(`[TraceContext] Failed to fetch spans for trace ${traceId}: ${error}`);
+		if (attempt === maxRetries) return null;
+		await sleep(retryDelayMs);
+	}
+	return null;
+}
+//#endregion
+//#region src/redteam/providers/traceFormatting.ts
+const DEFAULT_MAX_SPANS = 10;
+function formatDuration(durationMs) {
+	if (!durationMs || Number.isNaN(durationMs)) return "0ms";
+	if (durationMs < 1e3) return `${Math.round(durationMs)}ms`;
+	if (durationMs < 6e4) return `${(durationMs / 1e3).toFixed(1)}s`;
+	return `${(durationMs / 6e4).toFixed(1)}m`;
+}
+function formatSpan(span) {
+	const parts = [];
+	const duration = formatDuration(span.durationMs);
+	parts.push(`[${duration}] ${span.name}${span.kind && span.kind !== "unspecified" ? ` (${span.kind})` : ""}`);
+	const tool = getToolNameFromAttributes(span.attributes);
+	if (tool) parts.push(`tool=${tool}`);
+	const model = span.attributes["model"] || span.attributes["llm.model"];
+	if (model) parts.push(`model=${model}`);
+	if (span.status.code === "error") parts.push(`ERROR: ${span.status.message ?? "Unknown error"}`);
+	return parts.join(" | ");
+}
+function formatTraceSummary(trace, options = {}) {
+	if (!trace || trace.spans.length === 0) return "No trace spans recorded during this iteration.";
+	const maxSpans = options.maxSpans ?? DEFAULT_MAX_SPANS;
+	const spans = trace.spans.slice(0, maxSpans);
+	return [
+		`Trace ${trace.traceId.slice(0, 8)} • ${trace.spans.length} span${trace.spans.length === 1 ? "" : "s"}`,
+		"",
+		"Execution Flow:",
+		spans.map((span, index) => `${index + 1}. ${formatSpan(span)}`).join("\n"),
+		"",
+		"Key Observations:",
+		trace.insights.length > 0 ? trace.insights.map((i) => `• ${i}`).join("\n") : "None"
+	].join("\n");
+}
+function formatTraceForMetadata(trace) {
+	return {
+		traceId: trace.traceId,
+		fetchedAt: trace.fetchedAt,
+		spanCount: trace.spans.length,
+		insights: trace.insights
+	};
+}
+//#endregion
+//#region src/redteam/providers/tracingOptions.ts
+const DEFAULT_TRACING_OPTIONS = {
+	enabled: false,
+	includeInAttack: true,
+	includeInGrading: true,
+	includeInternalSpans: false,
+	maxSpans: 50,
+	maxDepth: 5,
+	maxRetries: 3,
+	retryDelayMs: 500,
+	spanFilter: void 0,
+	sanitizeAttributes: true
+};
+function mergeTracingConfig(...configs) {
+	return configs.reduce((acc, config) => config ? {
+		...acc,
+		...config
+	} : acc, {});
+}
+function normalizeTracingOptions(config) {
+	const merged = {
+		...DEFAULT_TRACING_OPTIONS,
+		...config
+	};
+	return {
+		enabled: Boolean(merged.enabled),
+		includeInAttack: merged.includeInAttack ?? DEFAULT_TRACING_OPTIONS.includeInAttack ?? true,
+		includeInGrading: merged.includeInGrading ?? DEFAULT_TRACING_OPTIONS.includeInGrading ?? true,
+		includeInternalSpans: merged.includeInternalSpans ?? DEFAULT_TRACING_OPTIONS.includeInternalSpans ?? false,
+		maxSpans: merged.maxSpans ?? DEFAULT_TRACING_OPTIONS.maxSpans,
+		maxDepth: merged.maxDepth ?? DEFAULT_TRACING_OPTIONS.maxDepth,
+		maxRetries: merged.maxRetries ?? DEFAULT_TRACING_OPTIONS.maxRetries,
+		retryDelayMs: merged.retryDelayMs ?? DEFAULT_TRACING_OPTIONS.retryDelayMs,
+		spanFilter: merged.spanFilter,
+		sanitizeAttributes: merged.sanitizeAttributes ?? DEFAULT_TRACING_OPTIONS.sanitizeAttributes
+	};
+}
+function resolveTracingOptions({ strategyId, test, config }) {
+	const globalConfig = state.config?.redteam?.tracing ?? void 0;
+	const testConfig = test?.metadata?.tracing ?? void 0;
+	const metadataStrategyConfig = (test?.metadata?.strategyConfig)?.tracing;
+	const providerStrategyConfig = config?.tracing ?? void 0;
+	return normalizeTracingOptions(mergeTracingConfig(globalConfig, testConfig, metadataStrategyConfig, providerStrategyConfig, strategyId && globalConfig?.strategies ? globalConfig.strategies[strategyId] : void 0, strategyId && testConfig?.strategies ? testConfig.strategies[strategyId] : void 0, strategyId && metadataStrategyConfig?.strategies ? metadataStrategyConfig.strategies[strategyId] : void 0, strategyId && providerStrategyConfig?.strategies ? providerStrategyConfig.strategies[strategyId] : void 0));
+}
+//#endregion
+export { fetchTraceContext as a, extractTraceIdFromTraceparent as i, formatTraceForMetadata as n, formatTraceSummary as r, resolveTracingOptions as t };
+
+//# sourceMappingURL=tracingOptions-ji2OuXbT.js.map

package/dist/src/{transcription-DuWDupG7.js → transcription-B8uIgCYX.js}

@@ -1,8 +1,8 @@
 import { a as logger } from "./logger-Ct2S6Yx-.js";
-import { h as REQUEST_TIMEOUT_MS } from "./fetch-Di00EQrc.js";
-import { r as fetchWithCache } from "./cache-D5NZmMiT.js";
-import { t as OpenAiGenericProvider } from "./openai-iYtrXzOX.js";
-import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-D9TisOyk.js";
+import { p as REQUEST_TIMEOUT_MS } from "./fetch-It34O8Ur.js";
+import { r as fetchWithCache } from "./cache-DIXbtkNO.js";
+import { t as OpenAiGenericProvider } from "./openai-zgwBb4Ff.js";
+import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-LKTmNsMQ.js";
 import fs from "fs";
 import path from "path";
 //#region src/providers/openai/transcription.ts
@@ -119,4 +119,4 @@ var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends Open
 //#endregion
 export { OpenAiTranscriptionProvider };
 
-//# sourceMappingURL=transcription-DuWDupG7.js.map
+//# sourceMappingURL=transcription-B8uIgCYX.js.map

package/dist/src/{transcription-CJspiD2c.js → transcription-CfU5loSq.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { s as logger } from "./logger-DksKw1Qc.js";
-import { m as REQUEST_TIMEOUT_MS } from "./fetch-BEWnXrrG.js";
-import { a as fetchWithCache } from "./cache-mb7c8hbp.js";
-import { t as OpenAiGenericProvider } from "./openai-Qsvz25mV.js";
-import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-C9J8ahRn.js";
+import { s as logger } from "./logger-BbY6ypFL.js";
+import { _ as REQUEST_TIMEOUT_MS } from "./fetch-DXUnXkVU.js";
+import { a as fetchWithCache } from "./cache-DpPWrkTE.js";
+import { t as OpenAiGenericProvider } from "./openai-CJrsh9n4.js";
+import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-5WnCSb0h.js";
 import fs from "fs";
 import path from "path";
 //#region src/providers/openai/transcription.ts
@@ -120,4 +120,4 @@ var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends Open
 //#endregion
 export { OpenAiTranscriptionProvider };
 
-//# sourceMappingURL=transcription-CJspiD2c.js.map
+//# sourceMappingURL=transcription-CfU5loSq.js.map

package/dist/src/{transcription-V2HaAmy2.js → transcription-Dkd22_4K.js}

@@ -1,8 +1,8 @@
-import { a as logger } from "./logger-B88EkIn6.js";
-import { h as REQUEST_TIMEOUT_MS } from "./fetch-B0Z3Oe4k.js";
-import { r as fetchWithCache } from "./cache-C4Xb-hNb.js";
-import { t as OpenAiGenericProvider } from "./openai-DhVEmgeZ.js";
-import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-D3q0WQ-0.js";
+import { a as logger } from "./logger-KD8JjCRJ.js";
+import { v as REQUEST_TIMEOUT_MS } from "./fetch-BufrQtvR.js";
+import { r as fetchWithCache } from "./cache-roFAE0cI.js";
+import { t as OpenAiGenericProvider } from "./openai-BMHD2Huo.js";
+import { i as OPENAI_TRANSCRIPTION_MODELS } from "./util-efByNxcr.js";
 import fs from "fs";
 import path from "path";
 //#region src/providers/openai/transcription.ts
@@ -119,4 +119,4 @@ var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends Open
 //#endregion
 export { OpenAiTranscriptionProvider };
 
-//# sourceMappingURL=transcription-V2HaAmy2.js.map
+//# sourceMappingURL=transcription-Dkd22_4K.js.map

package/dist/src/{transcription-BvjmiYB1.cjs → transcription-mzuf18Mq.cjs}

@@ -1,12 +1,13 @@
-const require_logger = require("./logger-COuQb2xB.cjs");
-const require_fetch = require("./fetch-CJU5ELPa.cjs");
-const require_cache = require("./cache-BIyPcp5v.cjs");
-const require_openai = require("./openai-URNyItar.cjs");
-const require_util = require("./util-CN3SrLT4.cjs");
+const require_rolldown_runtime = require("./rolldown-runtime-D_mwlA32.cjs");
+const require_logger = require("./logger-cfNpzI4o.cjs");
+const require_fetch = require("./fetch-Dw4XZHjj.cjs");
+const require_cache = require("./cache-CPGUA4Yl.cjs");
+const require_openai = require("./openai-C3uXv8wS.cjs");
+const require_util = require("./util-BSIuSLVK.cjs");
 let fs = require("fs");
-fs = require_logger.__toESM(fs);
+fs = require_rolldown_runtime.__toESM(fs, 1);
 let path = require("path");
-path = require_logger.__toESM(path);
+path = require_rolldown_runtime.__toESM(path, 1);
 //#region src/providers/openai/transcription.ts
 var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends require_openai.OpenAiGenericProvider {
 	static OPENAI_TRANSCRIPTION_MODEL_NAMES = require_util.OPENAI_TRANSCRIPTION_MODELS.map((model) => model.id);
@@ -121,4 +122,4 @@ var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends requ
 //#endregion
 exports.OpenAiTranscriptionProvider = OpenAiTranscriptionProvider;
 
-//# sourceMappingURL=transcription-BvjmiYB1.cjs.map
+//# sourceMappingURL=transcription-mzuf18Mq.cjs.map

package/dist/src/{transform-lQrDE1BQ.js → transform-BIMynQsA.js}

@@ -1,7 +1,7 @@
-import { T as getEnvString, a as logger, g as getAjv } from "./logger-B88EkIn6.js";
-import { S as parseChatPrompt, g as calculateCost, t as fetchWithProxy } from "./fetch-B0Z3Oe4k.js";
-import { a as getNunjucksEngine, n as renderVarsInObject } from "./render-DHIZ6_k8.js";
-import { T as maybeLoadFromExternalFile } from "./util-C8e5uydV.js";
+import { T as getEnvString, a as logger, g as getAjv } from "./logger-KD8JjCRJ.js";
+import { T as parseChatPrompt, t as fetchWithProxy, y as calculateCost } from "./fetch-BufrQtvR.js";
+import { n as renderVarsInObject, o as getNunjucksEngine } from "./render-_6ur1fhE.js";
+import { j as maybeLoadFromExternalFile } from "./util-I-Rf-KaD.js";
 import { z } from "zod";
 import crypto from "crypto";
 import Clone from "rfdc";
@@ -912,13 +912,13 @@ function calculateGoogleCost(modelName, config, promptTokens, completionTokens,
 	const model = GOOGLE_MODELS.find((m) => m.id === modelName);
 	if (promptTokens != null && completionTokens != null) {
 		if (model?.tieredCost && promptTokens > model.tieredCost.threshold) {
-			const inputCost = config.cost ?? model.tieredCost.above.input;
-			const outputCost = config.cost ?? model.tieredCost.above.output;
+			const inputCost = config.inputCost ?? config.cost ?? model.tieredCost.above.input;
+			const outputCost = config.outputCost ?? config.cost ?? model.tieredCost.above.output;
 			return inputCost * promptTokens + outputCost * completionTokens;
 		}
 		if (isVertexMode && model?.vertexCost) {
-			const inputCost = config.cost ?? model.vertexCost.input;
-			const outputCost = config.cost ?? model.vertexCost.output;
+			const inputCost = config.inputCost ?? config.cost ?? model.vertexCost.input;
+			const outputCost = config.outputCost ?? config.cost ?? model.vertexCost.output;
 			return inputCost * promptTokens + outputCost * completionTokens;
 		}
 	}
@@ -1507,4 +1507,4 @@ async function transformMCPServerConfigToClaudeCode(config) {
 //#endregion
 export { renderAuthVars as A, resolveProjectId as C, getAuthHeaders as D, applyQueryParams as E, getAuthQueryParams as O, loadCredentials as S, toDataUri as T, GoogleAuthManager as _, calculateGoogleCost as a, getGoogleClient as b, geminiFormatAndSystemInstructions as c, mergeParts as d, normalizeSafetySettings as f, CHAT_MODELS as g, validateFunctionCall as h, transformMCPToolsToOpenAi as i, TOKEN_REFRESH_BUFFER_MS as j, getOAuthTokenWithExpiry as k, getCandidate as l, parseConfigSystemInstruction as m, transformMCPToolsToAnthropic as n, createAuthCacheDiscriminator as o, normalizeTools as p, transformMCPToolsToGoogle as r, formatCandidateContents as s, transformMCPConfigToClaudeCode as t, getGoogleAccessToken as u, determineGoogleVertexMode as v, parseDataUrl as w, hasGoogleDefaultCredentials as x, getGoogleApiKey as y };
 
-//# sourceMappingURL=transform-lQrDE1BQ.js.map
+//# sourceMappingURL=transform-BIMynQsA.js.map

package/dist/src/transform-BnSTnFlp.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { N as state, s as logger } from "./logger-BbY6ypFL.js";
+import { i as isJavascriptFile } from "./fileExtensions-D4GCJ67J.js";
+import { a as safeJoin, r as importModule } from "./esm-Bexx2PFc.js";
+import { r as runPython } from "./pythonUtils-CgYxeSmO.js";
+import { t as getProcessShim } from "./processShim-BBxt7LKO.js";
+//#region src/util/transform.ts
+const INLINE_FUNCTION_LABEL = "[inline function]";
+const INLINE_STRING_LABEL = "[inline transform]";
+const FILE_TRANSFORM_LABEL = "[file transform]";
+/** Error labels truncate inline string transforms past this length so they stay readable in logs. */
+const INLINE_STRING_LABEL_MAX_LENGTH = 80;
+/**
+* Every config field that accepts a `StringOrFunctionSchema`. Shared between the
+* runtime sanitizer in `src/index.ts` (which replaces function values with
+* markers before persistence) and `scripts/generateJsonSchema.ts` (which rewrites
+* these fields to string-only in the generated JSON schema).
+*/
+const TRANSFORM_KEYS = [
+	"transform",
+	"transformVars",
+	"contextTransform",
+	"postprocess"
+];
+/**
+* Unwraps `transform()`'s `Transform failed (label): ...` wrapper and returns
+* the underlying message. Callers that add their own label wrapper (e.g.
+* `contextUtils.resolveContext`, SageMaker's error response) use this to avoid
+* stuttering two labels in the user-facing message.
+*/
+function getTransformErrorMessage(error) {
+	const cause = error?.cause;
+	const raw = error instanceof Error && cause instanceof Error ? cause : error;
+	return raw instanceof Error ? raw.message : String(raw);
+}
+const TransformInputType = {
+	OUTPUT: "output",
+	VARS: "vars"
+};
+/**
+* Parses a file path string to extract the file path and function name.
+* Handles Windows drive letters (e.g., C:\path\to\file.js:functionName).
+* @param filePath - The file path string, potentially including a function name.
+* @returns A tuple containing the file path and function name (if present).
+*/
+function parseFilePathAndFunctionName(filePath) {
+	const lastColonIndex = filePath.lastIndexOf(":");
+	if (lastColonIndex > 1) return [filePath.slice(0, lastColonIndex), filePath.slice(lastColonIndex + 1)];
+	return [filePath, void 0];
+}
+/**
+* Retrieves a JavaScript transform function from a file.
+* @param filePath - The path to the JavaScript file.
+* @param functionName - Optional name of the function to retrieve.
+* @returns A Promise resolving to the requested function.
+* @throws Error if the file doesn't export a valid function.
+*/
+async function getJavascriptTransformFunction(filePath, functionName) {
+	const requiredModule = await importModule(filePath);
+	if (functionName && Object.prototype.hasOwnProperty.call(requiredModule, functionName) && typeof requiredModule[functionName] === "function") return requiredModule[functionName];
+	else if (typeof requiredModule === "function") return requiredModule;
+	else if (requiredModule.default && typeof requiredModule.default === "function") return requiredModule.default;
+	throw new Error(`Transform ${filePath} must export a function, have a default export as a function, or export the specified function "${functionName}"`);
+}
+/**
+* Creates a function that runs a Python transform function.
+* @param filePath - The path to the Python file.
+* @param functionName - The name of the function to run (defaults to 'get_transform').
+* @returns A function that executes the Python transform.
+*/
+function getPythonTransformFunction(filePath, functionName = "get_transform") {
+	return async (output, context) => {
+		return runPython(filePath, functionName, [output, context]);
+	};
+}
+/**
+* Retrieves a transform function from a file, supporting both JavaScript and Python.
+* @param filePath - The path to the file, including the 'file://' prefix.
+* @returns A Promise resolving to the requested function.
+* @throws Error if the file format is unsupported.
+*/
+async function getFileTransformFunction(filePath) {
+	const [actualFilePath, functionName] = parseFilePathAndFunctionName(filePath.slice(7));
+	const fullPath = safeJoin(state.basePath || "", actualFilePath);
+	if (isJavascriptFile(fullPath)) return getJavascriptTransformFunction(fullPath, functionName);
+	else if (fullPath.endsWith(".py")) return getPythonTransformFunction(fullPath, functionName);
+	throw new Error(`Unsupported transform file format: file://${actualFilePath}`);
+}
+/**
+* Creates a function from inline JavaScript code.
+* @param code - The JavaScript code to convert into a function.
+* @returns A Function created from the provided code.
+*
+* The function receives three parameters:
+* - The input (output or vars depending on inputType)
+* - A context object
+* - A process object with mainModule.require shimmed for backwards compatibility
+*
+* To use require in inline transforms, use: process.mainModule.require('module-name')
+* Or assign it to a variable: const require = process.mainModule.require;
+*/
+function getInlineTransformFunction(code, inputType) {
+	return new Function(inputType, "context", "process", code.includes("\n") ? code : `return ${code}`);
+}
+/**
+* Determines and retrieves the appropriate transform function based on the input.
+* @param codeOrFilepath - Either inline code or a file path starting with 'file://'.
+* @returns A Promise resolving to the appropriate transform function.
+*/
+async function getTransformFunction(codeOrFilepath, inputType) {
+	if (codeOrFilepath.startsWith("file://")) try {
+		return await getFileTransformFunction(codeOrFilepath);
+	} catch (error) {
+		logger.error("Error loading transform function from file", {
+			error,
+			message: error instanceof Error ? error.message : String(error),
+			transform: getTransformLabel(codeOrFilepath)
+		});
+		throw error;
+	}
+	else try {
+		return getInlineTransformFunction(codeOrFilepath, inputType);
+	} catch (error) {
+		logger.error("Error creating inline transform function", {
+			error,
+			message: error instanceof Error ? error.message : String(error),
+			transform: getTransformLabel(codeOrFilepath)
+		});
+		throw error;
+	}
+}
+/**
+* Returns a human-readable label for a transform value, suitable for error messages.
+*
+* Inline string transforms are shown verbatim (single-line, truncated to
+* {@link INLINE_STRING_LABEL_MAX_LENGTH}) so users can see which expression failed.
+* Inline functions are shown by name only — their source is never rendered, to avoid
+* leaking implementation details via `Function.toString()` into logs and persisted errors.
+*/
+function getTransformLabel(t) {
+	if (t == null) return INLINE_STRING_LABEL;
+	if (typeof t === "function") return t.name ? `${INLINE_FUNCTION_LABEL}: ${t.name}` : INLINE_FUNCTION_LABEL;
+	if (t.startsWith("file://")) return FILE_TRANSFORM_LABEL;
+	const singleLine = t.replace(/\s+/g, " ").trim();
+	return `${INLINE_STRING_LABEL}: ${singleLine.length > INLINE_STRING_LABEL_MAX_LENGTH ? `${singleLine.slice(0, INLINE_STRING_LABEL_MAX_LENGTH - 1)}…` : singleLine}`;
+}
+/**
+* Transforms the output using a specified function, inline code, or file reference.
+*
+* @param codeOrFilepathOrFn - A TransformFunction, inline JavaScript code, or a file path
+* starting with 'file://'. File paths can include a function name
+* (e.g., 'file://transform.js:myFunction'). Python files default to 'get_transform'.
+* @param transformInput - The input to transform. Can be a string, object, or undefined.
+* @param context - Context object passed to the transform function (vars, prompt, metadata).
+* @param validateReturn - If true (default), throws when the transform returns null/undefined.
+* @param inputType - Whether the first parameter is named 'output' or 'vars' in inline code.
+* @returns A promise that resolves to the transformed output.
+* @throws When the transform is unloadable, throws, or (with `validateReturn`) returns null/undefined.
+*/
+async function transform(codeOrFilepathOrFn, transformInput, context, validateReturn = true, inputType = TransformInputType.OUTPUT) {
+	const isDirectFunction = typeof codeOrFilepathOrFn === "function";
+	const transformFn = isDirectFunction ? codeOrFilepathOrFn : await getTransformFunction(codeOrFilepathOrFn, inputType);
+	let ret;
+	try {
+		ret = isDirectFunction ? await Promise.resolve(transformFn(transformInput, context)) : await Promise.resolve(transformFn(transformInput, context, getProcessShim()));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const label = getTransformLabel(codeOrFilepathOrFn);
+		logger.error("Error in transform function", {
+			error,
+			message,
+			transform: label
+		});
+		if (error instanceof Error) {
+			const wrapped = /* @__PURE__ */ new Error(`Transform failed (${label}): ${message}`);
+			wrapped.cause = error;
+			throw wrapped;
+		}
+		throw error;
+	}
+	if (validateReturn && (ret === null || ret === void 0)) throw new Error(`Transform function did not return a value\n\n${getTransformLabel(codeOrFilepathOrFn)}`);
+	return ret;
+}
+//#endregion
+export { getTransformLabel as a, getTransformErrorMessage as i, TRANSFORM_KEYS as n, transform as o, TransformInputType as r, INLINE_FUNCTION_LABEL as t };
+
+//# sourceMappingURL=transform-BnSTnFlp.js.map