promptfoo 0.121.4 → 0.121.7

package/dist/src/runtimeTransform-Dgh_D7DU.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { s as logger } from "./logger-BbY6ypFL.js";
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+export { applyRuntimeTransforms as t };
+
+//# sourceMappingURL=runtimeTransform-Dgh_D7DU.js.map

package/dist/src/runtimeTransform-DigbjU1r.js

@@ -0,0 +1,142 @@
+import { a as logger } from "./logger-Ct2S6Yx-.js";
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+export { applyRuntimeTransforms as t };
+
+//# sourceMappingURL=runtimeTransform-DigbjU1r.js.map

package/dist/src/runtimeTransform-ON3YYILw.cjs

@@ -0,0 +1,147 @@
+const require_logger = require("./logger-cfNpzI4o.cjs");
+//#region src/redteam/shared/runtimeTransform.ts
+/**
+* Runtime transform utility for applying strategy transforms per-turn.
+*
+* This module enables multi-turn attack providers (Hydra, Crescendo, etc.)
+* to apply layer transforms (audio, base64, etc.) to each turn's prompt
+* before sending to the target.
+*
+* It reuses existing strategy implementations, avoiding code duplication.
+*/
+/**
+* Applies strategy transforms to a prompt at runtime (per-turn).
+* This is used by multi-turn attack providers to transform each turn's
+* output before sending to the target.
+*
+* @param prompt - The text prompt to transform
+* @param injectVar - The variable name used for injection (e.g., 'query')
+* @param layerConfigs - Array of layer configurations to apply in order
+* @param strategies - The loaded strategies array (to avoid circular imports)
+* @param context - Optional context metadata to pass to layer strategies
+* @returns TransformResult with transformed prompt and audio metadata
+*
+* @example
+* ```typescript
+* // In Hydra provider:
+* const result = await applyRuntimeTransforms(
+*   attackPrompt,
+*   'query',
+*   ['audio', 'base64'],
+*   Strategies,
+*   { evaluationId: context?.evaluationId, purpose: context?.test?.metadata?.purpose }
+* );
+* // result.prompt = transformed, result.audio = { data, format } if audio
+* ```
+*/
+async function applyRuntimeTransforms(prompt, injectVar, layerConfigs, strategies, context) {
+	const originalPrompt = prompt;
+	if (!layerConfigs?.length) return {
+		prompt,
+		originalPrompt
+	};
+	require_logger.logger.debug(`[RuntimeTransform] Applying ${layerConfigs.length} transforms to prompt`, {
+		hasContext: !!context,
+		hasEvaluationId: !!context?.evaluationId,
+		hasPurpose: !!context?.purpose
+	});
+	let testCase = {
+		vars: { [injectVar]: prompt },
+		assert: [],
+		metadata: {
+			pluginId: "runtime-transform",
+			evaluationId: context?.evaluationId,
+			testCaseId: context?.testCaseId,
+			purpose: context?.purpose,
+			goal: context?.goal
+		}
+	};
+	let audioApplied = false;
+	let imageApplied = false;
+	for (const layer of layerConfigs) {
+		const layerId = typeof layer === "string" ? layer : layer.id;
+		const layerConfig = typeof layer === "string" ? {} : layer.config || {};
+		const strategy = strategies.find((s) => s.id === layerId);
+		if (!strategy) {
+			require_logger.logger.warn(`[RuntimeTransform] Unknown layer strategy: ${layerId}, skipping`);
+			continue;
+		}
+		require_logger.logger.debug(`[RuntimeTransform] Applying layer: ${layerId}`);
+		if (layerId === "audio") audioApplied = true;
+		else if (layerId === "image") imageApplied = true;
+		try {
+			const transformed = (await strategy.action([testCase], injectVar, layerConfig))[0];
+			if (transformed) testCase = {
+				...transformed,
+				metadata: {
+					...testCase.metadata,
+					...transformed.metadata,
+					pluginId: testCase.metadata.pluginId
+				}
+			};
+			else require_logger.logger.warn(`[RuntimeTransform] Layer ${layerId} returned no test cases`);
+		} catch (error) {
+			const errorMsg = `Transform ${layerId} failed: ${error.message || "Unknown error"}`;
+			require_logger.logger.error(`[RuntimeTransform] ${errorMsg}`, { error });
+			return {
+				prompt: originalPrompt,
+				originalPrompt,
+				error: errorMsg
+			};
+		}
+	}
+	const transformedPrompt = String(testCase.vars?.[injectVar] ?? prompt);
+	require_logger.logger.debug(`[RuntimeTransform] Transform complete`, {
+		originalLength: prompt.length,
+		resultLength: transformedPrompt.length,
+		layersApplied: layerConfigs.length,
+		audioApplied,
+		imageApplied
+	});
+	const displayVars = {};
+	if (testCase.vars) {
+		for (const [key, value] of Object.entries(testCase.vars)) if (key !== injectVar && typeof value === "string") displayVars[key] = value;
+	}
+	const result = {
+		prompt: transformedPrompt,
+		originalPrompt,
+		...Object.keys(displayVars).length > 0 && { displayVars },
+		metadata: testCase.metadata
+	};
+	const audioStorageKey = testCase.metadata?.audioStorageKey;
+	const imageStorageKey = testCase.metadata?.imageStorageKey;
+	if (audioApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:audio\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.audio = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.audio = {
+			data: transformedPrompt,
+			format: "mp3"
+		};
+		if (audioStorageKey) require_logger.logger.debug(`[RuntimeTransform] Audio stored to: ${audioStorageKey} (will be sanitized before DB save)`);
+	}
+	if (imageApplied && transformedPrompt !== originalPrompt) {
+		const dataUrlMatch = transformedPrompt.match(/^data:image\/([^;]+);base64,(.+)$/);
+		if (dataUrlMatch) result.image = {
+			data: dataUrlMatch[2],
+			format: dataUrlMatch[1]
+		};
+		else result.image = {
+			data: transformedPrompt,
+			format: "png"
+		};
+		if (imageStorageKey) require_logger.logger.debug(`[RuntimeTransform] Image stored to: ${imageStorageKey} (will be sanitized before DB save)`);
+	}
+	return result;
+}
+//#endregion
+Object.defineProperty(exports, "applyRuntimeTransforms", {
+	enumerable: true,
+	get: function() {
+		return applyRuntimeTransforms;
+	}
+});
+
+//# sourceMappingURL=runtimeTransform-ON3YYILw.cjs.map

