promptfoo 0.120.26 → 0.121.1

package/dist/src/messages-D8EA0oDc.js

@@ -0,0 +1,240 @@
+import { b as getEnvString, i as logger, v as getEnvFloat, y as getEnvInt } from "./logger-DLcq4dWf.js";
+import { C as transformTools, S as transformToolChoice } from "./fetch-4M3YRaqL.js";
+import { a as isCacheEnabled, i as getCache } from "./cache-D3eqDYGU.js";
+import { a as createEmptyTokenUsage } from "./tokenUsageUtils-BDGe-iyI.js";
+import { n as withGenAISpan } from "./genaiTracer-70Z8BIuV.js";
+import { D as maybeLoadResponseFormatFromExternalFile, O as maybeLoadToolsFromExternalFile } from "./util-5cB-L7U3.js";
+import { i as normalizeFinishReason, n as MCPClient } from "./chat-BKm79wib.js";
+import { n as transformMCPToolsToAnthropic } from "./transform-DGxXocjk.js";
+import { a as parseMessages, i as outputFromMessage, n as calculateAnthropicCost, o as processAnthropicTools, r as getTokenUsage, t as ANTHROPIC_MODELS } from "./util-ZZH-3QZz.js";
+import Anthropic, { APIError } from "@anthropic-ai/sdk";
+//#region src/providers/anthropic/generic.ts
+/**
+* Generic provider class for Anthropic APIs
+* Serves as a base class with shared functionality for all Anthropic providers
+*/
+var AnthropicGenericProvider = class {
+	modelName;
+	config;
+	env;
+	apiKey;
+	anthropic;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.env = env;
+		this.modelName = modelName;
+		this.config = config || {};
+		this.apiKey = this.getApiKey();
+		this.anthropic = new Anthropic({
+			apiKey: this.apiKey,
+			baseURL: this.getApiBaseUrl()
+		});
+		this.id = id ? () => id : this.id;
+	}
+	id() {
+		return `anthropic:${this.modelName}`;
+	}
+	toString() {
+		return `[Anthropic Provider ${this.modelName}]`;
+	}
+	requiresApiKey() {
+		return true;
+	}
+	getApiKey() {
+		return this.config?.apiKey || this.env?.ANTHROPIC_API_KEY || getEnvString("ANTHROPIC_API_KEY");
+	}
+	getApiBaseUrl() {
+		return this.config?.apiBaseUrl || this.env?.ANTHROPIC_BASE_URL || getEnvString("ANTHROPIC_BASE_URL");
+	}
+	/**
+	* Base implementation - should be overridden by specific provider implementations
+	*/
+	async callApi(_prompt, _context) {
+		throw new Error("Not implemented: callApi must be implemented by subclasses");
+	}
+};
+//#endregion
+//#region src/providers/anthropic/messages.ts
+var AnthropicMessagesProvider = class AnthropicMessagesProvider extends AnthropicGenericProvider {
+	mcpClient = null;
+	initializationPromise = null;
+	static ANTHROPIC_MODELS = ANTHROPIC_MODELS;
+	static ANTHROPIC_MODELS_NAMES = ANTHROPIC_MODELS.map((model) => model.id);
+	constructor(modelName, options = {}) {
+		if (!AnthropicMessagesProvider.ANTHROPIC_MODELS_NAMES.includes(modelName)) logger.warn(`Using unknown Anthropic model: ${modelName}`);
+		super(modelName, options);
+		const { id } = options;
+		this.id = id ? () => id : this.id;
+		if (this.config.mcp?.enabled) this.initializationPromise = this.initializeMCP();
+	}
+	async initializeMCP() {
+		this.mcpClient = new MCPClient(this.config.mcp);
+		await this.mcpClient.initialize();
+	}
+	async cleanup() {
+		if (this.mcpClient) {
+			await this.initializationPromise;
+			await this.mcpClient.cleanup();
+			this.mcpClient = null;
+		}
+	}
+	toString() {
+		if (!this.modelName) throw new Error("Anthropic model name is not set. Please provide a valid model name.");
+		return `[Anthropic Messages Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context) {
+		if (this.initializationPromise != null) await this.initializationPromise;
+		if (!this.apiKey) throw new Error("Anthropic API key is not set. Set the ANTHROPIC_API_KEY environment variable or add `apiKey` to the provider config.");
+		if (!this.modelName) throw new Error("Anthropic model name is not set. Please provide a valid model name.");
+		const spanContext = {
+			system: "anthropic",
+			operationName: "chat",
+			model: this.modelName,
+			providerId: this.id(),
+			maxTokens: this.config.max_tokens,
+			temperature: this.config.temperature,
+			testIndex: context?.test?.vars?.__testIdx,
+			promptLabel: context?.prompt?.label,
+			traceparent: context?.traceparent,
+			requestBody: prompt
+		};
+		const resultExtractor = (response) => {
+			const result = {};
+			if (response.tokenUsage) result.tokenUsage = {
+				prompt: response.tokenUsage.prompt,
+				completion: response.tokenUsage.completion,
+				total: response.tokenUsage.total,
+				cached: response.tokenUsage.cached
+			};
+			if (response.finishReason) result.finishReasons = [response.finishReason];
+			if (response.cached !== void 0) result.cacheHit = response.cached;
+			if (response.output !== void 0) result.responseBody = typeof response.output === "string" ? response.output : JSON.stringify(response.output);
+			return result;
+		};
+		return withGenAISpan(spanContext, () => this.callApiInternal(prompt, context), resultExtractor);
+	}
+	/**
+	* Internal implementation of callApi without tracing wrapper.
+	*/
+	async callApiInternal(prompt, context) {
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const { system, extractedMessages, thinking } = parseMessages(prompt);
+		let mcpTools = [];
+		if (this.mcpClient) mcpTools = transformMCPToolsToAnthropic(this.mcpClient.getAllTools());
+		const { processedTools: processedConfigTools, requiredBetaFeatures } = processAnthropicTools(transformTools(await maybeLoadToolsFromExternalFile(config.tools, context?.vars) || [], "anthropic"));
+		const allTools = [...mcpTools, ...processedConfigTools];
+		const processedOutputFormat = maybeLoadResponseFormatFromExternalFile(config.output_format, context?.vars);
+		const shouldStream = config.stream ?? false;
+		const params = {
+			model: this.modelName,
+			...system ? { system } : {},
+			max_tokens: config?.max_tokens || getEnvInt("ANTHROPIC_MAX_TOKENS", config.thinking || thinking ? 2048 : 1024),
+			messages: extractedMessages,
+			stream: shouldStream,
+			temperature: config.thinking || thinking ? config.temperature : config.temperature || getEnvFloat("ANTHROPIC_TEMPERATURE", 0),
+			...allTools.length > 0 ? { tools: allTools } : {},
+			...config.tool_choice ? { tool_choice: transformToolChoice(config.tool_choice, "anthropic") } : {},
+			...config.thinking || thinking ? { thinking: config.thinking || thinking } : {},
+			...processedOutputFormat || config.effort ? { output_config: {
+				...processedOutputFormat ? { format: processedOutputFormat } : {},
+				...config.effort ? { effort: config.effort } : {}
+			} } : {},
+			...typeof config?.extra_body === "object" && config.extra_body ? config.extra_body : {}
+		};
+		logger.debug("Calling Anthropic Messages API", { params });
+		const headers = { ...config.headers || {} };
+		let allBetaFeatures = [...config.beta || [], ...requiredBetaFeatures];
+		if (processedOutputFormat && !allBetaFeatures.includes("structured-outputs-2025-11-13")) allBetaFeatures.push("structured-outputs-2025-11-13");
+		allBetaFeatures = [...new Set(allBetaFeatures)];
+		if (allBetaFeatures.length > 0) headers["anthropic-beta"] = allBetaFeatures.join(",");
+		const cache = await getCache();
+		const cacheKey = `anthropic:${JSON.stringify(params)}`;
+		if (isCacheEnabled()) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				logger.debug(`Returning cached response for ${prompt}: ${cachedResponse}`);
+				try {
+					const parsedCachedResponse = JSON.parse(cachedResponse);
+					const finishReason = normalizeFinishReason(parsedCachedResponse.stop_reason);
+					let output = outputFromMessage(parsedCachedResponse, config.showThinking ?? true);
+					if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+						output = JSON.parse(output);
+					} catch (error) {
+						logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+					}
+					return {
+						output,
+						tokenUsage: getTokenUsage(parsedCachedResponse, true),
+						...finishReason && { finishReason },
+						cost: calculateAnthropicCost(this.modelName, config, parsedCachedResponse.usage?.input_tokens, parsedCachedResponse.usage?.output_tokens),
+						cached: true
+					};
+				} catch {
+					return {
+						output: cachedResponse,
+						tokenUsage: createEmptyTokenUsage()
+					};
+				}
+			}
+		}
+		try {
+			if (shouldStream) {
+				const finalMessage = await (await this.anthropic.messages.stream(params, { ...typeof headers === "object" && Object.keys(headers).length > 0 ? { headers } : {} })).finalMessage();
+				logger.debug(`Anthropic Messages API streaming complete`, { finalMessage });
+				if (isCacheEnabled()) try {
+					await cache.set(cacheKey, JSON.stringify(finalMessage));
+				} catch (err) {
+					logger.error(`Failed to cache response: ${String(err)}`);
+				}
+				const finishReason = normalizeFinishReason(finalMessage.stop_reason);
+				let output = outputFromMessage(finalMessage, config.showThinking ?? true);
+				if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+					output = JSON.parse(output);
+				} catch (error) {
+					logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+				}
+				return {
+					output,
+					tokenUsage: getTokenUsage(finalMessage, false),
+					...finishReason && { finishReason },
+					cost: calculateAnthropicCost(this.modelName, config, finalMessage.usage?.input_tokens, finalMessage.usage?.output_tokens)
+				};
+			} else {
+				const response = await this.anthropic.messages.create(params, { ...typeof headers === "object" && Object.keys(headers).length > 0 ? { headers } : {} });
+				logger.debug(`Anthropic Messages API response`, { response });
+				if (isCacheEnabled()) try {
+					await cache.set(cacheKey, JSON.stringify(response));
+				} catch (err) {
+					logger.error(`Failed to cache response: ${String(err)}`);
+				}
+				const finishReason = normalizeFinishReason(response.stop_reason);
+				let output = outputFromMessage(response, config.showThinking ?? true);
+				if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+					output = JSON.parse(output);
+				} catch (error) {
+					logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+				}
+				return {
+					output,
+					tokenUsage: getTokenUsage(response, false),
+					...finishReason && { finishReason },
+					cost: calculateAnthropicCost(this.modelName, config, response.usage?.input_tokens, response.usage?.output_tokens)
+				};
+			}
+		} catch (err) {
+			logger.error(`Anthropic Messages API call error: ${err instanceof Error ? err.message : String(err)}`);
+			if (err instanceof APIError && err.error) {
+				const errorDetails = err.error;
+				return { error: `API call error: ${errorDetails.error.message}, status ${err.status}, type ${errorDetails.error.type}` };
+			}
+			return { error: `API call error: ${err instanceof Error ? err.message : String(err)}` };
+		}
+	}
+};
+//#endregion
+export { AnthropicGenericProvider as n, AnthropicMessagesProvider as t };
+
+//# sourceMappingURL=messages-D8EA0oDc.js.map

package/dist/src/{meteor-P2rUE-Uz.js → meteor-44VjEACX.js}

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
-import { t as invariant } from "./invariant-DT20jrBd.js";
-
+import { t as invariant } from "./invariant-BtWWVVhl.js";
 //#region src/assertions/meteor.ts
 let PorterStemmer;
 let WordNet;
@@ -130,7 +129,7 @@ async function handleMeteorAssertion({ assertion, inverse, outputString, rendere
 		assertion
 	};
 }
-
 //#endregion
 export { handleMeteorAssertion };
-//# sourceMappingURL=meteor-P2rUE-Uz.js.map
+
+//# sourceMappingURL=meteor-44VjEACX.js.map

package/dist/src/{meteor-SLNTgmXm.js → meteor-D-SotUw9.js}

@@ -1,5 +1,4 @@
-import { M as invariant } from "./server/index.js";
-
+import { t as invariant } from "./invariant-vgHWClmd.js";
 //#region src/assertions/meteor.ts
 let PorterStemmer;
 let WordNet;
@@ -129,7 +128,7 @@ async function handleMeteorAssertion({ assertion, inverse, outputString, rendere
 		assertion
 	};
 }
-
 //#endregion
 export { handleMeteorAssertion };
-//# sourceMappingURL=meteor-SLNTgmXm.js.map
+
+//# sourceMappingURL=meteor-D-SotUw9.js.map

package/dist/src/{meteor-odmwVbyG.cjs → meteor-DLZZ3osF.cjs}

@@ -1,5 +1,4 @@
-const require_invariant = require('./invariant-CKcJAQ6M.cjs');
-
+const require_invariant = require("./invariant-kfQ8Bu82.cjs");
 //#region src/assertions/meteor.ts
 let PorterStemmer;
 let WordNet;
@@ -129,7 +128,7 @@ async function handleMeteorAssertion({ assertion, inverse, outputString, rendere
 		assertion
 	};
 }
-
 //#endregion
 exports.handleMeteorAssertion = handleMeteorAssertion;
-//# sourceMappingURL=meteor-odmwVbyG.cjs.map
+
+//# sourceMappingURL=meteor-DLZZ3osF.cjs.map

package/dist/src/{meteor-Dj8cTkU_.js → meteor-DUiCJRC-.js}

@@ -1,5 +1,4 @@
-import { t as invariant } from "./invariant-1pAf2CD1.js";
-
+import { t as invariant } from "./invariant-Ddh24eXh.js";
 //#region src/assertions/meteor.ts
 let PorterStemmer;
 let WordNet;
@@ -129,7 +128,7 @@ async function handleMeteorAssertion({ assertion, inverse, outputString, rendere
 		assertion
 	};
 }
-
 //#endregion
 export { handleMeteorAssertion };
-//# sourceMappingURL=meteor-Dj8cTkU_.js.map
+
+//# sourceMappingURL=meteor-DUiCJRC-.js.map

package/dist/src/modelslab-C1OLRmVX.js

@@ -0,0 +1,166 @@
+import { b as getEnvString, i as logger } from "./logger-CT3IKMKA.js";
+import "./types-CLKiCBW3.js";
+import { p as REQUEST_TIMEOUT_MS, t as fetchWithProxy } from "./fetch-60Gzydls.js";
+import { r as fetchWithCache } from "./cache-8XhNqPKW.js";
+import "./accounts-xrUGFA6n.js";
+import { r as storeBlob } from "./blobs-Bpg5rH6i.js";
+import "./tables-5EvT_Bwn.js";
+import { n as isBlobStorageEnabled } from "./extractor-M67RUtg6.js";
+import { t as ellipsize } from "./text-B_UCRPp2.js";
+//#region src/providers/modelslab.ts
+/**
+* ModelsLab provider for text-to-image generation.
+*
+* Handles async polling: initial response may return {status: "processing"},
+* in which case we poll the fetch endpoint until completion.
+*
+* API docs: https://docs.modelslab.com
+*
+* NOTE: ModelsLab uses key-in-body authentication (not Bearer header).
+* The API key is sent as the "key" field in the JSON request body.
+*/
+const MODELSLAB_BASE_URL = "https://modelslab.com/api/v6";
+const POLL_INTERVAL_MS = 3e3;
+const MAX_POLL_ATTEMPTS = 60;
+var ModelsLabImageProvider = class {
+	modelName;
+	apiKey;
+	config;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || env?.MODELSLAB_API_KEY || getEnvString("MODELSLAB_API_KEY");
+		const { apiKey: _apiKey, ...restConfig } = config ?? {};
+		this.config = restConfig;
+		this.id = id ? () => id : this.id;
+	}
+	id() {
+		return `modelslab:image:${this.modelName}`;
+	}
+	toString() {
+		return `[ModelsLab Image Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context, _callApiOptions) {
+		if (!this.apiKey) return { error: "ModelsLab API key is not set. Set the MODELSLAB_API_KEY environment variable or add `apiKey` to the provider config." };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const requestBody = {
+			key: this.apiKey,
+			model_id: this.modelName,
+			prompt,
+			width: config.width ?? 512,
+			height: config.height ?? 512,
+			num_inference_steps: config.num_inference_steps ?? 30,
+			guidance_scale: config.guidance_scale ?? 7.5,
+			samples: config.samples ?? 1,
+			safety_checker: config.safety_checker ?? "no",
+			enhance_prompt: config.enhance_prompt ?? "no"
+		};
+		if (config.negative_prompt) requestBody.negative_prompt = config.negative_prompt;
+		if (config.seed !== void 0) requestBody.seed = config.seed;
+		try {
+			logger.debug("[ModelsLab] Image generation request", {
+				model: this.modelName,
+				prompt: ellipsize(prompt, 50)
+			});
+			const response = await fetchWithCache(`${MODELSLAB_BASE_URL}/images/text2img`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(requestBody)
+			}, REQUEST_TIMEOUT_MS, "json", true);
+			let data = response.data;
+			let cached = response.cached;
+			if (data.status === "processing") {
+				const requestId = data.request_id ?? String(data.id);
+				logger.debug("[ModelsLab] Image is processing, polling for result", {
+					model: this.modelName,
+					requestId
+				});
+				data = await this.pollForCompletion(requestId);
+				cached = false;
+			}
+			if (data.status === "error") return {
+				cached,
+				error: `ModelsLab API error: ${data.message || "Unknown error"}`
+			};
+			if (data.status === "success") {
+				if (!data.output || data.output.length === 0) return { error: "ModelsLab returned no image URLs" };
+				const imageUrl = data.output[0];
+				const { url: resolvedUrl, blobRef } = await this.maybeDownloadToBlob(imageUrl);
+				return {
+					output: `![${ellipsize(prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")"), 50)}](${resolvedUrl})`,
+					cached,
+					...blobRef && { metadata: {
+						blobRef,
+						blobHash: blobRef.hash
+					} }
+				};
+			}
+			return { error: `Unexpected ModelsLab response status: ${data.status}` };
+		} catch (err) {
+			return { error: `ModelsLab API call error: ${String(err)}` };
+		}
+	}
+	async maybeDownloadToBlob(imageUrl) {
+		if (!isBlobStorageEnabled()) return { url: imageUrl };
+		try {
+			const response = await fetchWithProxy(imageUrl);
+			if (!response.ok) {
+				logger.warn("[ModelsLab] Failed to download image for blob storage", {
+					url: imageUrl,
+					status: response.status
+				});
+				return { url: imageUrl };
+			}
+			const { ref } = await storeBlob(Buffer.from(await response.arrayBuffer()), response.headers.get("content-type")?.split(";")[0] || "image/png", {
+				location: "response.output",
+				kind: "image"
+			});
+			return {
+				url: ref.uri,
+				blobRef: ref
+			};
+		} catch (error) {
+			logger.warn("[ModelsLab] Failed to store image as blob, using URL", {
+				url: imageUrl,
+				error: String(error)
+			});
+			return { url: imageUrl };
+		}
+	}
+	async pollForCompletion(requestId) {
+		const fetchUrl = `${MODELSLAB_BASE_URL}/images/fetch/${requestId}`;
+		for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			try {
+				const data = (await fetchWithCache(fetchUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ key: this.apiKey })
+				}, REQUEST_TIMEOUT_MS, "json", true)).data;
+				logger.debug("[ModelsLab] Poll attempt", {
+					attempt: attempt + 1,
+					requestId,
+					status: data.status
+				});
+				if (data.status === "success" || data.status === "error") return data;
+			} catch (error) {
+				logger.warn("[ModelsLab] Poll attempt failed", {
+					attempt: attempt + 1,
+					requestId,
+					error: String(error)
+				});
+			}
+		}
+		return {
+			status: "error",
+			message: `ModelsLab image generation timed out after ${MAX_POLL_ATTEMPTS * POLL_INTERVAL_MS / 1e3}s`
+		};
+	}
+};
+//#endregion
+export { ModelsLabImageProvider };
+
+//# sourceMappingURL=modelslab-C1OLRmVX.js.map

