promptfoo 0.121.10 → 0.121.11

package/dist/src/quiverai-CzROwhTy.js

@@ -0,0 +1,324 @@
+import { E as getEnvString, o as logger } from "./logger-2ZstxKQf.js";
+import { t as fetchWithProxy, x as getRequestTimeoutMs } from "./fetch-BNUDixbE.js";
+import { r as fetchWithCache } from "./cache-BEZBHFxd.js";
+//#region src/providers/quiverai.ts
+const QUIVERAI_API_BASE_URL = "https://api.quiver.ai/v1";
+const QUIVERAI_DEFAULT_MODEL = "arrow-1.1";
+const SAMPLING_KEYS = [
+	"temperature",
+	"top_p",
+	"presence_penalty",
+	"max_output_tokens"
+];
+const GENERATION_KEYS = ["instructions", "n"];
+const VECTORIZE_KEYS = ["auto_crop", "target_size"];
+const NON_RETRYABLE_429_CODES = new Set(["weekly_limit_exceeded"]);
+const MAX_RETRY_AFTER_MS = 6e4;
+const MAX_RETRIES = 3;
+/**
+* QuiverAI provider for SVG vector graphics.
+*
+* Supports two endpoints:
+*  - Text → SVG via `POST /v1/svgs/generations` (mode: 'generation', the default).
+*  - Image → SVG via `POST /v1/svgs/vectorizations` (mode: 'vectorize').
+*
+* Streams by default for faster time-to-first-token; set `stream: false`
+* to enable on-disk response caching.
+*/
+var QuiverAiProvider = class {
+	config;
+	modelName;
+	mode;
+	apiKey;
+	apiBaseUrl;
+	constructor(modelName, options = {}) {
+		const { config, id, env, mode = "generation" } = options;
+		this.modelName = modelName;
+		this.mode = mode;
+		this.apiKey = config?.apiKey || env?.QUIVERAI_API_KEY || getEnvString("QUIVERAI_API_KEY") || "";
+		this.apiBaseUrl = config?.apiBaseUrl || QUIVERAI_API_BASE_URL;
+		if (id) this.id = () => id;
+		this.config = config || {};
+	}
+	id() {
+		return this.mode === "vectorize" ? `quiverai:vectorize:${this.modelName}` : `quiverai:${this.modelName}`;
+	}
+	toString() {
+		return `[QuiverAI ${this.mode === "vectorize" ? "Vectorize " : ""}Provider ${this.modelName}]`;
+	}
+	getApiUrl() {
+		const path = this.mode === "vectorize" ? "/svgs/vectorizations" : "/svgs/generations";
+		return `${this.apiBaseUrl}${path}`;
+	}
+	getHeaders() {
+		return {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.apiKey}`
+		};
+	}
+	async callApi(prompt, context) {
+		if (!this.apiKey) return { error: "QuiverAI API key is not set. Set the QUIVERAI_API_KEY environment variable or add apiKey to the provider config. Get a key at https://app.quiver.ai/settings/api-keys" };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const useStream = config.stream !== false;
+		let body;
+		try {
+			body = this.buildRequestBody(prompt, config, useStream);
+		} catch (error) {
+			return { error: `${error.message}` };
+		}
+		try {
+			if (useStream) return await this.callApiStreaming(body);
+			return await this.callApiNonStreaming(body, context);
+		} catch (error) {
+			logger.error(`QuiverAI API call error: ${error}`);
+			return { error: `QuiverAI API call error: ${error}` };
+		}
+	}
+	buildRequestBody(prompt, config, useStream) {
+		const sampling = pickDefined(config, [...SAMPLING_KEYS]);
+		if (this.mode === "vectorize") {
+			const image = getConfiguredVectorizeImage(config.image) ?? parsePromptAsImage(prompt);
+			return {
+				model: this.modelName,
+				image,
+				stream: useStream,
+				...sampling,
+				...pickDefined(config, [...VECTORIZE_KEYS])
+			};
+		}
+		return {
+			model: this.modelName,
+			prompt,
+			stream: useStream,
+			...sampling,
+			...pickDefined(config, [...GENERATION_KEYS]),
+			...config.references && { references: normalizeReferences(config.references) }
+		};
+	}
+	async callApiNonStreaming(body, context) {
+		const { data, cached, status, statusText } = await fetchWithCache(this.getApiUrl(), {
+			method: "POST",
+			headers: this.getHeaders(),
+			body: JSON.stringify(body)
+		}, getRequestTimeoutMs(), "json", context?.bustCache ?? context?.debug);
+		if (status < 200 || status >= 300) {
+			if (data && typeof data === "object" && "code" in data && "message" in data) return { error: formatError(data) };
+			return { error: `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}` };
+		}
+		const response = data;
+		return {
+			cached,
+			output: extractSvgOutput(response),
+			tokenUsage: mapTokenUsage(response.usage, cached ? 0 : 1),
+			metadata: buildMetadata({
+				responseId: response.id,
+				credits: response.credits
+			})
+		};
+	}
+	async callApiStreaming(body) {
+		let lastResp;
+		for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), getRequestTimeoutMs());
+			let reader;
+			try {
+				lastResp = await fetchWithProxy(this.getApiUrl(), {
+					method: "POST",
+					headers: this.getHeaders(),
+					body: JSON.stringify(body),
+					signal: controller.signal
+				});
+				if (lastResp.status === 429 && attempt < MAX_RETRIES && !await isNonRetryable429(lastResp)) {
+					const waitMs = getRetryAfterMs(lastResp.headers, attempt);
+					logger.debug(`QuiverAI: rate limited, retry ${attempt + 1}/${MAX_RETRIES} in ${waitMs}ms`);
+					await lastResp.body?.cancel();
+					await new Promise((resolve) => setTimeout(resolve, waitMs));
+					continue;
+				}
+				if (!lastResp.ok) return await handleStreamingError(lastResp);
+				if (!lastResp.body) return { error: "QuiverAI streaming response has no body" };
+				reader = lastResp.body.getReader();
+				return await readSSEStream(reader);
+			} finally {
+				reader?.cancel().catch(() => {});
+				clearTimeout(timeout);
+			}
+		}
+		return handleStreamingError(lastResp);
+	}
+};
+async function isNonRetryable429(resp) {
+	try {
+		const data = await resp.clone().json();
+		return typeof data?.code === "string" && NON_RETRYABLE_429_CODES.has(data.code);
+	} catch {
+		return false;
+	}
+}
+async function handleStreamingError(resp) {
+	try {
+		return { error: formatError(await resp.json()) };
+	} catch {
+		return { error: `QuiverAI API error: HTTP ${resp.status}` };
+	}
+}
+async function readSSEStream(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const outputs = /* @__PURE__ */ new Map();
+	let totalCredits;
+	let lastUsage;
+	let responseId;
+	const ingest = (line) => {
+		const data = parseSSEData(line);
+		if (!data) return;
+		if (data.type === "content" && typeof data.svg === "string") {
+			const key = data.id ?? `${data.index ?? outputs.size}`;
+			outputs.set(key, {
+				index: data.index ?? outputs.size,
+				svg: data.svg,
+				credits: data.credits
+			});
+			if (typeof data.credits === "number") totalCredits = (totalCredits ?? 0) + data.credits;
+			if (!responseId && data.id) responseId = data.id;
+		}
+		if (data.usage) lastUsage = data.usage;
+	};
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) ingest(line);
+	}
+	if (buffer.trim()) ingest(buffer);
+	if (outputs.size === 0) return { error: "QuiverAI streaming response contained no SVG content" };
+	const ordered = [...outputs.values()].sort((a, b) => a.index - b.index).map((o) => o.svg);
+	return {
+		output: ordered.length === 1 ? ordered[0] : ordered.join("\n\n"),
+		tokenUsage: mapTokenUsage(lastUsage, 1),
+		metadata: buildMetadata({
+			responseId,
+			credits: totalCredits
+		})
+	};
+}
+function pickDefined(obj, keys) {
+	return Object.fromEntries(keys.filter((k) => obj[k] != null).map((k) => [k, obj[k]]));
+}
+function formatError(err) {
+	const base = `${err.message} [${err.code}]`;
+	return err.request_id ? `${base} (request_id: ${err.request_id})` : base;
+}
+function mapTokenUsage(usage, numRequests) {
+	return {
+		total: usage?.total_tokens || 0,
+		prompt: usage?.input_tokens || 0,
+		completion: usage?.output_tokens || 0,
+		numRequests
+	};
+}
+function buildMetadata(parts) {
+	const meta = {};
+	if (parts.responseId) meta.responseId = parts.responseId;
+	if (typeof parts.credits === "number") meta.credits = parts.credits;
+	return Object.keys(meta).length ? meta : void 0;
+}
+function getRetryAfterMs(headers, attempt) {
+	const retryAfter = headers.get("retry-after");
+	if (retryAfter) {
+		const seconds = Number(retryAfter);
+		if (!Number.isNaN(seconds)) return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+		const date = new Date(retryAfter);
+		if (!Number.isNaN(date.getTime())) return Math.min(Math.max(0, date.getTime() - Date.now()), MAX_RETRY_AFTER_MS);
+	}
+	return Math.pow(2, attempt) * 1e3;
+}
+function parseSSEData(line) {
+	if (!line.startsWith("data:")) return null;
+	const payload = line.slice(line.startsWith("data: ") ? 6 : 5).trim();
+	if (!payload || payload === "[DONE]") return null;
+	try {
+		return JSON.parse(payload);
+	} catch {
+		logger.debug(`QuiverAI: failed to parse SSE data: ${payload}`);
+		return null;
+	}
+}
+function extractSvgOutput(response) {
+	if (Array.isArray(response.data)) {
+		const svgs = response.data.map((item) => item.svg).filter(Boolean);
+		if (svgs.length === 1) return svgs[0];
+		if (svgs.length > 1) return svgs.join("\n\n");
+	}
+	return JSON.stringify(response);
+}
+function normalizeReferences(refs) {
+	return refs.map((ref) => typeof ref === "string" ? { url: ref } : ref);
+}
+const BASE64_DATA_URL_PATTERN = /^data:image\/[a-zA-Z0-9.+-]+(?:;[^,;]+)*;base64,(.+)$/i;
+function normalizeImageReference(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const candidate = value;
+	if (typeof candidate.url === "string" && candidate.url.trim()) return { url: candidate.url };
+	if (typeof candidate.base64 === "string" && candidate.base64.trim()) return { base64: candidate.base64 };
+	return null;
+}
+function getConfiguredVectorizeImage(image) {
+	if (image === void 0) return;
+	const normalized = normalizeImageReference(image);
+	if (!normalized) throw new Error("QuiverAI vectorize `image` must contain a non-empty `url` or `base64` string.");
+	return normalized;
+}
+function parsePromptAsImage(prompt) {
+	const trimmed = prompt.trim();
+	if (!trimmed) throw new Error("QuiverAI vectorize requires an image: pass a URL or base64 string as the prompt, or set `image` in the provider config.");
+	const dataUrlMatch = BASE64_DATA_URL_PATTERN.exec(trimmed);
+	if (dataUrlMatch) return { base64: dataUrlMatch[1] };
+	if (/^data:image\//i.test(trimmed)) throw new Error("QuiverAI vectorize data URLs must be base64-encoded.");
+	if (/^https?:\/\//i.test(trimmed)) return { url: trimmed };
+	if (trimmed.startsWith("{")) {
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			return { base64: trimmed };
+		}
+		if (parsed && typeof parsed === "object") {
+			const image = normalizeImageReference(parsed);
+			if (image) return image;
+			if ("image" in parsed) {
+				const nestedImage = normalizeImageReference(parsed.image);
+				if (nestedImage) return nestedImage;
+				throw new Error("QuiverAI vectorize nested `image` must contain a non-empty `url` or `base64` string.");
+			}
+			throw new Error("QuiverAI vectorize JSON image input must contain a non-empty `url` or `base64` string.");
+		}
+	}
+	return { base64: trimmed };
+}
+function createQuiverAiProvider(providerPath, providerOptions = {}, env) {
+	const splits = providerPath.split(":");
+	const modelType = splits[1];
+	let mode = "generation";
+	let modelStart = 1;
+	if (modelType === "vectorize") {
+		mode = "vectorize";
+		modelStart = 2;
+	} else if (modelType === "generate" || modelType === "chat") modelStart = 2;
+	return new QuiverAiProvider(splits.slice(modelStart).join(":") || QUIVERAI_DEFAULT_MODEL, {
+		config: providerOptions.config,
+		id: providerOptions.id,
+		env: providerOptions.env ?? env,
+		mode
+	});
+}
+//#endregion
+export { createQuiverAiProvider };
+
+//# sourceMappingURL=quiverai-CzROwhTy.js.map

package/dist/src/{registry-C57trbNM.js → registry-B0pFfEzq.js}

@@ -29,91 +29,91 @@ const redteamProviderFactories = [
 	{
 		test: (providerPath) => providerPath === "agentic:memory-poisoning",
 		create: async (_providerPath, providerOptions) => {
-			const { MemoryPoisoningProvider } = await import("./memoryPoisoning-BYBQ1Ns5.js");
+			const { MemoryPoisoningProvider } = await import("./memoryPoisoning-DtJ5vYZW.js");
 			return new MemoryPoisoningProvider(providerOptions);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:best-of-n",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamBestOfNProvider } = await import("./bestOfN-BkH9d3Lr.js");
+			const { default: RedteamBestOfNProvider } = await import("./bestOfN-BEfIajMY.js");
 			return new RedteamBestOfNProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:crescendo",
 		create: async (_providerPath, providerOptions) => {
-			const { CrescendoProvider } = await import("./crescendo-BgGio6G0.js");
+			const { CrescendoProvider } = await import("./crescendo-BpVWWleP.js");
 			return new CrescendoProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:custom" || providerPath.startsWith("promptfoo:redteam:custom:"),
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamCustomProvider } = await import("./custom-DsSELzzx.js");
+			const { default: RedteamCustomProvider } = await import("./custom-LxkvkOvG.js");
 			return new RedteamCustomProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:goat",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamGoatProvider } = await import("./goat-kpeOOE-K.js");
+			const { default: RedteamGoatProvider } = await import("./goat-CNpA_tT8.js");
 			return new RedteamGoatProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:authoritative-markup-injection",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await import("./authoritativeMarkupInjection-CE4HOCHa.js");
+			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await import("./authoritativeMarkupInjection-CDCg-jRQ.js");
 			return new RedteamAuthoritativeMarkupInjectionProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:mischievous-user",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamMischievousUserProvider } = await import("./mischievousUser-DX1gGvUB.js");
+			const { default: RedteamMischievousUserProvider } = await import("./mischievousUser-BPDyepmu.js");
 			return new RedteamMischievousUserProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeProvider } = await import("./iterative-BIHF31Io.js");
+			const { default: RedteamIterativeProvider } = await import("./iterative-DyEoFedI.js");
 			return new RedteamIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:image",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamImageIterativeProvider } = await import("./iterativeImage-CbRn9_MH.js");
+			const { default: RedteamImageIterativeProvider } = await import("./iterativeImage-B7qV6kzP.js");
 			return new RedteamImageIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:tree",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeTreeProvider } = await import("./iterativeTree-DSNss1kE.js");
+			const { default: RedteamIterativeTreeProvider } = await import("./iterativeTree-B7116aK-.js");
 			return new RedteamIterativeTreeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:meta",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeMetaProvider } = await import("./iterativeMeta-2gyieWbU.js");
+			const { default: RedteamIterativeMetaProvider } = await import("./iterativeMeta-CnPYPYH0.js");
 			return new RedteamIterativeMetaProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:hydra",
 		create: async (_providerPath, providerOptions) => {
-			const { HydraProvider } = await import("./hydra-Cq_3qKz_.js");
+			const { HydraProvider } = await import("./hydra-BXmf4FCK.js");
 			return new HydraProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:indirect-web-pwn",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIndirectWebPwnProvider } = await import("./indirectWebPwn-CZ2kTy4r.js");
+			const { default: RedteamIndirectWebPwnProvider } = await import("./indirectWebPwn-C6_BaxjA.js");
 			return new RedteamIndirectWebPwnProvider(providerOptions.config);
 		}
 	}
@@ -121,4 +121,4 @@ const redteamProviderFactories = [
 //#endregion
 export { redteamProviderFactories };
 
-//# sourceMappingURL=registry-C57trbNM.js.map
+//# sourceMappingURL=registry-B0pFfEzq.js.map

package/dist/src/{registry-Bnb9O892.cjs → registry-BH1mZ37j.cjs}

@@ -29,91 +29,91 @@ const redteamProviderFactories = [
 	{
 		test: (providerPath) => providerPath === "agentic:memory-poisoning",
 		create: async (_providerPath, providerOptions) => {
-			const { MemoryPoisoningProvider } = await Promise.resolve().then(() => require("./memoryPoisoning-9mIgiE3F.cjs"));
+			const { MemoryPoisoningProvider } = await Promise.resolve().then(() => require("./memoryPoisoning-A8N_cbrW.cjs"));
 			return new MemoryPoisoningProvider(providerOptions);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:best-of-n",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamBestOfNProvider } = await Promise.resolve().then(() => require("./bestOfN-b6uHssUC.cjs"));
+			const { default: RedteamBestOfNProvider } = await Promise.resolve().then(() => require("./bestOfN-QWGyCB5j.cjs"));
 			return new RedteamBestOfNProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:crescendo",
 		create: async (_providerPath, providerOptions) => {
-			const { CrescendoProvider } = await Promise.resolve().then(() => require("./crescendo-TWgp7uGp.cjs"));
+			const { CrescendoProvider } = await Promise.resolve().then(() => require("./crescendo-CqQhmeC0.cjs"));
 			return new CrescendoProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:custom" || providerPath.startsWith("promptfoo:redteam:custom:"),
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamCustomProvider } = await Promise.resolve().then(() => require("./custom-D0p5pikf.cjs"));
+			const { default: RedteamCustomProvider } = await Promise.resolve().then(() => require("./custom-B_fKUq6j.cjs"));
 			return new RedteamCustomProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:goat",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamGoatProvider } = await Promise.resolve().then(() => require("./goat-Coh2te0S.cjs"));
+			const { default: RedteamGoatProvider } = await Promise.resolve().then(() => require("./goat-C1RkjWv1.cjs"));
 			return new RedteamGoatProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:authoritative-markup-injection",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await Promise.resolve().then(() => require("./authoritativeMarkupInjection-2C63bFKe.cjs"));
+			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await Promise.resolve().then(() => require("./authoritativeMarkupInjection-BAuWkXwn.cjs"));
 			return new RedteamAuthoritativeMarkupInjectionProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:mischievous-user",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamMischievousUserProvider } = await Promise.resolve().then(() => require("./mischievousUser-ECTv-u4g.cjs"));
+			const { default: RedteamMischievousUserProvider } = await Promise.resolve().then(() => require("./mischievousUser-DHYVKotH.cjs"));
 			return new RedteamMischievousUserProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeProvider } = await Promise.resolve().then(() => require("./iterative-XRfxQ0i8.cjs"));
+			const { default: RedteamIterativeProvider } = await Promise.resolve().then(() => require("./iterative-CD3I_Rwq.cjs"));
 			return new RedteamIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:image",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamImageIterativeProvider } = await Promise.resolve().then(() => require("./iterativeImage-DJtVKlFX.cjs"));
+			const { default: RedteamImageIterativeProvider } = await Promise.resolve().then(() => require("./iterativeImage-BaOAhF-S.cjs"));
 			return new RedteamImageIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:tree",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeTreeProvider } = await Promise.resolve().then(() => require("./iterativeTree-DoE-8nC3.cjs"));
+			const { default: RedteamIterativeTreeProvider } = await Promise.resolve().then(() => require("./iterativeTree-u2hKQ51y.cjs"));
 			return new RedteamIterativeTreeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:meta",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeMetaProvider } = await Promise.resolve().then(() => require("./iterativeMeta-dkFD9UKg.cjs"));
+			const { default: RedteamIterativeMetaProvider } = await Promise.resolve().then(() => require("./iterativeMeta-BQrhQ-iJ.cjs"));
 			return new RedteamIterativeMetaProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:hydra",
 		create: async (_providerPath, providerOptions) => {
-			const { HydraProvider } = await Promise.resolve().then(() => require("./hydra-B524i6K6.cjs"));
+			const { HydraProvider } = await Promise.resolve().then(() => require("./hydra-c1_7vPsg.cjs"));
 			return new HydraProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:indirect-web-pwn",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIndirectWebPwnProvider } = await Promise.resolve().then(() => require("./indirectWebPwn-Bfp-t224.cjs"));
+			const { default: RedteamIndirectWebPwnProvider } = await Promise.resolve().then(() => require("./indirectWebPwn-BqOgtzny.cjs"));
 			return new RedteamIndirectWebPwnProvider(providerOptions.config);
 		}
 	}
@@ -121,4 +121,4 @@ const redteamProviderFactories = [
 //#endregion
 exports.redteamProviderFactories = redteamProviderFactories;
 
-//# sourceMappingURL=registry-Bnb9O892.cjs.map
+//# sourceMappingURL=registry-BH1mZ37j.cjs.map

package/dist/src/{registry-CmhcDYtj.js → registry-Bvfyz9Xt.js}

@@ -29,91 +29,91 @@ const redteamProviderFactories = [
 	{
 		test: (providerPath) => providerPath === "agentic:memory-poisoning",
 		create: async (_providerPath, providerOptions) => {
-			const { MemoryPoisoningProvider } = await import("./memoryPoisoning-D4iqi_nT.js");
+			const { MemoryPoisoningProvider } = await import("./memoryPoisoning-BGe4fuFU.js");
 			return new MemoryPoisoningProvider(providerOptions);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:best-of-n",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamBestOfNProvider } = await import("./bestOfN-C1_WFZFb.js");
+			const { default: RedteamBestOfNProvider } = await import("./bestOfN-B89i9zc7.js");
 			return new RedteamBestOfNProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:crescendo",
 		create: async (_providerPath, providerOptions) => {
-			const { CrescendoProvider } = await import("./crescendo-C8YuBd9K.js");
+			const { CrescendoProvider } = await import("./crescendo-JAvyVRKK.js");
 			return new CrescendoProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:custom" || providerPath.startsWith("promptfoo:redteam:custom:"),
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamCustomProvider } = await import("./custom-CFnjgHKp.js");
+			const { default: RedteamCustomProvider } = await import("./custom-Bm6Tu-ji.js");
 			return new RedteamCustomProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:goat",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamGoatProvider } = await import("./goat-BCFeW4zk.js");
+			const { default: RedteamGoatProvider } = await import("./goat-BnB1zGir.js");
 			return new RedteamGoatProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:authoritative-markup-injection",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await import("./authoritativeMarkupInjection-B2MJXBR1.js");
+			const { default: RedteamAuthoritativeMarkupInjectionProvider } = await import("./authoritativeMarkupInjection-COd4q9Hp.js");
 			return new RedteamAuthoritativeMarkupInjectionProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:mischievous-user",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamMischievousUserProvider } = await import("./mischievousUser-D23wQ8f0.js");
+			const { default: RedteamMischievousUserProvider } = await import("./mischievousUser-D1mbddId.js");
 			return new RedteamMischievousUserProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeProvider } = await import("./iterative-DZkNlFE-.js");
+			const { default: RedteamIterativeProvider } = await import("./iterative-BzKNkXHn.js");
 			return new RedteamIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:image",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamImageIterativeProvider } = await import("./iterativeImage-BFRM8Jdx.js");
+			const { default: RedteamImageIterativeProvider } = await import("./iterativeImage-noXhuElt.js");
 			return new RedteamImageIterativeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:tree",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeTreeProvider } = await import("./iterativeTree-DuIk7wjS.js");
+			const { default: RedteamIterativeTreeProvider } = await import("./iterativeTree-cKlxQWhi.js");
 			return new RedteamIterativeTreeProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:iterative:meta",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIterativeMetaProvider } = await import("./iterativeMeta-CmMnD77T.js");
+			const { default: RedteamIterativeMetaProvider } = await import("./iterativeMeta-BHNJgPy0.js");
 			return new RedteamIterativeMetaProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:hydra",
 		create: async (_providerPath, providerOptions) => {
-			const { HydraProvider } = await import("./hydra-dOBPmWHt.js");
+			const { HydraProvider } = await import("./hydra-C5_Vuh-m.js");
 			return new HydraProvider(providerOptions.config);
 		}
 	},
 	{
 		test: (providerPath) => providerPath === "promptfoo:redteam:indirect-web-pwn",
 		create: async (_providerPath, providerOptions) => {
-			const { default: RedteamIndirectWebPwnProvider } = await import("./indirectWebPwn-8G6tgDBW.js");
+			const { default: RedteamIndirectWebPwnProvider } = await import("./indirectWebPwn-k8D0JacN.js");
 			return new RedteamIndirectWebPwnProvider(providerOptions.config);
 		}
 	}
@@ -121,4 +121,4 @@ const redteamProviderFactories = [
 //#endregion
 export { redteamProviderFactories };
 
-//# sourceMappingURL=registry-CmhcDYtj.js.map
+//# sourceMappingURL=registry-Bvfyz9Xt.js.map