package/dist/src/{sagemaker-BVkaG2-l.js → sagemaker-CujrzP1a.js}

@@ -1,6 +1,7 @@
-import { C as getEnvFloat, T as getEnvString, a as logger, w as getEnvInt } from "./logger-B88EkIn6.js";
-import { n as telemetry } from "./telemetry-dbaJ0E98.js";
-import { n as transform } from "./transform-DYX1_Xnh.js";
+import { C as getEnvFloat, T as getEnvString, a as logger, w as getEnvInt } from "./logger-KD8JjCRJ.js";
+import { n as StringOrFunctionSchema } from "./shared-BoG7qLMv.js";
+import { n as telemetry } from "./telemetry-DmXYcJNV.js";
+import { i as getTransformErrorMessage, o as transform, r as TransformInputType } from "./transform-CrPGTsij.js";
 import { z } from "zod";
 import crypto from "crypto";
 //#region src/providers/sagemaker.ts
@@ -10,6 +11,14 @@ import crypto from "crypto";
 * @returns Promise that resolves after the specified delay
 */
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function stringifyTransformResult(result) {
+	if (result === void 0 || result === null) {
+		logger.debug("Transform function returned null or undefined, using original prompt");
+		return;
+	}
+	if (typeof result === "string") return result;
+	return typeof result === "object" ? JSON.stringify(result) : String(result);
+}
 const SUPPORTED_MODEL_TYPES = [
 	"openai",
 	"llama",
@@ -34,7 +43,7 @@ const SageMakerConfigSchema = z.strictObject({
 	topP: z.number().optional(),
 	stopSequences: z.array(z.string()).optional(),
 	delay: z.number().optional(),
-	transform: z.string().optional(),
+	transform: StringOrFunctionSchema.optional(),
 	modelType: z.enum(SUPPORTED_MODEL_TYPES).optional(),
 	responseFormat: z.strictObject({
 		type: z.string().optional(),
@@ -154,53 +163,52 @@ var SageMakerGenericProvider = class {
 				prompt: context?.prompt || { raw: prompt },
 				uuid: `sagemaker-${this.endpointName}-${Date.now()}`
 			};
-			const transformFn = this.transform || context?.originalProvider?.transform;
-			if (!transformFn) return prompt;
+			const transformFn = this.transform;
 			logger.debug(`Applying transform to prompt for SageMaker endpoint ${this.getEndpointName()}`);
-			if (typeof transformFn === "string" && !transformFn.startsWith("file://")) try {
+			if (typeof transformFn === "string" && !transformFn.startsWith("file://")) {
+				let result;
 				if (transformFn.includes("=>")) {
-					const result = new Function("prompt", "context", `try { return (${transformFn})(prompt, context); } catch(e) { throw new Error("Transform function error: " + e.message); }`)(prompt, transformContext);
-					if (result === void 0 || result === null) {
-						logger.debug("Transform function returned null or undefined, using original prompt");
-						return prompt;
-					}
-					if (typeof result === "string") return result;
-					else if (typeof result === "object") return JSON.stringify(result);
-					else return String(result);
+					const fn = new Function("prompt", "context", `try { return (${transformFn})(prompt, context); } catch(e) { throw new Error("Transform function error: " + e.message); }`);
+					result = await Promise.resolve(fn(prompt, transformContext));
 				} else {
-					const result = new Function("prompt", "context", `try { ${transformFn} } catch(e) { throw new Error("Transform function error: " + e.message); }`)(prompt, transformContext);
-					if (result === void 0 || result === null) {
-						logger.debug("Transform function returned null or undefined, using original prompt");
-						return prompt;
-					}
-					if (typeof result === "string") return result;
-					else if (typeof result === "object") return JSON.stringify(result);
-					else return String(result);
-				}
-			} catch (transformError) {
-				logger.error(`Error executing inline transform: ${transformError}`);
-			}
-			else try {
-				const { TransformInputType } = await import("./transform-DYX1_Xnh.js").then((n) => n.r);
-				const transformed = await transform(transformFn, prompt, transformContext, false, TransformInputType.OUTPUT);
-				if (transformed === void 0 || transformed === null) {
-					logger.debug("Transform function returned null or undefined, using original prompt");
-					return prompt;
+					const fn = new Function("prompt", "context", `try { ${transformFn} } catch(e) { throw new Error("Transform function error: " + e.message); }`);
+					result = await Promise.resolve(fn(prompt, transformContext));
 				}
-				if (typeof transformed === "string") return transformed;
-				else if (typeof transformed === "object") return JSON.stringify(transformed);
-				else return String(transformed);
-			} catch (transformError) {
-				logger.error(`Error using transform utility: ${transformError}`);
+				const transformedPrompt = stringifyTransformResult(result);
+				if (transformedPrompt !== void 0) return transformedPrompt;
+			} else {
+				const transformedPrompt = stringifyTransformResult(await transform(transformFn, prompt, transformContext, false, TransformInputType.OUTPUT));
+				if (transformedPrompt !== void 0) return transformedPrompt;
 			}
 			logger.warn(`Transform did not produce a valid result, using original prompt`);
 			return prompt;
-		} catch (_) {
-			logger.error(`Error applying transform to prompt: ${_}`);
+		} catch (error) {
+			if (typeof this.transform === "function") throw error;
+			logger.error(`Error applying transform to prompt: ${error}`);
 			return prompt;
 		}
 	}
 	/**
+	* Run `applyTransformation` and convert a function-transform throw into a
+	* `ProviderResponse.error` so the evaluator sees a uniform error row instead
+	* of an uncaught rejection.
+	*/
+	async runTransformSafely(input, context, errorPrefix) {
+		try {
+			return {
+				ok: true,
+				value: await this.applyTransformation(input, context)
+			};
+		} catch (transformError) {
+			const message = `${errorPrefix}: ${getTransformErrorMessage(transformError)}`;
+			logger.error(message);
+			return {
+				ok: false,
+				error: message
+			};
+		}
+	}
+	/**
 	* Extracts data from a response using a path expression
 	* Supports JavaScript expressions and file-based transforms
 	*/
@@ -208,7 +216,6 @@ var SageMakerGenericProvider = class {
 		if (!pathExpression) return responseJson;
 		try {
 			if (pathExpression.startsWith("file://")) try {
-				const { TransformInputType } = await import("./transform-DYX1_Xnh.js").then((n) => n.r);
 				const transformedResult = await transform(pathExpression, responseJson, { prompt: {} }, false, TransformInputType.OUTPUT);
 				return transformedResult !== void 0 && transformedResult !== null ? transformedResult : responseJson;
 			} catch (error) {
@@ -403,9 +410,11 @@ 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-C4Xb-hNb.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-roFAE0cI.js").then((n) => n.t);
 		const delayMs = context?.originalProvider?.delay || this.delay;
-		const transformedPrompt = await this.applyTransformation(prompt, context);
+		const transformResult = await this.runTransformSafely(prompt, context, "SageMaker transform error");
+		if (!transformResult.ok) return { error: transformResult.error };
+		const transformedPrompt = transformResult.value;
 		const isTransformed = transformedPrompt !== prompt;
 		if (isTransformed) {
 			logger.debug(`Prompt transformed for SageMaker endpoint ${this.getEndpointName()}`);
@@ -415,7 +424,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-C4Xb-hNb.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
+			const cachedResult = await (getCache ? getCache() : await import("./cache-roFAE0cI.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
 			if (cachedResult) {
 				logger.debug(`Using cached SageMaker response for ${this.getEndpointName()}`);
 				try {
@@ -489,7 +498,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-C4Xb-hNb.js").then((n) => n.t).then((m) => m.getCache());
+				const cache = getCache ? getCache() : await import("./cache-roFAE0cI.js").then((n) => n.t).then((m) => m.getCache());
 				const resultToCache = JSON.stringify(result);
 				try {
 					await cache.set(cacheKey, resultToCache);
@@ -534,9 +543,11 @@ 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-C4Xb-hNb.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-roFAE0cI.js").then((n) => n.t);
 		const delayMs = context?.originalProvider?.delay || this.delay;
-		const transformedText = await this.applyTransformation(text, context);
+		const transformResult = await this.runTransformSafely(text, context, "SageMaker embedding transform error");
+		if (!transformResult.ok) return { error: transformResult.error };
+		const transformedText = transformResult.value;
 		const isTransformed = transformedText !== text;
 		if (isTransformed) {
 			logger.debug(`Text transformed for SageMaker embedding endpoint ${this.getEndpointName()}`);
@@ -546,7 +557,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-C4Xb-hNb.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
+			const cachedResult = await (await getCache ? await getCache() : await import("./cache-roFAE0cI.js").then((n) => n.t).then((m) => m.getCache())).get(cacheKey);
 			if (cachedResult) {
 				logger.debug(`Using cached SageMaker embedding response for ${this.getEndpointName()}`);
 				try {
@@ -660,11 +671,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-C4Xb-hNb.js").then((n) => n.t);
+		const { isCacheEnabled, getCache } = await import("./cache-roFAE0cI.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-C4Xb-hNb.js").then((n) => n.t).then((m) => m.getCache());
+			const cache = await getCache ? await getCache() : await import("./cache-roFAE0cI.js").then((n) => n.t).then((m) => m.getCache());
 			if (isTransformed && originalText && !result.metadata) result.metadata = {
 				transformed: true,
 				originalText
@@ -686,4 +697,4 @@ var SageMakerEmbeddingProvider = class extends SageMakerGenericProvider {
 //#endregion
 export { SageMakerCompletionProvider, SageMakerEmbeddingProvider };
 
-//# sourceMappingURL=sagemaker-BVkaG2-l.js.map
+//# sourceMappingURL=sagemaker-CujrzP1a.js.map