package/dist/src/modelslab-CqXBy3U8.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+import { C as getEnvString, o as logger } from "./logger-KkObSCzq.js";
+import { f as REQUEST_TIMEOUT_MS, n as fetchWithProxy } from "./fetch-BMv0O527.js";
+import "./accounts-CMqkzrVf.js";
+import "./cloud-Bc9526yV.js";
+import "./types-CH3Ge2sE.js";
+import { a as fetchWithCache } from "./cache-CG0SlR1d.js";
+import { i as storeBlob } from "./blobs-BAU-dXan.js";
+import "./tables-D36WTqKX.js";
+import { n as isBlobStorageEnabled } from "./extractor-CFG6bcWJ.js";
+import { t as ellipsize } from "./text-Db-Wt2u2.js";
+//#region src/providers/modelslab.ts
+/**
+* ModelsLab provider for text-to-image generation.
+*
+* Handles async polling: initial response may return {status: "processing"},
+* in which case we poll the fetch endpoint until completion.
+*
+* API docs: https://docs.modelslab.com
+*
+* NOTE: ModelsLab uses key-in-body authentication (not Bearer header).
+* The API key is sent as the "key" field in the JSON request body.
+*/
+const MODELSLAB_BASE_URL = "https://modelslab.com/api/v6";
+const POLL_INTERVAL_MS = 3e3;
+const MAX_POLL_ATTEMPTS = 60;
+var ModelsLabImageProvider = class {
+	modelName;
+	apiKey;
+	config;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || env?.MODELSLAB_API_KEY || getEnvString("MODELSLAB_API_KEY");
+		const { apiKey: _apiKey, ...restConfig } = config ?? {};
+		this.config = restConfig;
+		this.id = id ? () => id : this.id;
+	}
+	id() {
+		return `modelslab:image:${this.modelName}`;
+	}
+	toString() {
+		return `[ModelsLab Image Provider ${this.modelName}]`;
+	}
+	async callApi(prompt, context, _callApiOptions) {
+		if (!this.apiKey) return { error: "ModelsLab API key is not set. Set the MODELSLAB_API_KEY environment variable or add `apiKey` to the provider config." };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const requestBody = {
+			key: this.apiKey,
+			model_id: this.modelName,
+			prompt,
+			width: config.width ?? 512,
+			height: config.height ?? 512,
+			num_inference_steps: config.num_inference_steps ?? 30,
+			guidance_scale: config.guidance_scale ?? 7.5,
+			samples: config.samples ?? 1,
+			safety_checker: config.safety_checker ?? "no",
+			enhance_prompt: config.enhance_prompt ?? "no"
+		};
+		if (config.negative_prompt) requestBody.negative_prompt = config.negative_prompt;
+		if (config.seed !== void 0) requestBody.seed = config.seed;
+		try {
+			logger.debug("[ModelsLab] Image generation request", {
+				model: this.modelName,
+				prompt: ellipsize(prompt, 50)
+			});
+			const response = await fetchWithCache(`${MODELSLAB_BASE_URL}/images/text2img`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(requestBody)
+			}, REQUEST_TIMEOUT_MS, "json", true);
+			let data = response.data;
+			let cached = response.cached;
+			if (data.status === "processing") {
+				const requestId = data.request_id ?? String(data.id);
+				logger.debug("[ModelsLab] Image is processing, polling for result", {
+					model: this.modelName,
+					requestId
+				});
+				data = await this.pollForCompletion(requestId);
+				cached = false;
+			}
+			if (data.status === "error") return {
+				cached,
+				error: `ModelsLab API error: ${data.message || "Unknown error"}`
+			};
+			if (data.status === "success") {
+				if (!data.output || data.output.length === 0) return { error: "ModelsLab returned no image URLs" };
+				const imageUrl = data.output[0];
+				const { url: resolvedUrl, blobRef } = await this.maybeDownloadToBlob(imageUrl);
+				return {
+					output: `![${ellipsize(prompt.replace(/\r?\n|\r/g, " ").replace(/\[/g, "(").replace(/\]/g, ")"), 50)}](${resolvedUrl})`,
+					cached,
+					...blobRef && { metadata: {
+						blobRef,
+						blobHash: blobRef.hash
+					} }
+				};
+			}
+			return { error: `Unexpected ModelsLab response status: ${data.status}` };
+		} catch (err) {
+			return { error: `ModelsLab API call error: ${String(err)}` };
+		}
+	}
+	async maybeDownloadToBlob(imageUrl) {
+		if (!isBlobStorageEnabled()) return { url: imageUrl };
+		try {
+			const response = await fetchWithProxy(imageUrl);
+			if (!response.ok) {
+				logger.warn("[ModelsLab] Failed to download image for blob storage", {
+					url: imageUrl,
+					status: response.status
+				});
+				return { url: imageUrl };
+			}
+			const { ref } = await storeBlob(Buffer.from(await response.arrayBuffer()), response.headers.get("content-type")?.split(";")[0] || "image/png", {
+				location: "response.output",
+				kind: "image"
+			});
+			return {
+				url: ref.uri,
+				blobRef: ref
+			};
+		} catch (error) {
+			logger.warn("[ModelsLab] Failed to store image as blob, using URL", {
+				url: imageUrl,
+				error: String(error)
+			});
+			return { url: imageUrl };
+		}
+	}
+	async pollForCompletion(requestId) {
+		const fetchUrl = `${MODELSLAB_BASE_URL}/images/fetch/${requestId}`;
+		for (let attempt = 0; attempt < MAX_POLL_ATTEMPTS; attempt++) {
+			await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			try {
+				const data = (await fetchWithCache(fetchUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ key: this.apiKey })
+				}, REQUEST_TIMEOUT_MS, "json", true)).data;
+				logger.debug("[ModelsLab] Poll attempt", {
+					attempt: attempt + 1,
+					requestId,
+					status: data.status
+				});
+				if (data.status === "success" || data.status === "error") return data;
+			} catch (error) {
+				logger.warn("[ModelsLab] Poll attempt failed", {
+					attempt: attempt + 1,
+					requestId,
+					error: String(error)
+				});
+			}
+		}
+		return {
+			status: "error",
+			message: `ModelsLab image generation timed out after ${MAX_POLL_ATTEMPTS * POLL_INTERVAL_MS / 1e3}s`
+		};
+	}
+};
+//#endregion
+export { ModelsLabImageProvider };
+
+//# sourceMappingURL=modelslab-CqXBy3U8.js.map