promptfoo 0.125.0 → 0.125.1

package/dist/src/shared-tfPT8Tna.js

@@ -0,0 +1,1928 @@
+import { v as BaseTokenUsageSchema } from "./shared-DS0YmCOx.js";
+import { G as getEnvInt, M as isProviderOptions, R as safeJsonStringify, U as getEnvBool, W as getEnvFloat, j as isApiProvider, o as logger, rt as state } from "./logger-CNHLbG5Y.js";
+import { t as invariant } from "./invariant-CHP0zrix.js";
+import { K as sanitizeProviderIdForLog } from "./dataUrl-DUSr-ZvI.js";
+import { A as isTransientConnectionError, I as cloudConfig, N as parseRateLimitHeaders, O as isHttpRateLimitError, P as parseRetryAfter, l as withFetchRetryContext } from "./fetch-BG_Jl7ty.js";
+import "./tables-CpHZEDfI.js";
+import "./shared-CAXFSQC3.js";
+import { S as isCallerAbortError } from "./shared-BnN4RWgk.js";
+import { s as isLoggedIntoCloud } from "./accounts-vJBPs89d.js";
+import { X as isSafeCost, Z as isSafeTokenCount } from "./util-CeGgoYs1.js";
+import { h as remoteGenerationContextPayload } from "./remoteGeneration-CAtvamG6.js";
+import { n as isBlobStorageEnabled, t as extractAndStoreBinaryData } from "./extractor-wLjTmXQ-.js";
+import { a as accumulateGradingResponseTokenUsage, c as accumulateTokenUsage, d as createEmptyTokenUsage, s as accumulateResponseTokenUsage } from "./tokenUsageUtils-C51DmahQ.js";
+import { a as createResponseHeadersObserver, c as preserveResponseHeadersObserverError, i as composeResponseHeadersObservers, l as preserveResponseHeadersObserverErrorResponse, o as isResponseHeadersObserverError, s as isResponseHeadersObserverErrorResponse, t as OpenAiChatCompletionProvider } from "./chat-zCWuBKAj.js";
+import { t as PromptfooChatCompletionProvider } from "./promptfoo-Bhpm7sH6.js";
+import { o as transform, r as TransformInputType } from "./transform-gJysRqu9.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash, randomUUID } from "crypto";
+import { EventEmitter } from "events";
+//#region src/scheduler/providerCallExecutionContext.ts
+const providerCallExecutionContext = new AsyncLocalStorage();
+const providerCallTracingContext = new AsyncLocalStorage();
+function getProviderCallExecutionContext() {
+	return providerCallExecutionContext.getStore();
+}
+function withProviderCallExecutionContext(context, fn) {
+	return providerCallExecutionContext.run(context, fn);
+}
+function runProviderCallWithAbort(call, signal) {
+	if (!signal) return call();
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let pendingAbort;
+		const finish = (complete) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			if (pendingAbort) clearImmediate(pendingAbort);
+			complete();
+		};
+		const onAbort = () => {
+			pendingAbort = setImmediate(() => finish(() => reject(signal.reason)));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			call().then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+		} catch (error) {
+			finish(() => reject(error));
+		}
+	});
+}
+function getProviderCallTracingContext() {
+	return providerCallTracingContext.getStore();
+}
+function withProviderCallTracingContext(tracingContext, fn) {
+	return providerCallTracingContext.run(tracingContext, fn);
+}
+//#endregion
+//#region src/scheduler/types.ts
+/**
+* Shared types for the scheduler module.
+*/
+const HTTP_429_RE = /\b429\b/;
+/**
+* Default rate limit detection for ProviderResponse.
+*
+* Returns true when a result/error indicates a *retryable* rate limit. Hard
+* quota failures (billing exhaustion, daily limits) match the same `429` /
+* `too many requests` substrings but must NOT be classified as retryable —
+* doing so amplifies load against an exhausted account, which is the exact
+* regression PR 8896 closes at the transport layer. The result-path check
+* here mirrors that fail-fast contract for providers that fold the
+* structured error into `ProviderResponse.error`.
+*/
+function isProviderResponseRateLimited(result, error) {
+	if (isResponseHeadersObserverErrorResponse(result)) return false;
+	const responseError = result?.metadata?.errorOrigin === "tool" ? void 0 : result?.error;
+	if (result?.metadata?.rateLimitRetryable === false || result?.metadata?.rateLimitKind === "quota") return false;
+	if (result?.metadata?.rateLimitKind === "rate_limit") return true;
+	if (isHttpRateLimitError(error) && error.kind === "quota") return false;
+	if (responseError?.includes("Quota exceeded:")) return false;
+	if (error?.message?.includes("Quota exceeded:")) return false;
+	return Boolean(result?.metadata?.http?.status === 429 || HTTP_429_RE.test(responseError ?? "") || responseError?.toLowerCase?.().includes?.("rate limit") || HTTP_429_RE.test(error?.message ?? "") || error?.message?.toLowerCase().includes("rate limit") || error?.message?.toLowerCase().includes("too many requests"));
+}
+/**
+* Extract rate limit headers from ProviderResponse.
+* Headers can be at metadata.http.headers or metadata.headers.
+*/
+function getProviderResponseHeaders(result) {
+	return result?.metadata?.http?.headers || result?.metadata?.headers;
+}
+//#endregion
+//#region src/scheduler/providerWrapper.ts
+/**
+* Provider wrapper that adds rate limiting to any ApiProvider.
+*
+* Use this to wrap providers before passing them to redteam/assertion
+* code paths that bypass the main evaluator.
+*/
+/**
+* Symbol to mark providers that have already been wrapped.
+* Prevents double-wrapping which could cause issues.
+*/
+const WRAPPED_SYMBOL = Symbol.for("promptfoo.rateLimitWrapped");
+const TOKEN_USAGE_FIELDS = [
+	"prompt",
+	"completion",
+	"cached",
+	"total"
+];
+const COMPLETION_DETAIL_FIELDS = [
+	"reasoning",
+	"acceptedPrediction",
+	"rejectedPrediction",
+	"cacheReadInputTokens",
+	"cacheCreationInputTokens"
+];
+function addSafeTokenMetric(current, value) {
+	if (!isSafeTokenCount(value)) return;
+	const total = (current ?? 0) + value;
+	return Number.isSafeInteger(total) ? total : void 0;
+}
+function accumulateRetryTokenUsage(target, response) {
+	const usage = response.tokenUsage;
+	for (const field of TOKEN_USAGE_FIELDS) {
+		const total = addSafeTokenMetric(target[field], usage?.[field]);
+		if (total !== void 0) target[field] = total;
+	}
+	for (const field of COMPLETION_DETAIL_FIELDS) {
+		const value = usage?.completionDetails?.[field];
+		const total = addSafeTokenMetric(target.completionDetails?.[field], value);
+		if (total !== void 0) {
+			target.completionDetails ??= {};
+			target.completionDetails[field] = total;
+		}
+	}
+	const requests = response.cached ? 0 : isSafeTokenCount(usage?.numRequests) ? usage.numRequests : 1;
+	const totalRequests = addSafeTokenMetric(target.numRequests, requests);
+	if (totalRequests !== void 0) target.numRequests = totalRequests;
+}
+/**
+* Check if a provider is already wrapped with rate limiting.
+*/
+function isRateLimitWrapped(provider) {
+	return provider[WRAPPED_SYMBOL] === true;
+}
+/**
+* Create rate limit detection options for ProviderResponse.
+* Shared between providerWrapper and evaluator for consistency.
+*/
+function createProviderRateLimitOptions(abortSignal) {
+	return {
+		...abortSignal && { abortSignal },
+		onRateLimitExhausted: (result, error) => result.error ? result : {
+			...result,
+			error: error.message
+		},
+		getHeaders: (result) => result?.metadata?.rateLimitRetryable === false || result?.metadata?.rateLimitKind === "quota" ? void 0 : getProviderResponseHeaders(result),
+		isRateLimited: isProviderResponseRateLimited,
+		getRetryAfter: (result, error) => {
+			if (result?.metadata?.rateLimitRetryable === false) return;
+			const rawHeaders = getProviderResponseHeaders(result);
+			if (rawHeaders) {
+				const headers = {};
+				for (const [key, value] of Object.entries(rawHeaders)) headers[key.toLowerCase()] = value;
+				if (headers["retry-after-ms"]) {
+					const ms = Number.parseInt(headers["retry-after-ms"], 10);
+					if (Number.isFinite(ms) && ms >= 0) return ms;
+				}
+				if (headers["retry-after"]) {
+					const parsed = parseRetryAfter(headers["retry-after"]);
+					if (parsed !== null) return parsed;
+				}
+			}
+			const match = error?.message?.match(/\bretry after (\d+)\b/i);
+			if (match) {
+				const retryAfterMs = Number.parseInt(match[1], 10) * 1e3;
+				return Number.isFinite(retryAfterMs) ? retryAfterMs : void 0;
+			}
+		},
+		isRetryableResult: (result) => {
+			return result.metadata?.retryableErrorKind === "transient_availability";
+		},
+		finalizeResult: (result, retryResults) => {
+			if (retryResults.length === 0) return result;
+			const tokenUsage = {};
+			let combinedCost = 0;
+			let hasCost = false;
+			for (const response of [...retryResults, result]) {
+				accumulateRetryTokenUsage(tokenUsage, response);
+				if (isSafeCost(response.cost)) {
+					combinedCost += response.cost;
+					hasCost = true;
+				}
+			}
+			const resultWithoutCost = { ...result };
+			delete resultWithoutCost.cost;
+			return {
+				...resultWithoutCost,
+				tokenUsage,
+				...hasCost && Number.isFinite(combinedCost) && { cost: combinedCost }
+			};
+		}
+	};
+}
+/**
+* Wrap a provider with rate limiting.
+*
+* The wrapped provider will use the registry for all callApi calls,
+* automatically handling rate limits, retries, and adaptive concurrency.
+*
+* @param provider - The provider to wrap
+* @param registry - The rate limit registry to use
+* @returns A wrapped provider that applies rate limiting
+*/
+function wrapProviderWithRateLimiting(provider, registry) {
+	if (isRateLimitWrapped(provider)) return provider;
+	const originalCallApi = provider.callApi.bind(provider);
+	const wrappedProvider = {
+		...provider,
+		id: () => provider.id(),
+		callApi: async (prompt, context, options) => {
+			return registry.execute(provider, (onResponseHeaders) => originalCallApi(prompt, context, onResponseHeaders ? {
+				...options,
+				onResponseHeaders: composeResponseHeadersObservers(onResponseHeaders, options?.onResponseHeaders)
+			} : options), createProviderRateLimitOptions(options?.abortSignal));
+		}
+	};
+	wrappedProvider[WRAPPED_SYMBOL] = true;
+	return wrappedProvider;
+}
+//#endregion
+//#region src/blobs/remoteUpload.ts
+function buildRemoteUploadTarget() {
+	if (getEnvBool("PROMPTFOO_DISABLE_SHARING")) return null;
+	const baseUrl = cloudConfig.getApiHost();
+	const authHeaders = cloudConfig.getAuthHeaders();
+	if (!baseUrl || !authHeaders || !isLoggedIntoCloud()) return null;
+	try {
+		return {
+			url: new URL("/api/blobs", baseUrl).toString(),
+			authHeaders
+		};
+	} catch (error) {
+		logger.debug("[RemoteBlob] Invalid remote blob URL", {
+			error: error instanceof Error ? error.message : String(error),
+			baseUrl
+		});
+		return null;
+	}
+}
+function shouldAttemptRemoteBlobUpload() {
+	return buildRemoteUploadTarget() !== null;
+}
+async function uploadBlobRemote(buffer, mimeType, context) {
+	const target = buildRemoteUploadTarget();
+	if (!target) return null;
+	try {
+		const { fetchWithProxy } = await import("./fetch-BG_Jl7ty.js").then((n) => n.i);
+		const response = await fetchWithProxy(target.url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...target.authHeaders
+			},
+			body: JSON.stringify({
+				data: buffer.toString("base64"),
+				mimeType,
+				context
+			})
+		});
+		if (response.status === 404 || response.status === 400) {
+			logger.debug("[RemoteBlob] Remote blob upload unavailable", { status: response.status });
+			return null;
+		}
+		if (!response.ok) {
+			const text = await response.text();
+			logger.debug("[RemoteBlob] Failed to upload blob", {
+				status: response.status,
+				statusText: response.statusText,
+				body: text
+			});
+			return null;
+		}
+		const data = await response.json();
+		if (!data?.ref?.hash) {
+			logger.debug("[RemoteBlob] Remote upload returned malformed response");
+			return null;
+		}
+		return data;
+	} catch (error) {
+		logger.debug("[RemoteBlob] Error uploading blob", { error: error instanceof Error ? error.message : String(error) });
+		return null;
+	}
+}
+//#endregion
+//#region src/scheduler/adaptiveConcurrency.ts
+const DEFAULT_MIN_CONCURRENCY = 1;
+const BACKOFF_FACTOR = .5;
+const RECOVERY_FACTOR = 1.5;
+const RECOVERY_THRESHOLD = 5;
+const WARNING_THRESHOLD = .1;
+function concurrencyChange(previous, current, reason, changed = previous !== current) {
+	return {
+		changed,
+		previous,
+		current,
+		reason
+	};
+}
+/**
+* Manages adaptive concurrency based on rate limit feedback.
+*
+* Recovery path with constants (initial=10, min=1):
+* 1 → ceil(1.5) = 2   (5 successes)
+* 2 → ceil(3.0) = 3   (5 successes)
+* 3 → ceil(4.5) = 5   (5 successes)
+* 5 → ceil(7.5) = 8   (5 successes)
+* 8 → ceil(12) = 10   (5 successes, capped at initial)
+*
+* Total: 25 requests to fully recover from min=1 to initial=10
+*/
+var AdaptiveConcurrency = class {
+	current;
+	initial;
+	min;
+	consecutiveSuccesses = 0;
+	constructor(initial, min = DEFAULT_MIN_CONCURRENCY) {
+		this.initial = initial;
+		this.current = initial;
+		this.min = Math.min(initial, Math.max(1, min));
+	}
+	/**
+	* Called on successful request.
+	* May increase concurrency after sustained success.
+	*/
+	recordSuccess() {
+		this.consecutiveSuccesses++;
+		if (this.consecutiveSuccesses >= RECOVERY_THRESHOLD && this.current < this.initial) {
+			const previous = this.current;
+			this.current = Math.min(this.initial, Math.ceil(this.current * RECOVERY_FACTOR));
+			this.consecutiveSuccesses = 0;
+			return concurrencyChange(previous, this.current, "recovery");
+		}
+		return concurrencyChange(this.current, this.current, "recovery", false);
+	}
+	/**
+	* Called on rate limit (429).
+	* Reduces concurrency immediately.
+	*/
+	recordRateLimit() {
+		this.consecutiveSuccesses = 0;
+		const previous = this.current;
+		this.current = Math.max(this.min, Math.floor(this.current * BACKOFF_FACTOR));
+		return concurrencyChange(previous, this.current, "ratelimit");
+	}
+	/**
+	* Called when approaching rate limit.
+	* Proactively reduces concurrency based on remaining ratio.
+	*
+	* Formula:
+	* - At 10% remaining: reduce to 60% of current
+	* - At 5% remaining: reduce to 40% of current
+	* - At 1% remaining: reduce to 20% of current
+	*
+	* Linear scaling: reductionFactor = 0.2 + (ratio / WARNING_THRESHOLD) * 0.4
+	*/
+	recordApproachingLimit(ratio) {
+		const clampedRatio = Math.max(0, Math.min(1, ratio));
+		if (clampedRatio >= .1 || this.current <= this.min) return concurrencyChange(this.current, this.current, "proactive", false);
+		const previous = this.current;
+		const reductionFactor = .2 + clampedRatio / WARNING_THRESHOLD * .4;
+		this.current = Math.max(this.min, Math.floor(this.current * reductionFactor));
+		return concurrencyChange(previous, this.current, "proactive");
+	}
+	getCurrent() {
+		return this.current;
+	}
+	getMin() {
+		return this.min;
+	}
+	getInitial() {
+		return this.initial;
+	}
+};
+//#endregion
+//#region src/scheduler/cancellation.ts
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw signal.reason;
+}
+function sleepWithAbort(ms, signal) {
+	return new Promise((resolve, reject) => {
+		throwIfAborted(signal);
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/scheduler/retryPolicy.ts
+const DEFAULT_RETRY_POLICY = {
+	maxRetries: 3,
+	baseDelayMs: 1e3,
+	maxDelayMs: 6e4,
+	jitterFactor: .2
+};
+/**
+* Calculate delay for retry attempt.
+* Prefers server-specified Retry-After when available.
+*/
+function getRetryDelay(attempt, policy, serverRetryAfterMs) {
+	if (serverRetryAfterMs !== void 0 && serverRetryAfterMs >= 0) {
+		if (serverRetryAfterMs === 0) return 0;
+		const jitter = serverRetryAfterMs * policy.jitterFactor * Math.random();
+		return Math.min(serverRetryAfterMs + jitter, policy.maxDelayMs);
+	}
+	const exponentialDelay = policy.baseDelayMs * Math.pow(2, attempt);
+	const jitter = exponentialDelay * policy.jitterFactor * Math.random();
+	return Math.min(exponentialDelay + jitter, policy.maxDelayMs);
+}
+/**
+* Determine if we should retry a failed request.
+*/
+function shouldRetry(attempt, error, isRateLimited, policy) {
+	if (attempt >= policy.maxRetries) return false;
+	if (isHttpRateLimitError(error) && error.kind === "quota") return false;
+	if (isRateLimited) return true;
+	if (error) {
+		const message = (error.message ?? "").toLowerCase();
+		return isTransientConnectionError(error) || message.includes("timeout") || message.startsWith("websocket request timed out after ") || message.includes("econnrefused") || message.includes("network") || message.includes("503") || message.includes("502") || message.includes("504");
+	}
+	return false;
+}
+//#endregion
+//#region src/scheduler/slotQueue.ts
+const DEFAULT_QUEUE_TIMEOUT_MS = 3e5;
+/**
+* Manages concurrency slots with FIFO queue for waiting requests.
+*
+* Race condition prevention:
+* - All slot allocation goes through the queue
+* - processQueue() is synchronous and runs atomically
+* - No await between capacity check and increment
+*/
+var SlotQueue = class {
+	activeCount = 0;
+	maxConcurrency;
+	minConcurrency;
+	waiting = [];
+	resetTimer = null;
+	queueTimeoutMs;
+	resetAt = null;
+	remainingRequests = null;
+	remainingTokens = null;
+	requestLimit = null;
+	tokenLimit = null;
+	onSlotAcquired;
+	onSlotReleased;
+	constructor(options) {
+		this.maxConcurrency = options.maxConcurrency;
+		this.minConcurrency = options.minConcurrency;
+		this.queueTimeoutMs = options.queueTimeoutMs ?? DEFAULT_QUEUE_TIMEOUT_MS;
+		this.onSlotAcquired = options.onSlotAcquired;
+		this.onSlotReleased = options.onSlotReleased;
+	}
+	/**
+	* Acquire a slot. All requests go through the queue to prevent race conditions.
+	* Returns when a slot is available and quota is not exhausted. An aborted signal stops
+	* the request from waiting, but a slot that is free immediately is still granted.
+	*/
+	async acquire(requestId, abortSignal) {
+		return new Promise((resolve, reject) => {
+			let timeoutId;
+			const cleanup = () => {
+				if (timeoutId) clearTimeout(timeoutId);
+				abortSignal?.removeEventListener("abort", onAbort);
+			};
+			const removeAndReject = (error) => {
+				const index = this.waiting.indexOf(request);
+				if (index !== -1) {
+					this.waiting.splice(index, 1);
+					request.reject(error);
+					this.processQueue();
+				}
+			};
+			const onAbort = () => removeAndReject(abortSignal?.reason);
+			const request = {
+				id: requestId,
+				resolve: () => {
+					cleanup();
+					this.activeCount++;
+					this.onSlotAcquired?.(this.waiting.length);
+					resolve();
+				},
+				reject: (error) => {
+					cleanup();
+					reject(error);
+				}
+			};
+			if (this.queueTimeoutMs > 0) timeoutId = setTimeout(() => removeAndReject(/* @__PURE__ */ new Error(`Request ${requestId} timed out after ${this.queueTimeoutMs}ms in queue`)), this.queueTimeoutMs);
+			this.waiting.push(request);
+			abortSignal?.addEventListener("abort", onAbort, { once: true });
+			this.processQueue();
+			if (abortSignal?.aborted) onAbort();
+		});
+	}
+	/**
+	* Release a slot and process next queued request.
+	*/
+	release() {
+		if (this.activeCount <= 0) return;
+		this.activeCount--;
+		this.onSlotReleased?.(this.waiting.length);
+		this.processQueue();
+	}
+	/**
+	* Update rate limit state from parsed headers.
+	*/
+	updateRateLimitState(parsed) {
+		if (parsed.remainingRequests !== void 0) this.remainingRequests = parsed.remainingRequests;
+		if (parsed.limitRequests !== void 0) this.requestLimit = parsed.limitRequests;
+		if (parsed.remainingTokens !== void 0) this.remainingTokens = parsed.remainingTokens;
+		if (parsed.limitTokens !== void 0) this.tokenLimit = parsed.limitTokens;
+		if (parsed.resetAt !== void 0) {
+			this.resetAt = parsed.resetAt;
+			this.scheduleResetProcessing();
+		}
+	}
+	/**
+	* Mark that a rate limit was hit.
+	* Only updates resetAt if we don't already have a later reset time.
+	* A selected absolute deadline takes precedence over a relative retry delay.
+	*/
+	markRateLimited(retryAfterMs, selectedResetAt) {
+		this.remainingRequests = 0;
+		this.remainingTokens = 0;
+		let newResetAt = selectedResetAt;
+		if (newResetAt === void 0 && retryAfterMs !== void 0 && retryAfterMs >= 0) newResetAt = Date.now() + retryAfterMs;
+		if (newResetAt !== void 0) this.resetAt = Math.max(this.resetAt ?? newResetAt, newResetAt);
+		else if (this.resetAt === null) this.resetAt = Date.now() + 6e4;
+		this.scheduleResetProcessing();
+	}
+	/**
+	* Adjust max concurrency (called by adaptive algorithm).
+	*/
+	setMaxConcurrency(value) {
+		this.maxConcurrency = Math.max(this.minConcurrency, value);
+		this.processQueue();
+	}
+	getMaxConcurrency() {
+		return this.maxConcurrency;
+	}
+	getActiveCount() {
+		return this.activeCount;
+	}
+	getQueueDepth() {
+		return this.waiting.length;
+	}
+	getResetAt() {
+		return this.resetAt;
+	}
+	/**
+	* Check if quota is exhausted (should wait for reset).
+	* Checks BOTH request AND token quotas.
+	*
+	* NOTE: This method has intentional side effects - it clears stale quota state
+	* when the reset time has passed. This ensures we don't block indefinitely on
+	* outdated rate limit info.
+	*/
+	isQuotaExhausted() {
+		const now = Date.now();
+		if (this.resetAt && now >= this.resetAt) {
+			this.remainingRequests = null;
+			this.remainingTokens = null;
+			this.resetAt = null;
+			return false;
+		}
+		const quotaExhausted = (remaining) => remaining !== null && remaining <= 0 && this.resetAt && now < this.resetAt;
+		return !!(quotaExhausted(this.remainingRequests) || quotaExhausted(this.remainingTokens));
+	}
+	/**
+	* Schedule queue processing when rate limit window resets.
+	*/
+	scheduleResetProcessing() {
+		clearTimeout(this.resetTimer ?? void 0);
+		this.resetTimer = null;
+		if (this.resetAt && this.waiting.length > 0) {
+			const delay = Math.max(0, this.resetAt - Date.now());
+			this.resetTimer = setTimeout(() => {
+				this.resetTimer = null;
+				this.remainingRequests = null;
+				this.remainingTokens = null;
+				this.resetAt = null;
+				this.processQueue();
+			}, delay);
+		}
+	}
+	/**
+	* Process queued requests up to available capacity.
+	* SYNCHRONOUS - no awaits, prevents race conditions.
+	*/
+	processQueue() {
+		while (this.waiting.length > 0 && this.activeCount < this.maxConcurrency && !this.isQuotaExhausted()) this.waiting.shift().resolve();
+		if (this.waiting.length > 0 && this.isQuotaExhausted()) this.scheduleResetProcessing();
+		else if (this.resetTimer) {
+			clearTimeout(this.resetTimer);
+			this.resetTimer = null;
+		}
+	}
+	/**
+	* Check if approaching rate limit (for proactive throttling).
+	* Returns ratio of remaining/limit, or null if unknown.
+	*/
+	getRemainingRatio() {
+		let requestRatio = null;
+		let tokenRatio = null;
+		if (this.remainingRequests !== null && this.requestLimit !== null && this.requestLimit > 0) requestRatio = this.remainingRequests / this.requestLimit;
+		if (this.remainingTokens !== null && this.tokenLimit !== null && this.tokenLimit > 0) tokenRatio = this.remainingTokens / this.tokenLimit;
+		return {
+			requests: requestRatio,
+			tokens: tokenRatio
+		};
+	}
+	/**
+	* Cleanup resources.
+	*
+	* Rejects any pending acquire() promises with 'Queue disposed' error.
+	* Callers should handle these rejections (e.g., via .catch() on acquire promises).
+	*/
+	dispose() {
+		clearTimeout(this.resetTimer ?? void 0);
+		this.resetTimer = null;
+		const waiting = this.waiting;
+		this.waiting = [];
+		for (const request of waiting) request.reject(/* @__PURE__ */ new Error("Queue disposed"));
+	}
+};
+//#endregion
+//#region src/scheduler/providerRateLimitState.ts
+var RateLimitExhaustedError = class extends Error {
+	result;
+	constructor(message, result) {
+		super(message);
+		this.result = result;
+		this.name = "RateLimitExhaustedError";
+	}
+};
+/**
+* Wraps a finalizeResult throw so the retry classifier below skips it: a
+* finalizer failure is not provider work and must never trigger another call.
+*/
+var ResultFinalizationError = class extends Error {
+	original;
+	constructor(original) {
+		super("finalizeResult failed");
+		this.original = original;
+		this.name = "ResultFinalizationError";
+	}
+};
+/**
+* Manages rate limit state and retry logic for a single rate limit key.
+*/
+var ProviderRateLimitState = class extends EventEmitter {
+	rateLimitKey;
+	slotQueue;
+	adaptiveConcurrency;
+	retryPolicy;
+	totalRequests = 0;
+	completedRequests = 0;
+	failedRequests = 0;
+	rateLimitHits = 0;
+	retriedRequests = 0;
+	/** Keep the latest 100 latency measurements for bounded metric sorting and storage. */
+	latencies = [];
+	hasLearnedLimits = false;
+	constructor(options) {
+		super();
+		this.rateLimitKey = options.rateLimitKey;
+		this.retryPolicy = options.retryPolicy ?? DEFAULT_RETRY_POLICY;
+		this.adaptiveConcurrency = new AdaptiveConcurrency(options.maxConcurrency, options.minConcurrency);
+		this.slotQueue = new SlotQueue({
+			maxConcurrency: options.maxConcurrency,
+			minConcurrency: options.minConcurrency,
+			queueTimeoutMs: options.queueTimeoutMs,
+			onSlotAcquired: (queueDepth) => {
+				this.emit("slot:acquired", {
+					rateLimitKey: this.rateLimitKey,
+					queueDepth
+				});
+			},
+			onSlotReleased: (queueDepth) => {
+				this.emit("slot:released", {
+					rateLimitKey: this.rateLimitKey,
+					queueDepth
+				});
+			}
+		});
+	}
+	/**
+	* Execute a call with rate limiting and retry logic.
+	*/
+	async executeWithRetry(requestId, callFn, options) {
+		this.totalRequests++;
+		let attempt = 0;
+		const retryResults = [];
+		const retryPolicy = options.maxRetriesOverride === void 0 ? this.retryPolicy : {
+			...this.retryPolicy,
+			maxRetries: options.maxRetriesOverride
+		};
+		try {
+			while (true) {
+				try {
+					await this.slotQueue.acquire(`${requestId}-${attempt}`, options.abortSignal);
+				} catch (acquireError) {
+					this.emit(options.abortSignal?.aborted ? "queue:cancelled" : "queue:timeout", {
+						rateLimitKey: this.rateLimitKey,
+						requestId,
+						error: String(acquireError)
+					});
+					throw acquireError;
+				}
+				let ownsSlot = true;
+				let observedHeaders;
+				const onResponseHeaders = createResponseHeadersObserver(this, ([headers, backoff], alreadyObserved) => {
+					if (ownsSlot) {
+						if (backoff) {
+							if (!alreadyObserved) {
+								this.updateFromHeaders(headers, false, backoff.resetAt);
+								this.handleRateLimit(void 0, backoff.resetAt);
+							}
+						} else {
+							observedHeaders = headers;
+							if (!alreadyObserved) this.updateFromHeaders(headers, false);
+						}
+						return true;
+					}
+					return alreadyObserved;
+				});
+				const releaseSlot = () => {
+					if (ownsSlot) {
+						ownsSlot = false;
+						this.slotQueue.release();
+					}
+				};
+				const startTime = Date.now();
+				let retryError;
+				let retryResult;
+				let isRateLimited;
+				let isRetryableResult = false;
+				let retryAfterMs;
+				try {
+					throwIfAborted(options.abortSignal);
+					const result = await callFn(onResponseHeaders);
+					retryResult = result;
+					const hasErrorResponse = result !== null && typeof result === "object" && "error" in result && typeof result.error === "string" && result.error.length > 0;
+					const hasRefusalResponse = result !== null && typeof result === "object" && "isRefusal" in result && result.isRefusal === true;
+					const headers = options.getHeaders?.(result);
+					const isObserverError = isResponseHeadersObserverErrorResponse(result);
+					isRateLimited = options.canRetry?.() !== false && !isObserverError && (options.isRateLimited?.(result, void 0) ?? false);
+					isRetryableResult = options.canRetry?.() !== false && !isObserverError && (options.isRetryableResult?.(result) ?? false);
+					retryAfterMs = options.getRetryAfter?.(result, void 0);
+					if (!isObserverError && headers && (headers !== observedHeaders || isRateLimited)) this.updateFromHeaders(headers, isRateLimited);
+					if (isRateLimited) this.handleRateLimit(retryAfterMs);
+					if (this.latencies.push(Date.now() - startTime) > 100) this.latencies.shift();
+					releaseSlot();
+					if (options.abortSignal?.aborted && hasErrorResponse) {
+						this.failedRequests++;
+						return result;
+					}
+					if (!isRateLimited && !isRetryableResult || options.abortSignal?.aborted && hasRefusalResponse) {
+						let finalizedResult;
+						try {
+							finalizedResult = options.finalizeResult?.(result, retryResults) ?? result;
+						} catch (finalizerError) {
+							throw new ResultFinalizationError(finalizerError);
+						}
+						this.applyConcurrencyChange(this.adaptiveConcurrency.recordSuccess());
+						this.completedRequests++;
+						return finalizedResult;
+					}
+				} catch (error) {
+					if (ownsSlot) {
+						if (this.latencies.push(Date.now() - startTime) > 100) this.latencies.shift();
+					}
+					if (isResponseHeadersObserverError(onResponseHeaders, error)) throw error;
+					if (error instanceof ResultFinalizationError) throw error.original;
+					if (options.abortSignal?.aborted && (error === options.abortSignal.reason || !(error instanceof Error)) || error instanceof Error && (error.name === "AbortError" || error.name === "AbortException")) throw error;
+					retryError = error;
+					isRateLimited = options.canRetry?.() !== false && (options.isRateLimited?.(void 0, retryError) ?? this.isRateLimitError(retryError));
+					retryAfterMs = options.getRetryAfter?.(void 0, retryError);
+					if (isRateLimited) this.handleRateLimit(retryAfterMs);
+					if (options.abortSignal?.aborted) throw error;
+				} finally {
+					releaseSlot();
+				}
+				if (options.canRetry?.() === false || !shouldRetry(attempt, retryError, isRateLimited || isRetryableResult, retryPolicy)) {
+					if (retryError) throw retryError;
+					if (isRetryableResult) {
+						const finalizedResult = options.finalizeResult?.(retryResult, retryResults) ?? retryResult;
+						this.failedRequests++;
+						return finalizedResult;
+					}
+					if (!options.onRateLimitExhausted && options.finalizeResult) {
+						const finalizedResult = options.finalizeResult(retryResult, retryResults);
+						this.failedRequests++;
+						return finalizedResult;
+					}
+					throw new RateLimitExhaustedError(`Rate limit exceeded for ${this.rateLimitKey} after ${attempt + 1} attempts`, retryResult);
+				}
+				if (isRetryableResult && retryResult !== void 0) retryResults.push(retryResult);
+				attempt++;
+				await sleepWithAbort(this.recordRetry(attempt, retryPolicy, retryAfterMs, isRateLimited ? "ratelimit" : "error"), options.abortSignal);
+			}
+		} catch (error) {
+			this.failedRequests++;
+			throw error;
+		}
+	}
+	recordRetry(attempt, retryPolicy, retryAfterMs, reason) {
+		this.retriedRequests++;
+		const delayMs = getRetryDelay(attempt, retryPolicy, retryAfterMs);
+		this.emit("request:retrying", {
+			rateLimitKey: this.rateLimitKey,
+			attempt,
+			delayMs,
+			reason
+		});
+		return delayMs;
+	}
+	/**
+	* Update state from response headers.
+	* @param headers - Response headers
+	* @param isRateLimited - Whether the response indicates a rate limit (e.g., HTTP 429).
+	*   When false, retry-after headers are ignored to prevent incorrectly blocking the
+	*   queue on successful responses from providers/proxies that include these headers.
+	*/
+	updateFromHeaders(headers, isRateLimited, selectedResetAt) {
+		const parsed = parseRateLimitHeaders(headers);
+		if (selectedResetAt !== void 0) {
+			const existingResetAt = this.slotQueue.getResetAt();
+			parsed.resetAt = existingResetAt !== null && existingResetAt > Date.now() ? Math.max(existingResetAt, selectedResetAt) : selectedResetAt;
+		}
+		if (!this.hasLearnedLimits && (parsed.limitRequests !== void 0 || parsed.limitTokens !== void 0)) {
+			this.hasLearnedLimits = true;
+			this.emit("ratelimit:learned", {
+				rateLimitKey: this.rateLimitKey,
+				requestLimit: parsed.limitRequests,
+				tokenLimit: parsed.limitTokens
+			});
+		}
+		this.slotQueue.updateRateLimitState(parsed);
+		if (isRateLimited && parsed.retryAfterMs !== void 0) this.slotQueue.markRateLimited(parsed.retryAfterMs);
+		const ratios = this.slotQueue.getRemainingRatio();
+		const minRatio = Math.min(ratios.requests ?? 1, ratios.tokens ?? 1);
+		if (minRatio < .1) {
+			this.emit("ratelimit:warning", {
+				rateLimitKey: this.rateLimitKey,
+				requestRatio: ratios.requests,
+				tokenRatio: ratios.tokens
+			});
+			this.applyConcurrencyChange(this.adaptiveConcurrency.recordApproachingLimit(minRatio));
+		}
+	}
+	/**
+	* Handle rate limit hit.
+	* Delegates to SlotQueue which preserves existing resetAt from headers.
+	*/
+	handleRateLimit(retryAfterMs, selectedResetAt) {
+		this.rateLimitHits++;
+		this.slotQueue.markRateLimited(retryAfterMs, selectedResetAt);
+		const change = this.adaptiveConcurrency.recordRateLimit();
+		this.applyConcurrencyChange(change);
+		this.emit("ratelimit:hit", {
+			rateLimitKey: this.rateLimitKey,
+			retryAfterMs,
+			resetAt: this.slotQueue.getResetAt(),
+			concurrencyChange: change
+		});
+	}
+	/**
+	* Apply concurrency change and emit appropriate event.
+	*/
+	applyConcurrencyChange(change) {
+		if (change.changed) {
+			this.slotQueue.setMaxConcurrency(change.current);
+			this.emit(change.reason === "recovery" ? "concurrency:increased" : "concurrency:decreased", {
+				rateLimitKey: this.rateLimitKey,
+				...change
+			});
+		}
+	}
+	/**
+	* Check if error is a rate limit error.
+	*/
+	isRateLimitError(error) {
+		const message = (error.message ?? "").toLowerCase();
+		return message.includes("429") || message.includes("rate limit") || message.includes("too many requests");
+	}
+	/**
+	* Get current queue depth without sorting latencies.
+	* Use this for frequent checks instead of getMetrics().
+	*/
+	getQueueDepth() {
+		return this.slotQueue.getQueueDepth();
+	}
+	getMetrics() {
+		const sorted = [...this.latencies].sort((a, b) => a - b);
+		return {
+			rateLimitKey: this.rateLimitKey,
+			activeRequests: this.slotQueue.getActiveCount(),
+			maxConcurrency: this.slotQueue.getMaxConcurrency(),
+			queueDepth: this.slotQueue.getQueueDepth(),
+			totalRequests: this.totalRequests,
+			completedRequests: this.completedRequests,
+			failedRequests: this.failedRequests,
+			rateLimitHits: this.rateLimitHits,
+			retriedRequests: this.retriedRequests,
+			avgLatencyMs: sorted.length > 0 ? sorted.reduce((a, b) => a + b, 0) / sorted.length : 0,
+			p50LatencyMs: sorted[Math.floor((sorted.length - 1) * .5)] ?? 0,
+			p99LatencyMs: sorted[Math.floor((sorted.length - 1) * .99)] ?? 0
+		};
+	}
+	dispose() {
+		this.slotQueue.dispose();
+		this.removeAllListeners();
+	}
+};
+//#endregion
+//#region src/scheduler/rateLimitKey.ts
+/**
+* Generate a rate limit key that identifies a unique rate limit pool.
+* Same provider with different API keys/regions get different keys.
+*/
+function getRateLimitKey(provider) {
+	const providerId = provider.id();
+	const config = provider.config || {};
+	const relevantConfig = {};
+	if (config.apiKey && config.apiKey.length > 4) relevantConfig.apiKeyTail = config.apiKey.slice(-4);
+	if (config.apiBaseUrl) relevantConfig.apiBaseUrl = config.apiBaseUrl;
+	if (config.region) relevantConfig.region = config.region;
+	if (config.organization) relevantConfig.organization = config.organization;
+	const configParts = Object.entries(relevantConfig).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join("|");
+	if (configParts)
+ /**
+	* Hash a string using SHA-256.
+	* Returns first 12 chars of hex digest (48 bits).
+	*/
+	return `${providerId}[${createHash("sha256").update(configParts).digest("hex").slice(0, 12)}]`;
+	return providerId;
+}
+//#endregion
+//#region src/scheduler/rateLimitRegistry.ts
+/**
+* Per-eval registry that manages rate limit state for all providers.
+* NOT a singleton - create one per evaluation context.
+*/
+var RateLimitRegistry = class extends EventEmitter {
+	states = /* @__PURE__ */ new Map();
+	maxConcurrency;
+	minConcurrency;
+	queueTimeoutMs;
+	enabled;
+	constructor(options) {
+		super();
+		this.maxConcurrency = options.maxConcurrency;
+		this.minConcurrency = options.minConcurrency ?? getEnvInt("PROMPTFOO_MIN_CONCURRENCY", 1);
+		this.queueTimeoutMs = options.queueTimeoutMs ?? getEnvInt("PROMPTFOO_SCHEDULER_QUEUE_TIMEOUT_MS", 3e5);
+		this.enabled = !getEnvBool("PROMPTFOO_DISABLE_ADAPTIVE_SCHEDULER", false);
+	}
+	/**
+	* Execute a provider call with rate limiting and retries.
+	*
+	* Note: No idempotency tracking. Each call is independent.
+	* The single integration point (evaluator) ensures no double-wrapping.
+	*/
+	async execute(provider, callFn, options) {
+		const providerMaxRetries = getProviderMaxRetries(provider);
+		if (!this.enabled) return withFetchRetryContext(providerMaxRetries, () => runProviderCallWithAbort(callFn, options?.abortSignal));
+		const rateLimitKey = getRateLimitKey(provider);
+		const parentContext = getProviderCallExecutionContext();
+		if (parentContext?.rateLimitProvider && getRateLimitKey(parentContext.rateLimitProvider) !== rateLimitKey) parentContext.onNestedScheduledCall?.();
+		let nestedCallStarted = false;
+		if (!this.states.has(rateLimitKey)) {
+			const state = new ProviderRateLimitState({
+				rateLimitKey,
+				maxConcurrency: this.maxConcurrency,
+				minConcurrency: this.minConcurrency,
+				queueTimeoutMs: this.queueTimeoutMs
+			});
+			state.on("ratelimit:hit", (data) => this.emit("ratelimit:hit", data));
+			state.on("ratelimit:warning", (data) => this.emit("ratelimit:warning", data));
+			state.on("ratelimit:learned", (data) => this.emit("ratelimit:learned", data));
+			state.on("concurrency:increased", (data) => this.emit("concurrency:increased", data));
+			state.on("concurrency:decreased", (data) => this.emit("concurrency:decreased", data));
+			state.on("request:retrying", (data) => this.emit("request:retrying", data));
+			this.states.set(rateLimitKey, state);
+		}
+		const state = this.states.get(rateLimitKey);
+		const requestId = `${rateLimitKey}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+		this.emit("request:started", {
+			rateLimitKey,
+			requestId,
+			queueDepth: state.getQueueDepth()
+		});
+		const run = () => state.executeWithRetry(requestId, (onResponseHeaders) => {
+			const executionContext = getProviderCallExecutionContext();
+			return executionContext ? withProviderCallExecutionContext({
+				...executionContext,
+				rateLimitRegistry: this,
+				rateLimitProvider: provider,
+				onNestedScheduledCall: () => {
+					nestedCallStarted = true;
+				}
+			}, () => callFn(onResponseHeaders)) : callFn(onResponseHeaders);
+		}, {
+			abortSignal: options?.abortSignal,
+			getHeaders: (result) => nestedCallStarted ? void 0 : options?.getHeaders?.(result),
+			isRateLimited: options?.isRateLimited,
+			isRetryableResult: options?.isRetryableResult,
+			finalizeResult: options?.finalizeResult,
+			onRateLimitExhausted: options?.onRateLimitExhausted,
+			canRetry: () => !nestedCallStarted,
+			getRetryAfter: options?.getRetryAfter,
+			maxRetriesOverride: provider.handlesOwnRetries ? 0 : providerMaxRetries
+		});
+		try {
+			const result = await withFetchRetryContext(providerMaxRetries, () => runProviderCallWithAbort(run, options?.abortSignal));
+			this.emit("request:completed", {
+				rateLimitKey,
+				requestId
+			});
+			return result;
+		} catch (error) {
+			this.emit("request:failed", {
+				rateLimitKey,
+				requestId,
+				error: String(error)
+			});
+			if (error instanceof RateLimitExhaustedError && options?.onRateLimitExhausted) return options.onRateLimitExhausted(error.result, error);
+			throw error;
+		}
+	}
+	/**
+	* Get metrics for all tracked providers.
+	*/
+	getMetrics() {
+		const metrics = {};
+		for (const [key, state] of this.states) metrics[key] = state.getMetrics();
+		return metrics;
+	}
+	/**
+	* Cleanup all resources.
+	*/
+	dispose() {
+		for (const state of this.states.values()) state.dispose();
+		this.states.clear();
+		this.removeAllListeners();
+	}
+};
+/**
+* Read the provider's configured maxRetries value, tolerating numeric strings
+* (e.g. from environment overrides) and rejecting invalid values.
+*
+* Returning `undefined` means "fall back to defaults" — distinct from `0`, which
+* means "disable retries". Invalid user-supplied values (negatives, floats,
+* non-numeric strings) are logged so config typos aren't silently ignored.
+*/
+function getProviderMaxRetries(provider) {
+	const raw = provider.config && typeof provider.config === "object" ? provider.config.maxRetries : void 0;
+	if (raw === void 0) return;
+	if (typeof raw === "number" && Number.isInteger(raw) && raw >= 0) return raw;
+	if (typeof raw === "string") {
+		const trimmed = raw.trim();
+		if (/^\d+$/.test(trimmed)) {
+			const parsed = Number(trimmed);
+			if (Number.isSafeInteger(parsed)) return parsed;
+		}
+	}
+	logger.warn("[RateLimit] Ignoring invalid provider.config.maxRetries; expected a non-negative integer.", {
+		maxRetries: raw,
+		providerId: sanitizeProviderIdForLog(provider.id())
+	});
+}
+//#endregion
+//#region src/util/tokenUsage.ts
+/**
+* A utility class for tracking token usage across an evaluation.
+*
+* @deprecated Use OpenTelemetry tracing instead for per-call token tracking.
+* This class provides only cumulative totals and will be removed in a future version.
+*
+* For new implementations, use the OTEL-based tracing infrastructure:
+* - Enable tracing with `PROMPTFOO_OTEL_ENABLED=true`
+* - Token usage is automatically captured as GenAI semantic convention span attributes
+*
+* @see src/tracing/genaiTracer.ts for the new tracing implementation
+*/
+var TokenUsageTracker = class TokenUsageTracker {
+	static instance;
+	providersMap = /* @__PURE__ */ new Map();
+	constructor() {}
+	/**
+	* Get the singleton instance of TokenUsageTracker
+	*/
+	static getInstance() {
+		if (!TokenUsageTracker.instance) TokenUsageTracker.instance = new TokenUsageTracker();
+		return TokenUsageTracker.instance;
+	}
+	/**
+	* Track token usage for a provider
+	* @param provider The provider to track usage for
+	* @param usage The token usage to track
+	*/
+	trackUsage(providerId, usage = { numRequests: 1 }) {
+		const updated = { ...this.providersMap.get(providerId) ?? createEmptyTokenUsage() };
+		accumulateTokenUsage(updated, usage);
+		this.providersMap.set(providerId, updated);
+		logger.debug(`Tracked token usage for ${sanitizeProviderIdForLog(providerId)}: total=${usage.total ?? 0}, cached=${usage.cached ?? 0}`);
+	}
+	/**
+	* Track token usage from one provider response while preserving the shared
+	* response-aware request-counting contract.
+	*/
+	trackResponseUsage(providerId, response) {
+		if (!response) return;
+		let tokenUsage;
+		try {
+			const rawTokenUsage = response.tokenUsage;
+			if (rawTokenUsage) {
+				const parsedTokenUsage = BaseTokenUsageSchema.safeParse(rawTokenUsage);
+				if (parsedTokenUsage.success) tokenUsage = parsedTokenUsage.data;
+			}
+		} catch {
+			tokenUsage = void 0;
+		}
+		const updated = { ...this.providersMap.get(providerId) ?? createEmptyTokenUsage() };
+		const accounting = createEmptyTokenUsage();
+		accumulateResponseTokenUsage(accounting, {
+			cached: response.cached,
+			tokenUsage
+		});
+		accumulateTokenUsage(updated, {
+			...accounting.incurredTokenUsage ?? accounting,
+			cached: accounting.cached
+		});
+		this.providersMap.set(providerId, updated);
+		logger.debug(`Tracked response usage for ${sanitizeProviderIdForLog(providerId)}: total=${tokenUsage?.total ?? 0}, cached=${tokenUsage?.cached ?? 0}`);
+	}
+	/**
+	* Get the cumulative token usage for a specific provider
+	* @param providerId The ID of the provider to get usage for
+	* @returns A detached snapshot of the token usage for the provider
+	*/
+	getProviderUsage(providerId) {
+		return structuredClone(this.providersMap.get(providerId));
+	}
+	/**
+	* Get all provider IDs that have token usage tracked
+	* @returns Array of provider IDs
+	*/
+	getProviderIds() {
+		return Array.from(this.providersMap.keys());
+	}
+	/**
+	* Get aggregated token usage across all providers
+	* @returns Aggregated token usage
+	*/
+	getTotalUsage() {
+		const result = createEmptyTokenUsage();
+		for (const usage of this.providersMap.values()) accumulateTokenUsage(result, usage);
+		return result;
+	}
+	/**
+	* Reset token usage for a specific provider
+	* @param providerId The ID of the provider to reset
+	*/
+	resetProviderUsage(providerId) {
+		this.providersMap.delete(providerId);
+	}
+	/**
+	* Reset token usage for all providers
+	*/
+	resetAllUsage() {
+		this.providersMap.clear();
+	}
+	/**
+	* Cleanup method to prevent memory leaks
+	*/
+	cleanup() {
+		this.providersMap.clear();
+	}
+};
+//#endregion
+//#region src/redteam/grading/storedResult.ts
+/** Opaque runtime values cannot safely identify a reusable assertion configuration. */
+function getGradingAssertionHash(assertion) {
+	if (!assertion) return;
+	try {
+		const serialized = JSON.stringify(assertion, function(key, value) {
+			const original = this[key];
+			if (typeof original === "function" || typeof original === "symbol") throw new Error("Assertion contains a runtime value");
+			if (original && typeof original === "object") {
+				const prototype = Object.getPrototypeOf(original);
+				if (prototype !== Object.prototype && prototype !== Array.prototype && prototype !== null || typeof original.toJSON === "function") throw new Error("Assertion contains a runtime object");
+			}
+			return value;
+		});
+		return createHash("sha256").update(serialized).digest("hex");
+	} catch {
+		return;
+	}
+}
+/** Bind a verdict to its target turn without persisting another copy of the conversation. */
+function getGradingInputHash(prompt, output, messages, pluginId) {
+	const conversation = Array.isArray(messages) ? messages.filter((message) => (message?.role === "user" || message?.role === "assistant") && typeof message.content === "string").map(({ role, content }) => ({
+		role,
+		content
+	})) : [];
+	return createHash("sha256").update(JSON.stringify([
+		pluginId,
+		prompt,
+		output,
+		conversation
+	])).digest("hex");
+}
+function getTargetConversation(messages) {
+	if (!Array.isArray(messages)) return {};
+	let lastUserIndex = -1;
+	for (let index = messages.length - 1; index >= 0; index--) if (messages[index]?.role === "user" && typeof messages[index].content === "string") {
+		lastUserIndex = index;
+		break;
+	}
+	if (lastUserIndex < 0 || !messages[lastUserIndex].content.trim()) return {};
+	const conversationTranscript = messages.slice(0, lastUserIndex).filter((message) => (message?.role === "user" || message?.role === "assistant") && typeof message.content === "string").map((message) => `${message.role === "user" ? "User" : "Assistant"}: ${message.content}`).join("\n\n");
+	return {
+		lastUserPrompt: messages[lastUserIndex].content,
+		conversationTranscript
+	};
+}
+/** Attach cumulative usage without marking fresh work as a cached response. */
+function withGradingUsage(result, tokensUsed) {
+	if (result.metadata?.cachedResponse === true && (tokensUsed?.numRequests ?? 0) > 0) {
+		const { cachedResponse: _cachedResponse, ...metadata } = result.metadata;
+		return {
+			...result,
+			metadata,
+			tokensUsed
+		};
+	}
+	return {
+		...result,
+		tokensUsed
+	};
+}
+//#endregion
+//#region src/redteam/shared/promptLength.ts
+const MAX_CHARS_PER_MESSAGE_MODIFIER_KEY = "maxCharsPerMessage";
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function getMaxCharsPerMessage(limit) {
+	const maxCharsPerMessage = limit ?? state.config?.redteam?.maxCharsPerMessage;
+	if (typeof maxCharsPerMessage !== "number" || !Number.isInteger(maxCharsPerMessage) || maxCharsPerMessage <= 0) return;
+	return maxCharsPerMessage;
+}
+function parseChatMessages(prompt) {
+	try {
+		const parsed = JSON.parse(prompt);
+		if (Array.isArray(parsed) && parsed.every((item) => isRecord(item) && typeof item.role === "string" && typeof item.content === "string")) return parsed.map((message, index) => ({
+			content: message.content,
+			path: `[${index}].content`,
+			role: message.role
+		}));
+		if (isRecord(parsed) && parsed._promptfoo_audio_hybrid === true && (parsed.history === void 0 || Array.isArray(parsed.history)) && isRecord(parsed.currentTurn) && typeof parsed.currentTurn.role === "string" && typeof parsed.currentTurn.transcript === "string" && (parsed.history === void 0 || parsed.history.every((item) => isRecord(item) && typeof item.role === "string" && typeof item.content === "string"))) return [...(parsed.history ?? []).map((message, index) => ({
+			content: message.content,
+			path: `history[${index}].content`,
+			role: message.role
+		})), {
+			content: parsed.currentTurn.transcript,
+			path: "currentTurn.transcript",
+			role: parsed.currentTurn.role
+		}];
+	} catch {}
+}
+function getPromptLengthViolation(prompt, limit) {
+	const maxCharsPerMessage = getMaxCharsPerMessage(limit);
+	if (!maxCharsPerMessage) return;
+	const messages = parseChatMessages(prompt);
+	if (messages) {
+		const oversizedMessage = messages.find((message) => message.role === "user" && message.content.length > maxCharsPerMessage);
+		return oversizedMessage ? {
+			length: oversizedMessage.content.length,
+			limit: maxCharsPerMessage,
+			path: oversizedMessage.path
+		} : void 0;
+	}
+	if (prompt.length <= maxCharsPerMessage) return;
+	return {
+		length: prompt.length,
+		limit: maxCharsPerMessage,
+		path: "prompt"
+	};
+}
+function getMaxCharsPerMessageModifierValue(limit) {
+	const maxCharsPerMessage = getMaxCharsPerMessage(limit);
+	if (!maxCharsPerMessage) return;
+	return `Each generated user message must be ${maxCharsPerMessage} characters or fewer.`;
+}
+function getGeneratedPromptOverLimit(prompt, limit) {
+	const violation = getPromptLengthViolation(prompt, limit);
+	if (!violation) return;
+	return {
+		length: violation.length,
+		limit: violation.limit
+	};
+}
+function throwIfTargetPromptExceedsMaxChars(prompt, limit) {
+	const violation = getPromptLengthViolation(prompt, limit);
+	if (!violation) return;
+	throw new Error(`Target prompt message at ${violation.path} exceeds maxCharsPerMessage=${violation.limit}: ${violation.length} characters.`);
+}
+//#endregion
+//#region src/redteam/providers/constants.ts
+const ATTACKER_MODEL = "gpt-5.5-2026-04-23";
+const ATTACKER_MODEL_SMALL = "gpt-5.4-mini-2026-03-17";
+const TEMPERATURE = getEnvFloat("PROMPTFOO_JAILBREAK_TEMPERATURE") ? getEnvFloat("PROMPTFOO_JAILBREAK_TEMPERATURE") : .7;
+/** Count a blocking-analysis task as grading without treating it as a target or attacker call. */
+function accumulateUnblockingTokenUsage(totalTokenUsage, result) {
+	if (!result.attempted && !result.tokenUsage) return;
+	accumulateGradingResponseTokenUsage(totalTokenUsage, {
+		cached: result.cached,
+		tokenUsage: result.tokenUsage?.assertions ?? result.tokenUsage
+	});
+}
+const defaultRedteamProviderLoader = async (providers) => {
+	const { loadApiProviders } = await import("./providers-CpJlgHET.js").then((n) => n.i);
+	return loadApiProviders(providers);
+};
+let redteamProviderLoader = defaultRedteamProviderLoader;
+async function loadRedteamProvider({ provider, jsonOnly = false, preferSmallModel = false, purpose = "redteam" } = {}) {
+	let ret;
+	const redteamProvider = provider;
+	if (isApiProvider(redteamProvider)) {
+		logger.debug(`Using ${purpose} provider: ${redteamProvider}`);
+		ret = redteamProvider;
+	} else if (typeof redteamProvider === "string" || isProviderOptions(redteamProvider)) {
+		logger.debug(`Loading ${purpose} provider`, { provider: redteamProvider });
+		ret = (await redteamProviderLoader([redteamProvider]))[0];
+	} else {
+		const defaultModel = preferSmallModel ? ATTACKER_MODEL_SMALL : ATTACKER_MODEL;
+		logger.debug(`Using default ${purpose} provider: ${defaultModel}`);
+		ret = new OpenAiChatCompletionProvider(defaultModel, { config: {
+			temperature: TEMPERATURE,
+			response_format: jsonOnly ? { type: "json_object" } : void 0
+		} });
+	}
+	return ret;
+}
+var RedteamProviderManager = class {
+	provider;
+	providerSpec;
+	jsonOnlyProvider;
+	multilingualProvider;
+	gradingProvider;
+	gradingJsonOnlyProvider;
+	rateLimitRegistry;
+	/**
+	* Set the rate limit registry to use for wrapping providers.
+	* When set, all providers returned by this manager will be wrapped
+	* with rate limiting.
+	*/
+	setRateLimitRegistry(registry) {
+		this.rateLimitRegistry = registry;
+	}
+	/**
+	* Wrap a provider with rate limiting if a registry is configured.
+	*/
+	wrapProvider(provider) {
+		if (this.rateLimitRegistry) return wrapProviderWithRateLimiting(provider, this.rateLimitRegistry);
+		return provider;
+	}
+	clearProvider() {
+		this.provider = void 0;
+		this.providerSpec = void 0;
+		this.jsonOnlyProvider = void 0;
+		this.multilingualProvider = void 0;
+		this.gradingProvider = void 0;
+		this.gradingJsonOnlyProvider = void 0;
+	}
+	async setProvider(provider) {
+		const loadedProvider = await loadRedteamProvider({ provider });
+		const loadedJsonOnlyProvider = await loadRedteamProvider({
+			provider,
+			jsonOnly: true
+		});
+		this.providerSpec = typeof provider === "string" || isProviderOptions(provider) ? provider : void 0;
+		this.provider = loadedProvider;
+		this.jsonOnlyProvider = loadedJsonOnlyProvider;
+	}
+	getDefaultTestProvider() {
+		if (typeof state.config?.defaultTest !== "object") return;
+		return state.config.defaultTest?.provider || state.config.defaultTest?.options?.provider?.text || state.config.defaultTest?.options?.provider || void 0;
+	}
+	resolveProviderCandidate({ provider, fallbackProvider, ignoreCliState = false } = {}) {
+		const toSpec = (value) => typeof value === "string" || isProviderOptions(value) ? value : void 0;
+		if (provider) return {
+			source: "explicit",
+			provider,
+			spec: toSpec(provider)
+		};
+		if (this.provider && this.jsonOnlyProvider) return {
+			source: "cache",
+			cachedProvider: this.provider,
+			cachedJsonOnlyProvider: this.jsonOnlyProvider,
+			spec: this.providerSpec
+		};
+		if (fallbackProvider) return {
+			source: "fallback",
+			provider: fallbackProvider,
+			spec: toSpec(fallbackProvider)
+		};
+		if (ignoreCliState) return { source: "default" };
+		const configuredProvider = state.config?.redteam?.provider;
+		if (configuredProvider) return {
+			source: "explicit",
+			provider: configuredProvider,
+			spec: toSpec(configuredProvider)
+		};
+		const defaultTestProvider = this.getDefaultTestProvider();
+		if (defaultTestProvider) return {
+			source: "explicit",
+			provider: defaultTestProvider,
+			spec: toSpec(defaultTestProvider)
+		};
+		return { source: "default" };
+	}
+	async loadProviderCandidate(candidate, { jsonOnly = false, preferSmallModel = false } = {}) {
+		if (candidate.source === "cache") {
+			const cachedProvider = jsonOnly ? candidate.cachedJsonOnlyProvider : candidate.cachedProvider;
+			invariant(cachedProvider, "Expected cached redteam provider variant to be set");
+			logger.debug("[RedteamProviderManager] Using cached redteam provider: " + cachedProvider.id());
+			return this.wrapProvider(cachedProvider);
+		}
+		const loaded = await loadRedteamProvider({
+			provider: candidate.provider,
+			jsonOnly,
+			preferSmallModel
+		});
+		logger.debug("[RedteamProviderManager] Loaded " + candidate.source + " redteam provider: " + loaded.id());
+		return this.wrapProvider(loaded);
+	}
+	/**
+	* Resolves runtime provider, provenance, local-only spec, and safe persisted ID
+	* through one precedence walk.
+	*/
+	async getProviderSelection({ provider, fallbackProvider, ignoreCliState = false, jsonOnly = false, preferSmallModel = false } = {}) {
+		const candidate = this.resolveProviderCandidate({
+			provider,
+			fallbackProvider,
+			ignoreCliState
+		});
+		return {
+			provider: await this.loadProviderCandidate(candidate, {
+				jsonOnly,
+				preferSmallModel
+			}),
+			source: candidate.source,
+			localProviderSpec: candidate.spec,
+			persistableId: typeof candidate.spec === "string" ? candidate.spec : void 0
+		};
+	}
+	/**
+	* Loads the built-in attacker model without consulting cache or CLI state.
+	*/
+	async getDefaultProvider({ jsonOnly = false, preferSmallModel = false } = {}) {
+		const provider = await loadRedteamProvider({
+			jsonOnly,
+			preferSmallModel
+		});
+		return this.wrapProvider(provider);
+	}
+	async setMultilingualProvider(provider) {
+		this.multilingualProvider = await loadRedteamProvider({
+			provider,
+			jsonOnly: true
+		});
+	}
+	async setGradingProvider(provider) {
+		this.gradingProvider = await loadRedteamProvider({
+			provider,
+			purpose: "grading"
+		});
+		this.gradingJsonOnlyProvider = await loadRedteamProvider({
+			provider,
+			jsonOnly: true,
+			purpose: "grading"
+		});
+	}
+	async getProvider({ provider, fallbackProvider, ignoreCliState = false, jsonOnly = false, preferSmallModel = false }) {
+		return (await this.getProviderSelection({
+			provider,
+			fallbackProvider,
+			ignoreCliState,
+			jsonOnly,
+			preferSmallModel
+		})).provider;
+	}
+	async getGradingProvider({ provider, jsonOnly = false } = {}) {
+		if (provider) {
+			const loaded = await loadRedteamProvider({
+				provider,
+				jsonOnly,
+				purpose: "grading"
+			});
+			return this.wrapProvider(loaded);
+		}
+		if (this.gradingProvider && this.gradingJsonOnlyProvider) {
+			logger.debug(`[RedteamProviderManager] Using cached grading provider: ${this.gradingProvider.id()}`);
+			return this.wrapProvider(jsonOnly ? this.gradingJsonOnlyProvider : this.gradingProvider);
+		}
+		const cfg = typeof state.config?.defaultTest === "object" && (state.config?.defaultTest)?.provider || typeof state.config?.defaultTest === "object" && (state.config?.defaultTest)?.options?.provider?.text || typeof state.config?.defaultTest === "object" && (state.config?.defaultTest)?.options?.provider || void 0;
+		if (cfg) {
+			const loaded = await loadRedteamProvider({
+				provider: cfg,
+				jsonOnly,
+				purpose: "grading"
+			});
+			logger.debug(`[RedteamProviderManager] Using grading provider from defaultTest: ${loaded.id()}`);
+			return this.wrapProvider(loaded);
+		}
+		return this.getProvider({ jsonOnly });
+	}
+	async getMultilingualProvider() {
+		if (this.multilingualProvider) {
+			logger.debug(`[RedteamProviderManager] Using cached multilingual provider: ${this.multilingualProvider.id()}`);
+			return this.wrapProvider(this.multilingualProvider);
+		}
+		logger.debug("[RedteamProviderManager] No multilingual provider configured");
+	}
+};
+const redteamProviderManager = new RedteamProviderManager();
+/** Retain only the selected error's origin when a strategy rebuilds its response. */
+function preserveSelectedError(response, selected) {
+	if (!response.error || !selected?.error) return response;
+	if (selected.metadata?.errorOrigin === "tool") response.metadata = {
+		...response.metadata,
+		errorOrigin: "tool"
+	};
+	return preserveResponseHeadersObserverErrorResponse(selected, response);
+}
+function isConversationEndedResponse(response) {
+	return Boolean(response?.conversationEnded);
+}
+function getTargetPromptMaxCharsPerMessage(context) {
+	const configuredLimit = (context?.test?.metadata?.strategyConfig)?.maxCharsPerMessage ?? (context?.test?.metadata?.pluginConfig)?.maxCharsPerMessage;
+	if (typeof configuredLimit !== "number" || !Number.isInteger(configuredLimit) || configuredLimit <= 0) return;
+	return configuredLimit;
+}
+/** Invoke a red-team target with the same tracing behavior across every strategy. */
+function callTargetProvider(targetProvider, targetPrompt, context, options) {
+	const executionContext = getProviderCallExecutionContext();
+	const tracingContext = getProviderCallTracingContext();
+	const invoke = (onResponseHeaders) => {
+		const targetOptions = onResponseHeaders ? {
+			...options,
+			onResponseHeaders: composeResponseHeadersObservers(onResponseHeaders, options?.onResponseHeaders)
+		} : options;
+		const call = async (callContext) => {
+			const response = await targetProvider.callApi(targetPrompt, callContext, targetOptions);
+			executionContext?.onTargetResponse?.(targetPrompt, response);
+			return response;
+		};
+		return tracingContext ? tracingContext.withProviderSpan({
+			provider: targetProvider,
+			callContext: context
+		}, call) : call(context);
+	};
+	const registry = executionContext?.rateLimitRegistry;
+	const activeProvider = executionContext?.rateLimitProvider;
+	if (registry && !isRateLimitWrapped(targetProvider) && (!activeProvider || getRateLimitKey(activeProvider) !== getRateLimitKey(targetProvider))) return registry.execute(targetProvider, invoke, createProviderRateLimitOptions(options?.abortSignal));
+	return invoke();
+}
+/** Preserve caller cancellation across target and strategy error accounting. */
+function isTargetCallAbortError(error, signal) {
+	return error instanceof Error && error.name === "AbortError" || isCallerAbortError(error, signal, { requireReasonMatch: true });
+}
+/** Keep strategy judge calls beneath grader-owned spans without changing their requests. */
+function callGradingProvider(provider, prompt, callContext, options) {
+	const invoke = (context) => options === void 0 ? provider.callApi(prompt, context) : provider.callApi(prompt, context, options);
+	const tracingContext = getProviderCallTracingContext();
+	if (!tracingContext) return invoke(callContext);
+	return tracingContext.withGraderSpan({
+		graderId: callContext?.prompt.label ?? "judge",
+		evalId: callContext?.evaluationId,
+		testIndex: callContext?.testIdx ?? tracingContext.testIndex
+	}, () => tracingContext.withProviderSpan({
+		provider,
+		callContext,
+		role: "grader"
+	}, invoke));
+}
+/**
+* Gets the response from the target provider for a given prompt.
+* @param targetProvider - The API provider to get the response from.
+* @param targetPrompt - The prompt to send to the target provider.
+* @returns A promise that resolves to the target provider's response as an object.
+*/
+async function getTargetResponse(targetProvider, targetPrompt, context, options) {
+	let targetRespRaw;
+	try {
+		throwIfTargetPromptExceedsMaxChars(targetPrompt, getTargetPromptMaxCharsPerMessage(context));
+		targetRespRaw = await callTargetProvider(targetProvider, targetPrompt, context, options);
+	} catch (error) {
+		if (isTargetCallAbortError(error, options?.abortSignal)) throw error;
+		return preserveResponseHeadersObserverError(options?.onResponseHeaders, error, {
+			output: "",
+			error: error.message,
+			tokenUsage: { numRequests: error instanceof Error && error.message.includes("maxCharsPerMessage=") ? 0 : 1 }
+		});
+	}
+	if (!targetRespRaw.cached && targetProvider.delay && targetProvider.delay > 0 && !options?.abortSignal?.aborted) {
+		logger.debug(`Sleeping for ${targetProvider.delay}ms`);
+		try {
+			await sleepWithAbort(targetProvider.delay, options?.abortSignal);
+		} catch (error) {
+			if (!isCallerAbortError(error, options?.abortSignal, { requireReasonMatch: true })) throw error;
+		}
+	}
+	const tokenUsage = {
+		numRequests: 1,
+		...targetRespRaw.tokenUsage
+	};
+	const hasOutput = targetRespRaw && Object.prototype.hasOwnProperty.call(targetRespRaw, "output") && targetRespRaw.output != null;
+	if (targetRespRaw?.error) {
+		const output = hasOutput ? typeof targetRespRaw.output === "string" ? targetRespRaw.output : safeJsonStringify(targetRespRaw.output) : "";
+		return preserveSelectedError({
+			...targetRespRaw,
+			output,
+			error: targetRespRaw.error,
+			tokenUsage
+		}, targetRespRaw);
+	}
+	if (hasOutput) {
+		const output = typeof targetRespRaw.output === "string" ? targetRespRaw.output : safeJsonStringify(targetRespRaw.output);
+		return {
+			...targetRespRaw,
+			output,
+			tokenUsage
+		};
+	}
+	if (targetRespRaw?.conversationEnded) return {
+		...targetRespRaw,
+		output: "",
+		tokenUsage
+	};
+	return {
+		...targetRespRaw,
+		output: "",
+		error: "Target returned malformed response: expected either `output` or `error` property to be set. Empty strings are valid output values; null and undefined are not.",
+		tokenUsage
+	};
+}
+/** Trace every strategy grader at one boundary, including graders with custom getResult methods. */
+function runRedteamGrader(grader, prompt, output, test, ...args) {
+	const invoke = () => grader.getResult(prompt, output, test, ...args);
+	const tracingContext = getProviderCallTracingContext();
+	if (!tracingContext) return invoke();
+	return tracingContext.withGraderSpan({
+		graderId: grader.id,
+		evalId: test.metadata?.evaluationId,
+		testIndex: tracingContext.testIndex
+	}, invoke);
+}
+/** Preserve the latest verdict while retaining usage from every strategy grading turn. */
+function accumulateGraderResult(previous, current, input) {
+	if (input) current = {
+		...current,
+		metadata: {
+			...current.metadata,
+			redteamGradingAssertionHash: getGradingAssertionHash(input.assertion),
+			redteamGradingInputHash: getGradingInputHash(input.prompt, input.output, input.messages, input.pluginId)
+		}
+	};
+	const normalizeGradingTaskUsage = (result) => {
+		if (!result.tokensUsed) return;
+		const reportedTotal = result.tokensUsed.total ?? (result.tokensUsed.prompt ?? 0) + (result.tokensUsed.completion ?? 0);
+		const cachedTokens = result.tokensUsed.cached ?? 0;
+		if (result.metadata?.cachedResponse === true || result.tokensUsed.numRequests === 0 && reportedTotal <= cachedTokens) return {
+			total: 0,
+			prompt: 0,
+			completion: 0,
+			cached: Math.max(cachedTokens, reportedTotal),
+			numRequests: 0
+		};
+		return {
+			...result.tokensUsed,
+			numRequests: 1
+		};
+	};
+	if (!previous?.tokensUsed) {
+		const tokensUsed = normalizeGradingTaskUsage(current);
+		if (!tokensUsed) return current;
+		return withGradingUsage(current, tokensUsed);
+	}
+	const previousTokensUsed = previous.metadata?.cachedResponse === true && (previous.tokensUsed.numRequests ?? 0) > 0 ? previous.tokensUsed : normalizeGradingTaskUsage(previous);
+	if (!previousTokensUsed) return current;
+	const tokensUsed = {
+		...previousTokensUsed,
+		numRequests: previous.tokensUsed.numRequests || previousTokensUsed.numRequests,
+		...previous.tokensUsed.completionDetails ? { completionDetails: { ...previous.tokensUsed.completionDetails } } : {}
+	};
+	const currentTokensUsed = normalizeGradingTaskUsage(current);
+	if (currentTokensUsed) accumulateTokenUsage(tokensUsed, currentTokensUsed);
+	return withGradingUsage(current, tokensUsed);
+}
+/** Keep the verdict and its inputs together; grader errors do not identify vulnerabilities. */
+function captureFlaggedTurn(graderResult, turn) {
+	if (graderResult.pass || graderResult.metadata?.graderError === true) return;
+	return {
+		graderResult,
+		...turn,
+		messages: [...turn.messages]
+	};
+}
+/** Preserve the flagged verdict with grading usage from all turns. */
+function resolveStoredGraderResult(flaggedResult, storedGraderResult) {
+	return flaggedResult ? withGradingUsage(flaggedResult, storedGraderResult?.tokensUsed) : storedGraderResult;
+}
+/**
+* Validates if a parsed JSON object is a valid chat message array
+*/
+function isValidChatMessageArray(parsed) {
+	return Array.isArray(parsed) && parsed.every((msg) => msg && typeof msg === "object" && "role" in msg && "content" in msg && typeof msg.role === "string" && typeof msg.content === "string" && [
+		"user",
+		"assistant",
+		"system",
+		"developer"
+	].includes(msg.role));
+}
+const getLastMessageContent = (messages, role) => messages.filter((m) => m?.role === role).slice(-1)[0]?.content;
+/**
+* Converts an array of messages to the redteamHistory format
+* @param messages Array of messages with role and content
+* @returns Array of prompt-output pairs, or empty array if conversion fails
+*/
+const messagesToRedteamHistory = (messages) => {
+	try {
+		return messages.reduce((acc, msg, i, arr) => {
+			if (msg?.role === "user" && i < arr.length - 1 && arr[i + 1]?.role === "assistant") acc.push({
+				prompt: msg.content || "",
+				output: arr[i + 1].content || ""
+			});
+			return acc;
+		}, []);
+	} catch (error) {
+		logger.debug(`Failed to convert messages to redteamHistory: ${error}`);
+		return [];
+	}
+};
+/**
+* Formats redteam turn history as a readable transcript for context-aware graders.
+* This keeps conversation context separate from the latest assistant output under test.
+*/
+function formatRedteamHistoryAsTranscript(history) {
+	return history.map((turn, index) => `Turn ${index + 1}:\nUser: ${turn.prompt}\nAssistant: ${turn.output}`).join("\n\n");
+}
+function checkPenalizedPhrases(output) {
+	const partialMatchPhrases = ["in the face of impending doom", "science fiction"];
+	const exactMatchPhrases = ["yes, i can help you", "yes, i can help you with that"];
+	const hasPartialMatch = partialMatchPhrases.some((phrase) => output.toLowerCase().includes(phrase));
+	const hasExactMatch = exactMatchPhrases.includes(output.toLowerCase().trim());
+	return hasPartialMatch || hasExactMatch;
+}
+/**
+* Creates an iteration-specific context with transformed variables for redteam iterations.
+* This utility function handles the common pattern of re-running transformVars for each
+* iteration to generate fresh values (e.g., new sessionId).
+*
+* @param originalVars - The original variables before transformation
+* @param transformVarsConfig - The transform configuration from the test
+* @param context - The original context that may be updated
+* @param iterationNumber - The current iteration number (for logging)
+* @param loggerTag - The logger tag to use for debug messages (e.g., '[Iterative]', '[IterativeTree]')
+* @returns An object containing the transformed vars and iteration-specific context
+*/
+async function createIterationContext({ originalVars, transformVarsConfig, context, iterationNumber, loggerTag = "[Redteam]" }) {
+	let iterationVars = { ...originalVars };
+	if (transformVarsConfig) {
+		logger.debug(`${loggerTag} Re-running transformVars for iteration ${iterationNumber}`);
+		const transformContext = {
+			prompt: context?.prompt || {},
+			uuid: randomUUID()
+		};
+		try {
+			const transformedVars = await transform(transformVarsConfig, originalVars, transformContext, true, TransformInputType.VARS);
+			invariant(typeof transformedVars === "object", "Transform function did not return a valid object");
+			iterationVars = {
+				...originalVars,
+				...transformedVars
+			};
+			logger.debug(`${loggerTag} Transformed vars for iteration ${iterationNumber}`, { transformedVars });
+		} catch (error) {
+			logger.error(`${loggerTag} Error transforming vars`, { error });
+			if (typeof transformVarsConfig === "function") throw error;
+		}
+	}
+	return context ? {
+		...context,
+		vars: iterationVars
+	} : void 0;
+}
+/**
+* Externalize large blob payloads in provider responses before they are copied into
+* redteam conversation/history (prevents meta prompts from exploding with base64).
+*/
+async function externalizeResponseForRedteamHistory(response, context) {
+	if (!isBlobStorageEnabled() && !shouldAttemptRemoteBlobUpload()) return response;
+	return await extractAndStoreBinaryData(response, context) || response;
+}
+/**
+* Shared unblocking functionality used by redteam providers to handle blocking questions
+*/
+async function tryUnblocking({ messages, lastResponse, goal, purpose, targetId }) {
+	try {
+		if (!getEnvBool("PROMPTFOO_ENABLE_UNBLOCKING")) {
+			logger.debug("[Unblocking] Disabled by default (set PROMPTFOO_ENABLE_UNBLOCKING=true to enable)");
+			return { success: false };
+		}
+		const { checkServerFeatureSupport } = await import("./server-C7b8z6aC.js").then((n) => n.n);
+		if (!await checkServerFeatureSupport("blocking-question-analysis", "2025-06-16T14:49:11-07:00")) {
+			logger.debug("[Unblocking] Server does not support unblocking, skipping gracefully");
+			return { success: false };
+		}
+		logger.debug("[Unblocking] Attempting to unblock with blocking-question-analysis task");
+		const unblockingProvider = new PromptfooChatCompletionProvider({
+			task: "blocking-question-analysis",
+			jsonOnly: true,
+			preferSmallModel: false,
+			...remoteGenerationContextPayload(targetId)
+		});
+		const unblockingRequest = {
+			conversationObjective: goal || "",
+			recentHistory: messages.map((msg) => ({
+				role: msg.role,
+				content: msg.content
+			})),
+			targetResponse: lastResponse,
+			purpose: purpose || ""
+		};
+		const response = await unblockingProvider.callApi(JSON.stringify(unblockingRequest), {
+			prompt: {
+				raw: JSON.stringify(unblockingRequest),
+				label: "unblocking"
+			},
+			vars: {}
+		});
+		TokenUsageTracker.getInstance().trackResponseUsage(unblockingProvider.id(), response);
+		if (response.error) {
+			logger.error(`[Unblocking] Unblocking provider error: ${response.error}`);
+			return {
+				attempted: true,
+				cached: response.cached,
+				success: false,
+				tokenUsage: response.tokenUsage
+			};
+		}
+		const parsed = response.output;
+		logger.debug("[Unblocking] Unblocking analysis", { analysis: parsed });
+		if (parsed.isBlocking && parsed.unblockingAnswer) {
+			logger.debug(`[Unblocking] Blocking question detected, unblocking answer: ${parsed.unblockingAnswer}`);
+			return {
+				attempted: true,
+				cached: response.cached,
+				success: true,
+				tokenUsage: response.tokenUsage,
+				unblockingPrompt: parsed.unblockingAnswer
+			};
+		} else {
+			logger.debug("[Unblocking] No blocking question detected");
+			return {
+				attempted: true,
+				cached: response.cached,
+				success: false,
+				tokenUsage: response.tokenUsage
+			};
+		}
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") throw error;
+		logger.error(`[Unblocking] Error in unblocking flow: ${error}`);
+		return { success: false };
+	}
+}
+function isSingleAssertion(assertToUse) {
+	return Boolean(assertToUse && assertToUse.type !== "assert-set");
+}
+/**
+* Builds the assertion object for storedGraderResult with the rubric value.
+* This ensures the grading template is preserved for display in the UI.
+*/
+function buildGraderResultAssertion(gradeAssertion, assertToUse, rubric) {
+	if (gradeAssertion) return {
+		...gradeAssertion,
+		value: rubric
+	};
+	if (isSingleAssertion(assertToUse)) return {
+		...assertToUse,
+		value: rubric
+	};
+}
+function getGraderAssertionValue(assertToUse) {
+	if (!isSingleAssertion(assertToUse)) return;
+	return assertToUse.value;
+}
+//#endregion
+export { withGradingUsage as A, getProviderCallTracingContext as B, MAX_CHARS_PER_MESSAGE_MODIFIER_KEY as C, getGradingAssertionHash as D, throwIfTargetPromptExceedsMaxChars as E, shouldAttemptRemoteBlobUpload as F, withProviderCallExecutionContext as H, uploadBlobRemote as I, createProviderRateLimitOptions as L, RateLimitRegistry as M, sleepWithAbort as N, getGradingInputHash as O, throwIfAborted as P, isRateLimitWrapped as R, tryUnblocking as S, getMaxCharsPerMessageModifierValue as T, withProviderCallTracingContext as U, runProviderCallWithAbort as V, messagesToRedteamHistory as _, callTargetProvider as a, resolveStoredGraderResult as b, createIterationContext as c, getGraderAssertionValue as d, getLastMessageContent as f, isValidChatMessageArray as g, isTargetCallAbortError as h, callGradingProvider as i, TokenUsageTracker as j, getTargetConversation as k, externalizeResponseForRedteamHistory as l, isConversationEndedResponse as m, accumulateUnblockingTokenUsage as n, captureFlaggedTurn as o, getTargetResponse as p, buildGraderResultAssertion as r, checkPenalizedPhrases as s, accumulateGraderResult as t, formatRedteamHistoryAsTranscript as u, preserveSelectedError as v, getGeneratedPromptOverLimit as w, runRedteamGrader as x, redteamProviderManager as y, getProviderCallExecutionContext as z };
+
+//# sourceMappingURL=shared-tfPT8Tna.js.map