promptfoo 0.120.26 → 0.121.1

package/dist/src/pythonUtils-D6fwaDSg.js

@@ -0,0 +1,249 @@
+import { _ as getEnvBool, b as getEnvString, i as logger, m as safeJsonStringify } from "./logger-DLcq4dWf.js";
+import { n as getWrapperDir } from "./esm-CaIwzWR5.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { promisify } from "util";
+import { execFile } from "child_process";
+import { PythonShell } from "python-shell";
+//#region src/python/pythonUtils.ts
+const execFileAsync = promisify(execFile);
+/**
+* Gets an integer value from an environment variable.
+* @param key - The environment variable name
+* @returns The parsed integer value, or undefined if not set or not a valid integer
+*/
+function getEnvInt(key) {
+	const value = process.env[key];
+	if (value === void 0) return;
+	const parsed = parseInt(value, 10);
+	return isNaN(parsed) ? void 0 : parsed;
+}
+/**
+* Resolves the Python executable path from explicit config and environment.
+* This centralizes the fallback logic: configPath > PROMPTFOO_PYTHON env var.
+*
+* Note: Does NOT apply the final 'python' default - that's handled by
+* validatePythonPath. This preserves the distinction between "explicitly
+* configured" (should fail if invalid) and "using system default" (should
+* try fallback detection).
+*
+* @param configPath - Explicitly configured Python path from provider config
+* @returns The configured path, or undefined if neither config nor env var is set
+*/
+function getConfiguredPythonPath(configPath) {
+	if (configPath) return configPath;
+	return getEnvString("PROMPTFOO_PYTHON") || void 0;
+}
+const state = {
+	cachedPythonPath: null,
+	validationPromise: null
+};
+/**
+* Try to find Python using Windows 'where' command, filtering out Microsoft Store stubs.
+*/
+async function tryWindowsWhere() {
+	try {
+		const output = (await execFileAsync("where", ["python"])).stdout.trim();
+		if (!output) {
+			logger.debug("Windows 'where python' returned empty output");
+			return null;
+		}
+		const paths = output.split("\n").filter((path) => path.trim());
+		for (const pythonPath of paths) {
+			const trimmedPath = pythonPath.trim();
+			if (trimmedPath.includes("WindowsApps") || !trimmedPath.endsWith(".exe")) continue;
+			const validated = await tryPath(trimmedPath);
+			if (validated) return validated;
+		}
+	} catch (error) {
+		const errorMsg = error instanceof Error ? error.message : String(error);
+		logger.debug(`Windows 'where python' failed: ${errorMsg}`);
+		if (errorMsg.includes("Access is denied") || errorMsg.includes("EACCES")) logger.warn(`Permission denied when searching for Python: ${errorMsg}`);
+	}
+	return null;
+}
+/**
+* Try Python commands to get sys.executable path.
+*/
+async function tryPythonCommands(commands) {
+	for (const cmd of commands) try {
+		const executablePath = (await execFileAsync(cmd, ["-c", "import sys; print(sys.executable)"])).stdout.trim();
+		if (executablePath && executablePath !== "None") {
+			if (process.platform === "win32" && !executablePath.toLowerCase().endsWith(".exe")) {
+				if (executablePath.includes("\\") || /^[A-Za-z]:/.test(executablePath)) return executablePath + ".exe";
+			}
+			return executablePath;
+		}
+	} catch (error) {
+		const errorMsg = error instanceof Error ? error.message : String(error);
+		logger.debug(`Python command "${cmd}" failed: ${errorMsg}`);
+		if (errorMsg.includes("Access is denied") || errorMsg.includes("EACCES") || errorMsg.includes("EPERM")) logger.warn(`Permission denied when trying Python command "${cmd}": ${errorMsg}`);
+	}
+	return null;
+}
+/**
+* Try direct command validation as final fallback.
+*/
+async function tryDirectCommands(commands) {
+	for (const cmd of commands) try {
+		const validated = await tryPath(cmd);
+		if (validated) return validated;
+	} catch (error) {
+		const errorMsg = error instanceof Error ? error.message : String(error);
+		logger.debug(`Direct command "${cmd}" failed: ${errorMsg}`);
+		if (errorMsg.includes("Access is denied") || errorMsg.includes("EACCES") || errorMsg.includes("EPERM")) logger.warn(`Permission denied when trying Python command "${cmd}": ${errorMsg}`);
+	}
+	return null;
+}
+/**
+* Attempts to get the Python executable path using platform-appropriate strategies.
+* @returns The Python executable path if successful, or null if failed.
+*/
+async function getSysExecutable() {
+	if (process.platform === "win32") {
+		const whereResult = await tryWindowsWhere();
+		if (whereResult) return whereResult;
+		const sysResult = await tryPythonCommands(["py", "py -3"]);
+		if (sysResult) return sysResult;
+		return await tryDirectCommands(["python"]);
+	} else return await tryPythonCommands(["python3", "python"]);
+}
+/**
+* Attempts to validate a Python executable path.
+* @param path - The path to the Python executable to test.
+* @returns The validated path if successful, or null if invalid.
+*/
+async function tryPath(path) {
+	let timeoutId;
+	try {
+		const timeoutPromise = new Promise((_, reject) => {
+			timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("Command timed out")), 2500);
+		});
+		const result = await Promise.race([execFileAsync(path, ["--version"]), timeoutPromise]);
+		if (timeoutId) clearTimeout(timeoutId);
+		if (result.stdout.trim().startsWith("Python")) return path;
+		return null;
+	} catch {
+		if (timeoutId) clearTimeout(timeoutId);
+		return null;
+	}
+}
+/**
+* Validates and caches the Python executable path.
+*
+* @param pythonPath - Path to the Python executable.
+* @param isExplicit - If true, only tries the provided path.
+* @returns Validated Python executable path.
+* @throws {Error} If no valid Python executable is found.
+*/
+async function validatePythonPath(pythonPath, isExplicit) {
+	if (state.cachedPythonPath) return state.cachedPythonPath;
+	if (!state.validationPromise) state.validationPromise = (async () => {
+		try {
+			const primaryPath = await tryPath(pythonPath);
+			if (primaryPath) {
+				state.cachedPythonPath = primaryPath;
+				state.validationPromise = null;
+				return primaryPath;
+			}
+			if (isExplicit) {
+				const error = /* @__PURE__ */ new Error(`Python 3 not found. Tried "${pythonPath}" Please ensure Python 3 is installed and set the PROMPTFOO_PYTHON environment variable to your Python 3 executable path (e.g., '${process.platform === "win32" ? "C:\\Python39\\python.exe" : "/usr/bin/python3"}').`);
+				state.validationPromise = null;
+				throw error;
+			}
+			const detectedPath = await getSysExecutable();
+			if (detectedPath) {
+				state.cachedPythonPath = detectedPath;
+				state.validationPromise = null;
+				return detectedPath;
+			}
+			const error = /* @__PURE__ */ new Error(`Python 3 not found. Tried "${pythonPath}", sys.executable detection, and fallback commands. Please ensure Python 3 is installed and set the PROMPTFOO_PYTHON environment variable to your Python 3 executable path (e.g., '${process.platform === "win32" ? "C:\\Python39\\python.exe" : "/usr/bin/python3"}').`);
+			state.validationPromise = null;
+			throw error;
+		} catch (error) {
+			state.validationPromise = null;
+			throw error;
+		}
+	})();
+	return state.validationPromise;
+}
+/**
+* Runs a Python script with the specified method and arguments.
+*
+* @param scriptPath - The path to the Python script to run.
+* @param method - The name of the method to call in the Python script.
+* @param args - An array of arguments to pass to the Python script.
+* @param options - Optional settings for running the Python script.
+* @param options.pythonExecutable - Optional path to the Python executable.
+* @returns A promise that resolves to the output of the Python script.
+* @throws An error if there's an issue running the Python script or parsing its output.
+*/
+async function runPython(scriptPath, method, args, options = {}) {
+	const absPath = path.resolve(scriptPath);
+	const tempJsonPath = path.join(os.tmpdir(), `promptfoo-python-input-json-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
+	const outputPath = path.join(os.tmpdir(), `promptfoo-python-output-json-${Date.now()}-${Math.random().toString(16).slice(2)}.json`);
+	const customPath = getConfiguredPythonPath(options.pythonExecutable);
+	let pythonPath = customPath || "python";
+	pythonPath = await validatePythonPath(pythonPath, typeof customPath === "string");
+	const pythonOptions = {
+		args: [
+			absPath,
+			method,
+			tempJsonPath,
+			outputPath
+		],
+		env: process.env,
+		mode: "binary",
+		pythonPath,
+		scriptPath: getWrapperDir("python"),
+		...getEnvBool("PROMPTFOO_PYTHON_DEBUG_ENABLED") && { stdio: "inherit" }
+	};
+	try {
+		fs.writeFileSync(tempJsonPath, safeJsonStringify(args), "utf-8");
+		logger.debug(`Running Python wrapper with args: ${safeJsonStringify(args)}`);
+		await new Promise((resolve, reject) => {
+			try {
+				const pyshell = new PythonShell("wrapper.py", pythonOptions);
+				pyshell.stdout?.on("data", (chunk) => {
+					logger.debug(chunk.toString("utf-8").trim());
+				});
+				pyshell.stderr?.on("data", (chunk) => {
+					logger.error(chunk.toString("utf-8").trim());
+				});
+				pyshell.end((err) => {
+					if (err) reject(err);
+					else resolve();
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+		const output = fs.readFileSync(outputPath, "utf-8");
+		logger.debug(`Python script ${absPath} returned: ${output}`);
+		let result;
+		try {
+			result = JSON.parse(output);
+			logger.debug(`Python script ${absPath} parsed output type: ${typeof result}, structure: ${result ? JSON.stringify(Object.keys(result)) : "undefined"}`);
+		} catch (error) {
+			throw new Error(`Invalid JSON: ${error.message} when parsing result: ${output}\nStack Trace: ${error.stack}`);
+		}
+		if (result?.type !== "final_result") throw new Error("The Python script `call_api` function must return a dict with an `output`");
+		return result.data;
+	} catch (error) {
+		logger.error(`Error running Python script: ${error.message}\nStack Trace: ${error.stack?.replace("--- Python Traceback ---", "Python Traceback: ") || "No Python traceback available"}`);
+		throw new Error(`Error running Python script: ${error.message}\nStack Trace: ${error.stack?.replace("--- Python Traceback ---", "Python Traceback: ") || "No Python traceback available"}`);
+	} finally {
+		[tempJsonPath, outputPath].forEach((file) => {
+			try {
+				fs.unlinkSync(file);
+			} catch (error) {
+				logger.error(`Error removing ${file}: ${error}`);
+			}
+		});
+	}
+}
+//#endregion
+export { validatePythonPath as i, getEnvInt as n, runPython as r, getConfiguredPythonPath as t };
+
+//# sourceMappingURL=pythonUtils-D6fwaDSg.js.map

package/dist/src/quiverai-C2jVwbH1.js

@@ -0,0 +1,213 @@
+import { b as getEnvString, i as logger } from "./logger-DLcq4dWf.js";
+import { p as REQUEST_TIMEOUT_MS, t as fetchWithProxy } from "./fetch-4M3YRaqL.js";
+import { r as fetchWithCache } from "./cache-D3eqDYGU.js";
+//#region src/providers/quiverai.ts
+const QUIVERAI_API_BASE_URL = "https://api.quiver.ai/v1";
+const QUIVERAI_DEFAULT_MODEL = "arrow-preview";
+/**
+* QuiverAI provider for SVG vector graphics generation using the Arrow model.
+* Uses QuiverAI's native SVG generation API (POST /v1/svgs/generations).
+* Streams by default for faster time-to-first-token.
+*/
+var QuiverAiProvider = class {
+	config;
+	modelName;
+	apiKey;
+	apiBaseUrl;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || env?.QUIVERAI_API_KEY || getEnvString("QUIVERAI_API_KEY") || "";
+		this.apiBaseUrl = config?.apiBaseUrl || QUIVERAI_API_BASE_URL;
+		if (id) this.id = () => id;
+		this.config = config || {};
+	}
+	id() {
+		return `quiverai:${this.modelName}`;
+	}
+	toString() {
+		return `[QuiverAI Provider ${this.modelName}]`;
+	}
+	getApiUrl() {
+		return `${this.apiBaseUrl}/svgs/generations`;
+	}
+	getHeaders() {
+		return {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.apiKey}`
+		};
+	}
+	async callApi(prompt, context) {
+		if (!this.apiKey) return { error: "QuiverAI API key is not set. Set the QUIVERAI_API_KEY environment variable or add apiKey to the provider config. Get a key at https://app.quiver.ai/settings/api-keys" };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const useStream = config.stream !== false;
+		const body = {
+			model: this.modelName,
+			prompt,
+			stream: useStream,
+			...pickDefined(config, [
+				"instructions",
+				"references",
+				"n",
+				"temperature",
+				"top_p",
+				"presence_penalty",
+				"max_output_tokens"
+			])
+		};
+		try {
+			if (useStream) return await this.callApiStreaming(body);
+			return await this.callApiNonStreaming(body, context);
+		} catch (error) {
+			logger.error(`QuiverAI API call error: ${error}`);
+			return { error: `QuiverAI API call error: ${error}` };
+		}
+	}
+	async callApiNonStreaming(body, context) {
+		const { data, cached, status, statusText } = await fetchWithCache(this.getApiUrl(), {
+			method: "POST",
+			headers: this.getHeaders(),
+			body: JSON.stringify(body)
+		}, REQUEST_TIMEOUT_MS, "json", context?.bustCache ?? context?.debug);
+		if (status < 200 || status >= 300) {
+			if (data && typeof data === "object" && "code" in data && "message" in data) return { error: formatError(data) };
+			return { error: `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}` };
+		}
+		const response = data;
+		return {
+			cached,
+			output: extractSvgOutput(response),
+			tokenUsage: mapTokenUsage(response.usage, cached ? 0 : 1)
+		};
+	}
+	async callApiStreaming(body) {
+		const maxRetries = 3;
+		let lastResp;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+			let reader;
+			try {
+				lastResp = await fetchWithProxy(this.getApiUrl(), {
+					method: "POST",
+					headers: this.getHeaders(),
+					body: JSON.stringify(body),
+					signal: controller.signal
+				});
+				if (lastResp.status === 429 && attempt < maxRetries) {
+					const waitMs = getRetryAfterMs(lastResp.headers, attempt);
+					logger.debug(`QuiverAI: rate limited, retry ${attempt + 1}/${maxRetries} in ${waitMs}ms`);
+					await lastResp.body?.cancel();
+					await new Promise((resolve) => setTimeout(resolve, waitMs));
+					continue;
+				}
+				if (!lastResp.ok) return await handleStreamingError(lastResp);
+				if (!lastResp.body) return { error: "QuiverAI streaming response has no body" };
+				reader = lastResp.body.getReader();
+				return await readSSEStream(reader);
+			} finally {
+				reader?.cancel().catch(() => {});
+				clearTimeout(timeout);
+			}
+		}
+		return handleStreamingError(lastResp);
+	}
+};
+async function handleStreamingError(resp) {
+	try {
+		return { error: formatError(await resp.json()) };
+	} catch {
+		return { error: `QuiverAI API error: HTTP ${resp.status}` };
+	}
+}
+async function readSSEStream(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let finalSvg = "";
+	let usage;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) {
+			const parsed = parseSSELine(line);
+			if (parsed.svg) finalSvg = parsed.svg;
+			if (parsed.usage) usage = parsed.usage;
+		}
+	}
+	if (buffer.trim()) {
+		const parsed = parseSSELine(buffer);
+		if (parsed.svg) finalSvg = parsed.svg;
+		if (parsed.usage) usage = parsed.usage;
+	}
+	if (!finalSvg) return { error: "QuiverAI streaming response contained no SVG content" };
+	return {
+		output: finalSvg,
+		tokenUsage: mapTokenUsage(usage, 1)
+	};
+}
+function pickDefined(obj, keys) {
+	return Object.fromEntries(keys.filter((k) => obj[k] != null).map((k) => [k, obj[k]]));
+}
+function formatError(err) {
+	const base = `${err.message} [${err.code}]`;
+	return err.request_id ? `${base} (request_id: ${err.request_id})` : base;
+}
+function mapTokenUsage(usage, numRequests) {
+	return {
+		total: usage?.total_tokens || 0,
+		prompt: usage?.input_tokens || 0,
+		completion: usage?.output_tokens || 0,
+		numRequests
+	};
+}
+const MAX_RETRY_AFTER_MS = 6e4;
+function getRetryAfterMs(headers, attempt) {
+	const retryAfter = headers.get("retry-after");
+	if (retryAfter) {
+		const seconds = Number(retryAfter);
+		if (!Number.isNaN(seconds)) return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+		const date = new Date(retryAfter);
+		if (!Number.isNaN(date.getTime())) return Math.min(Math.max(0, date.getTime() - Date.now()), MAX_RETRY_AFTER_MS);
+	}
+	return Math.pow(2, attempt) * 1e3;
+}
+function parseSSELine(line) {
+	if (!line.startsWith("data:")) return {};
+	const payload = line.slice(line.startsWith("data: ") ? 6 : 5).trim();
+	if (!payload || payload === "[DONE]") return {};
+	try {
+		const event = JSON.parse(payload);
+		return {
+			svg: event.type === "content" && event.svg ? event.svg : void 0,
+			usage: event.usage
+		};
+	} catch {
+		logger.debug(`QuiverAI: failed to parse SSE data: ${payload}`);
+		return {};
+	}
+}
+function extractSvgOutput(response) {
+	if (Array.isArray(response.data)) {
+		const svgs = response.data.map((item) => item.svg).filter(Boolean);
+		return svgs.length === 1 ? svgs[0] : svgs.join("\n\n");
+	}
+	return JSON.stringify(response);
+}
+function createQuiverAiProvider(providerPath, providerOptions = {}, env) {
+	const splits = providerPath.split(":");
+	return new QuiverAiProvider((splits[1] === "chat" ? splits.slice(2) : splits.slice(1)).join(":") || QUIVERAI_DEFAULT_MODEL, {
+		config: providerOptions.config,
+		id: providerOptions.id,
+		env: providerOptions.env ?? env
+	});
+}
+//#endregion
+export { createQuiverAiProvider };
+
+//# sourceMappingURL=quiverai-C2jVwbH1.js.map

package/dist/src/quiverai-CI6gYJVI.js

@@ -0,0 +1,213 @@
+import { b as getEnvString, i as logger } from "./logger-CT3IKMKA.js";
+import { p as REQUEST_TIMEOUT_MS, t as fetchWithProxy } from "./fetch-60Gzydls.js";
+import { r as fetchWithCache } from "./cache-8XhNqPKW.js";
+//#region src/providers/quiverai.ts
+const QUIVERAI_API_BASE_URL = "https://api.quiver.ai/v1";
+const QUIVERAI_DEFAULT_MODEL = "arrow-preview";
+/**
+* QuiverAI provider for SVG vector graphics generation using the Arrow model.
+* Uses QuiverAI's native SVG generation API (POST /v1/svgs/generations).
+* Streams by default for faster time-to-first-token.
+*/
+var QuiverAiProvider = class {
+	config;
+	modelName;
+	apiKey;
+	apiBaseUrl;
+	constructor(modelName, options = {}) {
+		const { config, id, env } = options;
+		this.modelName = modelName;
+		this.apiKey = config?.apiKey || env?.QUIVERAI_API_KEY || getEnvString("QUIVERAI_API_KEY") || "";
+		this.apiBaseUrl = config?.apiBaseUrl || QUIVERAI_API_BASE_URL;
+		if (id) this.id = () => id;
+		this.config = config || {};
+	}
+	id() {
+		return `quiverai:${this.modelName}`;
+	}
+	toString() {
+		return `[QuiverAI Provider ${this.modelName}]`;
+	}
+	getApiUrl() {
+		return `${this.apiBaseUrl}/svgs/generations`;
+	}
+	getHeaders() {
+		return {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.apiKey}`
+		};
+	}
+	async callApi(prompt, context) {
+		if (!this.apiKey) return { error: "QuiverAI API key is not set. Set the QUIVERAI_API_KEY environment variable or add apiKey to the provider config. Get a key at https://app.quiver.ai/settings/api-keys" };
+		const config = {
+			...this.config,
+			...context?.prompt?.config
+		};
+		const useStream = config.stream !== false;
+		const body = {
+			model: this.modelName,
+			prompt,
+			stream: useStream,
+			...pickDefined(config, [
+				"instructions",
+				"references",
+				"n",
+				"temperature",
+				"top_p",
+				"presence_penalty",
+				"max_output_tokens"
+			])
+		};
+		try {
+			if (useStream) return await this.callApiStreaming(body);
+			return await this.callApiNonStreaming(body, context);
+		} catch (error) {
+			logger.error(`QuiverAI API call error: ${error}`);
+			return { error: `QuiverAI API call error: ${error}` };
+		}
+	}
+	async callApiNonStreaming(body, context) {
+		const { data, cached, status, statusText } = await fetchWithCache(this.getApiUrl(), {
+			method: "POST",
+			headers: this.getHeaders(),
+			body: JSON.stringify(body)
+		}, REQUEST_TIMEOUT_MS, "json", context?.bustCache ?? context?.debug);
+		if (status < 200 || status >= 300) {
+			if (data && typeof data === "object" && "code" in data && "message" in data) return { error: formatError(data) };
+			return { error: `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}` };
+		}
+		const response = data;
+		return {
+			cached,
+			output: extractSvgOutput(response),
+			tokenUsage: mapTokenUsage(response.usage, cached ? 0 : 1)
+		};
+	}
+	async callApiStreaming(body) {
+		const maxRetries = 3;
+		let lastResp;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+			let reader;
+			try {
+				lastResp = await fetchWithProxy(this.getApiUrl(), {
+					method: "POST",
+					headers: this.getHeaders(),
+					body: JSON.stringify(body),
+					signal: controller.signal
+				});
+				if (lastResp.status === 429 && attempt < maxRetries) {
+					const waitMs = getRetryAfterMs(lastResp.headers, attempt);
+					logger.debug(`QuiverAI: rate limited, retry ${attempt + 1}/${maxRetries} in ${waitMs}ms`);
+					await lastResp.body?.cancel();
+					await new Promise((resolve) => setTimeout(resolve, waitMs));
+					continue;
+				}
+				if (!lastResp.ok) return await handleStreamingError(lastResp);
+				if (!lastResp.body) return { error: "QuiverAI streaming response has no body" };
+				reader = lastResp.body.getReader();
+				return await readSSEStream(reader);
+			} finally {
+				reader?.cancel().catch(() => {});
+				clearTimeout(timeout);
+			}
+		}
+		return handleStreamingError(lastResp);
+	}
+};
+async function handleStreamingError(resp) {
+	try {
+		return { error: formatError(await resp.json()) };
+	} catch {
+		return { error: `QuiverAI API error: HTTP ${resp.status}` };
+	}
+}
+async function readSSEStream(reader) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let finalSvg = "";
+	let usage;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) {
+			const parsed = parseSSELine(line);
+			if (parsed.svg) finalSvg = parsed.svg;
+			if (parsed.usage) usage = parsed.usage;
+		}
+	}
+	if (buffer.trim()) {
+		const parsed = parseSSELine(buffer);
+		if (parsed.svg) finalSvg = parsed.svg;
+		if (parsed.usage) usage = parsed.usage;
+	}
+	if (!finalSvg) return { error: "QuiverAI streaming response contained no SVG content" };
+	return {
+		output: finalSvg,
+		tokenUsage: mapTokenUsage(usage, 1)
+	};
+}
+function pickDefined(obj, keys) {
+	return Object.fromEntries(keys.filter((k) => obj[k] != null).map((k) => [k, obj[k]]));
+}
+function formatError(err) {
+	const base = `${err.message} [${err.code}]`;
+	return err.request_id ? `${base} (request_id: ${err.request_id})` : base;
+}
+function mapTokenUsage(usage, numRequests) {
+	return {
+		total: usage?.total_tokens || 0,
+		prompt: usage?.input_tokens || 0,
+		completion: usage?.output_tokens || 0,
+		numRequests
+	};
+}
+const MAX_RETRY_AFTER_MS = 6e4;
+function getRetryAfterMs(headers, attempt) {
+	const retryAfter = headers.get("retry-after");
+	if (retryAfter) {
+		const seconds = Number(retryAfter);
+		if (!Number.isNaN(seconds)) return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+		const date = new Date(retryAfter);
+		if (!Number.isNaN(date.getTime())) return Math.min(Math.max(0, date.getTime() - Date.now()), MAX_RETRY_AFTER_MS);
+	}
+	return Math.pow(2, attempt) * 1e3;
+}
+function parseSSELine(line) {
+	if (!line.startsWith("data:")) return {};
+	const payload = line.slice(line.startsWith("data: ") ? 6 : 5).trim();
+	if (!payload || payload === "[DONE]") return {};
+	try {
+		const event = JSON.parse(payload);
+		return {
+			svg: event.type === "content" && event.svg ? event.svg : void 0,
+			usage: event.usage
+		};
+	} catch {
+		logger.debug(`QuiverAI: failed to parse SSE data: ${payload}`);
+		return {};
+	}
+}
+function extractSvgOutput(response) {
+	if (Array.isArray(response.data)) {
+		const svgs = response.data.map((item) => item.svg).filter(Boolean);
+		return svgs.length === 1 ? svgs[0] : svgs.join("\n\n");
+	}
+	return JSON.stringify(response);
+}
+function createQuiverAiProvider(providerPath, providerOptions = {}, env) {
+	const splits = providerPath.split(":");
+	return new QuiverAiProvider((splits[1] === "chat" ? splits.slice(2) : splits.slice(1)).join(":") || QUIVERAI_DEFAULT_MODEL, {
+		config: providerOptions.config,
+		id: providerOptions.id,
+		env: providerOptions.env ?? env
+	});
+}
+//#endregion
+export { createQuiverAiProvider };
+
+//# sourceMappingURL=quiverai-CI6gYJVI.js.map