promptfoo 0.125.0 → 0.125.1

package/dist/src/transcription-fZenF3G5.js

@@ -0,0 +1,175 @@
+import { o as logger } from "./logger-Gff7RMNF.js";
+import { A as isAbortError, k as getAbortError } from "./fetch-B5KxZuKu.js";
+import { a as getRequestTimeoutMs } from "./shared-BBI-NXjW.js";
+import { i as fetchWithCache } from "./cache-DSm6t1MZ.js";
+import { c as OPENAI_TRANSCRIPTION_MODELS, d as appendOpenAiApiPath, f as assertOpenAiApiModel, k as getTokenUsage } from "./util-CsTD_ROg.js";
+import { n as OpenAiGenericProvider } from "./openai-TU3iAci7.js";
+import path from "path";
+import fs from "fs/promises";
+//#region src/providers/openai/transcription.ts
+var OpenAiTranscriptionProvider = class OpenAiTranscriptionProvider extends OpenAiGenericProvider {
+	static OPENAI_TRANSCRIPTION_MODEL_NAMES = OPENAI_TRANSCRIPTION_MODELS.map((model) => model.id);
+	config;
+	constructor(modelName, options = {}) {
+		if (!OpenAiTranscriptionProvider.OPENAI_TRANSCRIPTION_MODEL_NAMES.includes(modelName)) logger.debug(`Using unknown transcription model: ${modelName}`);
+		super(modelName, options);
+		this.config = options.config || {};
+		assertOpenAiApiModel(modelName, this.getApiUrl(), { allowTranscription: true });
+	}
+	id() {
+		return `openai:transcription:${this.modelName}`;
+	}
+	toString() {
+		return `[OpenAI Transcription Provider ${this.modelName}]`;
+	}
+	calculateTranscriptionCost(durationSeconds, usage) {
+		const model = OPENAI_TRANSCRIPTION_MODELS.find((m) => m.id === this.modelName);
+		if (!model?.cost) return;
+		const inputTokenDetails = usage?.input_token_details;
+		if (usage?.type === "tokens" && typeof inputTokenDetails?.text_tokens === "number" && typeof inputTokenDetails?.audio_tokens === "number" && typeof usage.output_tokens === "number" && model.cost.input !== void 0 && model.cost.audioInput !== void 0 && model.cost.output !== void 0) return inputTokenDetails.text_tokens * model.cost.input + inputTokenDetails.audio_tokens * model.cost.audioInput + usage.output_tokens * model.cost.output;
+		if (durationSeconds === void 0) return;
+		return durationSeconds / 60 * model.cost.perMinute;
+	}
+	async callApi(prompt, context, callApiOptions) {
+		const abortSignal = callApiOptions?.abortSignal;
+		if (abortSignal?.aborted) throw getAbortError(abortSignal);
+		const apiKey = this.getApiKey();
+		if (!apiKey && this.requiresApiKey()) throw new Error(this.getMissingApiKeyErrorMessage());
+		const promptConfig = context?.prompt?.config;
+		const config = {
+			...this.config,
+			...promptConfig
+		};
+		const isGptTranscribe = this.modelName === "gpt-transcribe";
+		if (isGptTranscribe) {
+			const hasOption = (options, key) => options != null && Object.prototype.hasOwnProperty.call(options, key) && options[key] !== void 0;
+			const providerHasLanguage = hasOption(this.config, "language");
+			const providerHasLanguages = hasOption(this.config, "languages");
+			const promptHasLanguage = hasOption(promptConfig, "language");
+			const promptHasLanguages = hasOption(promptConfig, "languages");
+			if (providerHasLanguage && providerHasLanguages || promptHasLanguage && promptHasLanguages) return { error: "gpt-transcribe accepts either config.language or config.languages, not both. Use config.languages for multilingual audio." };
+			if (promptHasLanguage) config.languages = void 0;
+			else if (promptHasLanguages) config.language = void 0;
+			if (config.language !== void 0) {
+				config.languages = [config.language];
+				config.language = void 0;
+			}
+		}
+		if (config.languages !== void 0 || config.keywords !== void 0) {
+			if (!isGptTranscribe) return { error: "languages and keywords require the gpt-transcribe file transcription model." };
+			if (config.languages !== void 0 && (!Array.isArray(config.languages) || config.languages.some((language) => typeof language !== "string" || !/^[a-z]{2,3}(?:-[a-z]{2})?$/i.test(language.trim())))) return { error: "languages must be an array of language codes such as en, eng, or zh-cn." };
+			if (config.keywords !== void 0 && (!Array.isArray(config.keywords) || config.keywords.some((keyword) => typeof keyword !== "string" || !keyword.trim() || /[<>\r\n]/.test(keyword)))) return { error: "keywords must be an array of non-empty, single-line strings without < or >." };
+		}
+		const audioFilePath = prompt.trim();
+		let fileBuffer;
+		try {
+			fileBuffer = await fs.readFile(audioFilePath);
+		} catch (err) {
+			if (err.code === "ENOENT") return { error: `Audio file not found: ${audioFilePath}` };
+			logger.error("Failed to read audio file", {
+				error: err,
+				audioFilePath
+			});
+			return { error: `Failed to read audio file ${audioFilePath}: ${String(err)}` };
+		}
+		try {
+			const fileName = path.basename(audioFilePath);
+			const file = new File([fileBuffer], fileName);
+			const formData = new FormData();
+			formData.append("file", file);
+			formData.append("model", this.modelName);
+			if (config.language) formData.append("language", config.language);
+			for (const language of config.languages || []) formData.append("languages[]", language.trim());
+			for (const keyword of config.keywords || []) formData.append("keywords[]", keyword.trim());
+			if (config.prompt && !this.modelName.includes("diarize")) formData.append("prompt", config.prompt);
+			if (config.temperature !== void 0) formData.append("temperature", config.temperature.toString());
+			if (this.modelName === "whisper-1" && config.timestamp_granularities) for (const granularity of config.timestamp_granularities) formData.append("timestamp_granularities[]", granularity);
+			const isDiarizationModel = this.modelName.includes("diarize");
+			const chunkingStrategy = config.chunking_strategy ?? (isDiarizationModel ? "auto" : void 0);
+			if (typeof chunkingStrategy === "string") formData.append("chunking_strategy", chunkingStrategy);
+			else if (chunkingStrategy) {
+				for (const [key, value] of Object.entries(chunkingStrategy)) if (value !== void 0) formData.append(`chunking_strategy[${key}]`, String(value));
+			}
+			if (isDiarizationModel) {
+				formData.append("response_format", "diarized_json");
+				for (const name of config.known_speaker_names || []) formData.append("known_speaker_names[]", name);
+				for (const reference of config.known_speaker_references || []) formData.append("known_speaker_references[]", reference);
+			} else if (!isGptTranscribe) {
+				const responseFormat = this.modelName.startsWith("gpt-4o-") ? "json" : "verbose_json";
+				formData.append("response_format", responseFormat);
+			}
+			const customHeaders = this.getOpenAiRequestHeaders(config.headers);
+			const hasAuthorizationOverride = Object.keys(customHeaders).some((header) => header.toLowerCase() === "authorization");
+			const headers = {
+				...apiKey && !hasAuthorizationOverride ? { Authorization: `Bearer ${apiKey}` } : {},
+				...customHeaders
+			};
+			for (const header of Object.keys(headers)) if (header.toLowerCase() === "content-type") delete headers[header];
+			let data, status, statusText;
+			let cached = false;
+			try {
+				({data, cached, status, statusText} = await fetchWithCache(appendOpenAiApiPath(this.getApiUrl(), "audio/transcriptions"), {
+					method: "POST",
+					headers,
+					body: formData,
+					...abortSignal ? { signal: abortSignal } : {}
+				}, getRequestTimeoutMs(), "json", context?.bustCache ?? context?.debug, config.maxRetries));
+				if (status < 200 || status >= 300) return { error: `API error: ${status} ${statusText}\n${typeof data === "string" ? data : JSON.stringify(data)}` };
+			} catch (err) {
+				if (abortSignal?.aborted) throw getAbortError(abortSignal);
+				if (isAbortError(err)) throw err;
+				logger.error("API call error", { error: err });
+				return { error: `API call error: ${String(err)}` };
+			}
+			if (data.error) return { error: typeof data.error === "string" ? data.error : JSON.stringify(data.error) };
+			const durationSeconds = data.usage?.type === "duration" && typeof data.usage.seconds === "number" ? data.usage.seconds : typeof data.duration === "number" ? data.duration : void 0;
+			const cost = cached ? 0 : this.calculateTranscriptionCost(durationSeconds, data.usage);
+			const tokenUsage = data.usage?.type === "tokens" ? getTokenUsage({ usage: {
+				total_tokens: data.usage.total_tokens,
+				prompt_tokens: data.usage.input_tokens,
+				completion_tokens: data.usage.output_tokens
+			} }, cached) : void 0;
+			const segments = data.segments || [];
+			const averageMetric = (key) => {
+				const values = segments.map((segment) => segment[key]).filter((value) => typeof value === "number");
+				return values.length > 0 ? values.reduce((sum, value) => sum + value, 0) / values.length : void 0;
+			};
+			const avgLogprob = averageMetric("avg_logprob");
+			const avgCompressionRatio = averageMetric("compression_ratio");
+			const avgNoSpeechProb = averageMetric("no_speech_prob");
+			let output;
+			if (this.modelName.includes("diarize") && data.segments) output = data.segments.map((segment) => {
+				const speaker = segment.speaker || "Unknown";
+				const text = segment.text || "";
+				return `[${segment.start?.toFixed(2) || "0.00"}s - ${segment.end?.toFixed(2) || "0.00"}s] ${speaker}: ${text}`;
+			}).join("\n");
+			else if (typeof data.text === "string") output = data.text;
+			else return { error: "No transcription returned from API" };
+			return {
+				output,
+				cached,
+				cost,
+				...tokenUsage ? { tokenUsage } : {},
+				metadata: {
+					task: data.task,
+					...durationSeconds === void 0 ? {} : { duration: durationSeconds },
+					language: data.language,
+					...Array.isArray(data.languages) ? { languages: data.languages } : {},
+					segments: data.segments?.length || 0,
+					...avgLogprob === void 0 ? {} : { avgLogprob },
+					...avgCompressionRatio === void 0 ? {} : { avgCompressionRatio },
+					...avgNoSpeechProb === void 0 ? {} : { avgNoSpeechProb },
+					...this.modelName.includes("diarize") && data.speakers ? { speakers: data.speakers } : {}
+				}
+			};
+		} catch (err) {
+			if (isAbortError(err)) throw err;
+			logger.error("Transcription error", { error: err });
+			return { error: `Transcription error: ${String(err)}` };
+		}
+	}
+};
+//#endregion
+export { OpenAiTranscriptionProvider };
+
+//# sourceMappingURL=transcription-fZenF3G5.js.map

package/dist/src/transform-BzhRc5z2.js

@@ -0,0 +1,125 @@
+import { f as McpConfigSchema } from "./shared-DS0YmCOx.js";
+import { a as getOAuthTokenWithExpiry, l as renderAuthVars, n as getAuthHeaders, r as getAuthQueryParams, t as applyQueryParams } from "./util-CePiY2xZ.js";
+import { k as sanitizeSchemaForGemini } from "./util-qzBqirBH.js";
+//#region src/providers/mcp/transform.ts
+function transformMCPToolsToOpenAi(tools) {
+	return tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let properties = {};
+		let required = void 0;
+		let additionalProperties = void 0;
+		if (schema && typeof schema === "object" && "properties" in schema) {
+			properties = schema.properties ?? {};
+			required = schema.required;
+			if ("additionalProperties" in schema) additionalProperties = schema.additionalProperties;
+		}
+		return {
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: {
+					type: "object",
+					properties,
+					...required && required.length > 0 ? { required } : {},
+					...additionalProperties === void 0 ? {} : { additionalProperties }
+				}
+			}
+		};
+	});
+}
+function transformMCPToolsToAnthropic(tools) {
+	return tools.map((tool) => {
+		const { $schema: _$schema, ...cleanSchema } = tool.inputSchema;
+		return {
+			name: tool.name,
+			description: tool.description,
+			input_schema: {
+				type: "object",
+				...cleanSchema
+			}
+		};
+	});
+}
+function transformMCPToolsToGoogle(tools) {
+	return [{ functionDeclarations: tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let parameters;
+		if (schema && typeof schema === "object") {
+			parameters = sanitizeSchemaForGemini(schema);
+			if (!parameters.type) parameters.type = "OBJECT";
+			if (!parameters.properties) parameters.properties = {};
+		} else parameters = {
+			type: "OBJECT",
+			properties: {}
+		};
+		return {
+			name: tool.name,
+			description: tool.description,
+			parameters
+		};
+	}) }];
+}
+async function transformMCPConfigToClaudeCode(input) {
+	const config = validateMCPConfigForClaudeCode(input);
+	if (config.enabled === false) return {};
+	const serverConfigs = getServerConfigs(config);
+	const servers = await Promise.all(serverConfigs.map((server) => transformMCPServerConfigToClaudeCode(server)));
+	return Object.fromEntries(servers.map((server, index) => [getClaudeCodeServerName(serverConfigs[index]), server]));
+}
+function getServerConfigs(config) {
+	return [...config.servers ?? [], ...config.server ? [config.server] : []];
+}
+function getClaudeCodeServerName({ name, url, command }) {
+	return name ?? url ?? command ?? "default";
+}
+function validateMCPConfigForClaudeCode(input) {
+	const result = McpConfigSchema.safeParse(input);
+	if (!result.success) throw new Error(`Claude Agent SDK MCP configuration is malformed: ${result.error.message}`);
+	const config = result.data;
+	if (!config.enabled) return config;
+	if (config.tools !== void 0 || config.exclude_tools?.length) throw new Error("Claude Agent SDK MCP integration does not support MCP tool allowlists or non-empty exclusions; remove `tools`/`exclude_tools` or disable MCP for this provider.");
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const [index, server] of getServerConfigs(config).entries()) {
+		const name = getClaudeCodeServerName(server);
+		let namespace = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+		if (name.startsWith("claude.ai ")) namespace = namespace.replace(/_+/g, "_").replace(/^_|_$/g, "");
+		const previous = namespaces.get(namespace);
+		if (previous !== void 0) throw new Error(`Claude Agent SDK MCP servers ${previous + 1} and ${index + 1} have colliding tool names; give each server a unique \`name\` using letters, numbers, hyphens, or underscores.`);
+		namespaces.set(namespace, index);
+	}
+	return config;
+}
+async function transformMCPServerConfigToClaudeCode(config) {
+	let out;
+	if (config.url) {
+		const renderedConfig = renderAuthVars(config);
+		const oauthToken = renderedConfig.auth?.type === "oauth" ? (await getOAuthTokenWithExpiry(renderedConfig.auth, config.url)).accessToken : void 0;
+		const queryParams = getAuthQueryParams(renderedConfig);
+		out = {
+			type: "http",
+			url: applyQueryParams(config.url, queryParams),
+			headers: {
+				...config.headers ?? {},
+				...getAuthHeaders(renderedConfig, oauthToken)
+			}
+		};
+	} else if (config.command) out = {
+		type: "stdio",
+		command: config.command,
+		args: config.args ?? [],
+		...config.env && { env: config.env }
+	};
+	else if (config.path) out = {
+		type: "stdio",
+		command: config.path.endsWith(".py") ? process.platform === "win32" ? "python" : "python3" : process.execPath,
+		args: [config.path],
+		...config.env && { env: config.env }
+	};
+	else throw new Error("MCP configuration cannot be converted to Claude Agent SDK MCP server config");
+	return out;
+}
+//#endregion
+export { validateMCPConfigForClaudeCode as a, transformMCPToolsToOpenAi as i, transformMCPToolsToAnthropic as n, transformMCPToolsToGoogle as r, transformMCPConfigToClaudeCode as t };
+
+//# sourceMappingURL=transform-BzhRc5z2.js.map

package/dist/src/transform-CPQu05u6.cjs

@@ -0,0 +1,154 @@
+const require_shared = require("./shared-Bo_Ejt46.cjs");
+const require_util = require("./util-ClJRjlQA.cjs");
+const require_util$1 = require("./util-Df7rfMGb.cjs");
+//#region src/providers/mcp/transform.ts
+function transformMCPToolsToOpenAi(tools) {
+	return tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let properties = {};
+		let required = void 0;
+		let additionalProperties = void 0;
+		if (schema && typeof schema === "object" && "properties" in schema) {
+			properties = schema.properties ?? {};
+			required = schema.required;
+			if ("additionalProperties" in schema) additionalProperties = schema.additionalProperties;
+		}
+		return {
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: {
+					type: "object",
+					properties,
+					...required && required.length > 0 ? { required } : {},
+					...additionalProperties === void 0 ? {} : { additionalProperties }
+				}
+			}
+		};
+	});
+}
+function transformMCPToolsToAnthropic(tools) {
+	return tools.map((tool) => {
+		const { $schema: _$schema, ...cleanSchema } = tool.inputSchema;
+		return {
+			name: tool.name,
+			description: tool.description,
+			input_schema: {
+				type: "object",
+				...cleanSchema
+			}
+		};
+	});
+}
+function transformMCPToolsToGoogle(tools) {
+	return [{ functionDeclarations: tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let parameters;
+		if (schema && typeof schema === "object") {
+			parameters = require_util$1.sanitizeSchemaForGemini(schema);
+			if (!parameters.type) parameters.type = "OBJECT";
+			if (!parameters.properties) parameters.properties = {};
+		} else parameters = {
+			type: "OBJECT",
+			properties: {}
+		};
+		return {
+			name: tool.name,
+			description: tool.description,
+			parameters
+		};
+	}) }];
+}
+async function transformMCPConfigToClaudeCode(input) {
+	const config = validateMCPConfigForClaudeCode(input);
+	if (config.enabled === false) return {};
+	const serverConfigs = getServerConfigs(config);
+	const servers = await Promise.all(serverConfigs.map((server) => transformMCPServerConfigToClaudeCode(server)));
+	return Object.fromEntries(servers.map((server, index) => [getClaudeCodeServerName(serverConfigs[index]), server]));
+}
+function getServerConfigs(config) {
+	return [...config.servers ?? [], ...config.server ? [config.server] : []];
+}
+function getClaudeCodeServerName({ name, url, command }) {
+	return name ?? url ?? command ?? "default";
+}
+function validateMCPConfigForClaudeCode(input) {
+	const result = require_shared.McpConfigSchema.safeParse(input);
+	if (!result.success) throw new Error(`Claude Agent SDK MCP configuration is malformed: ${result.error.message}`);
+	const config = result.data;
+	if (!config.enabled) return config;
+	if (config.tools !== void 0 || config.exclude_tools?.length) throw new Error("Claude Agent SDK MCP integration does not support MCP tool allowlists or non-empty exclusions; remove `tools`/`exclude_tools` or disable MCP for this provider.");
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const [index, server] of getServerConfigs(config).entries()) {
+		const name = getClaudeCodeServerName(server);
+		let namespace = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+		if (name.startsWith("claude.ai ")) namespace = namespace.replace(/_+/g, "_").replace(/^_|_$/g, "");
+		const previous = namespaces.get(namespace);
+		if (previous !== void 0) throw new Error(`Claude Agent SDK MCP servers ${previous + 1} and ${index + 1} have colliding tool names; give each server a unique \`name\` using letters, numbers, hyphens, or underscores.`);
+		namespaces.set(namespace, index);
+	}
+	return config;
+}
+async function transformMCPServerConfigToClaudeCode(config) {
+	let out;
+	if (config.url) {
+		const renderedConfig = require_util.renderAuthVars(config);
+		const oauthToken = renderedConfig.auth?.type === "oauth" ? (await require_util.getOAuthTokenWithExpiry(renderedConfig.auth, config.url)).accessToken : void 0;
+		const queryParams = require_util.getAuthQueryParams(renderedConfig);
+		out = {
+			type: "http",
+			url: require_util.applyQueryParams(config.url, queryParams),
+			headers: {
+				...config.headers ?? {},
+				...require_util.getAuthHeaders(renderedConfig, oauthToken)
+			}
+		};
+	} else if (config.command) out = {
+		type: "stdio",
+		command: config.command,
+		args: config.args ?? [],
+		...config.env && { env: config.env }
+	};
+	else if (config.path) out = {
+		type: "stdio",
+		command: config.path.endsWith(".py") ? process.platform === "win32" ? "python" : "python3" : process.execPath,
+		args: [config.path],
+		...config.env && { env: config.env }
+	};
+	else throw new Error("MCP configuration cannot be converted to Claude Agent SDK MCP server config");
+	return out;
+}
+//#endregion
+Object.defineProperty(exports, "transformMCPConfigToClaudeCode", {
+	enumerable: true,
+	get: function() {
+		return transformMCPConfigToClaudeCode;
+	}
+});
+Object.defineProperty(exports, "transformMCPToolsToAnthropic", {
+	enumerable: true,
+	get: function() {
+		return transformMCPToolsToAnthropic;
+	}
+});
+Object.defineProperty(exports, "transformMCPToolsToGoogle", {
+	enumerable: true,
+	get: function() {
+		return transformMCPToolsToGoogle;
+	}
+});
+Object.defineProperty(exports, "transformMCPToolsToOpenAi", {
+	enumerable: true,
+	get: function() {
+		return transformMCPToolsToOpenAi;
+	}
+});
+Object.defineProperty(exports, "validateMCPConfigForClaudeCode", {
+	enumerable: true,
+	get: function() {
+		return validateMCPConfigForClaudeCode;
+	}
+});
+
+//# sourceMappingURL=transform-CPQu05u6.cjs.map

package/dist/src/transform-DAED8imp.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import { a as getOAuthTokenWithExpiry, l as renderAuthVars, n as getAuthHeaders, r as getAuthQueryParams, t as applyQueryParams } from "./util-WH8CgVs4.js";
+import { t as McpConfigSchema } from "./mcp-CV2k2gwj.js";
+import { k as sanitizeSchemaForGemini } from "./util-Kf0KnG_6.js";
+//#region src/providers/mcp/transform.ts
+function transformMCPToolsToOpenAi(tools) {
+	return tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let properties = {};
+		let required = void 0;
+		let additionalProperties = void 0;
+		if (schema && typeof schema === "object" && "properties" in schema) {
+			properties = schema.properties ?? {};
+			required = schema.required;
+			if ("additionalProperties" in schema) additionalProperties = schema.additionalProperties;
+		}
+		return {
+			type: "function",
+			function: {
+				name: tool.name,
+				description: tool.description,
+				parameters: {
+					type: "object",
+					properties,
+					...required && required.length > 0 ? { required } : {},
+					...additionalProperties === void 0 ? {} : { additionalProperties }
+				}
+			}
+		};
+	});
+}
+function transformMCPToolsToAnthropic(tools) {
+	return tools.map((tool) => {
+		const { $schema: _$schema, ...cleanSchema } = tool.inputSchema;
+		return {
+			name: tool.name,
+			description: tool.description,
+			input_schema: {
+				type: "object",
+				...cleanSchema
+			}
+		};
+	});
+}
+function transformMCPToolsToGoogle(tools) {
+	return [{ functionDeclarations: tools.map((tool) => {
+		const schema = tool.inputSchema;
+		let parameters;
+		if (schema && typeof schema === "object") {
+			parameters = sanitizeSchemaForGemini(schema);
+			if (!parameters.type) parameters.type = "OBJECT";
+			if (!parameters.properties) parameters.properties = {};
+		} else parameters = {
+			type: "OBJECT",
+			properties: {}
+		};
+		return {
+			name: tool.name,
+			description: tool.description,
+			parameters
+		};
+	}) }];
+}
+async function transformMCPConfigToClaudeCode(input) {
+	const config = validateMCPConfigForClaudeCode(input);
+	if (config.enabled === false) return {};
+	const serverConfigs = getServerConfigs(config);
+	const servers = await Promise.all(serverConfigs.map((server) => transformMCPServerConfigToClaudeCode(server)));
+	return Object.fromEntries(servers.map((server, index) => [getClaudeCodeServerName(serverConfigs[index]), server]));
+}
+function getServerConfigs(config) {
+	return [...config.servers ?? [], ...config.server ? [config.server] : []];
+}
+function getClaudeCodeServerName({ name, url, command }) {
+	return name ?? url ?? command ?? "default";
+}
+function validateMCPConfigForClaudeCode(input) {
+	const result = McpConfigSchema.safeParse(input);
+	if (!result.success) throw new Error(`Claude Agent SDK MCP configuration is malformed: ${result.error.message}`);
+	const config = result.data;
+	if (!config.enabled) return config;
+	if (config.tools !== void 0 || config.exclude_tools?.length) throw new Error("Claude Agent SDK MCP integration does not support MCP tool allowlists or non-empty exclusions; remove `tools`/`exclude_tools` or disable MCP for this provider.");
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const [index, server] of getServerConfigs(config).entries()) {
+		const name = getClaudeCodeServerName(server);
+		let namespace = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+		if (name.startsWith("claude.ai ")) namespace = namespace.replace(/_+/g, "_").replace(/^_|_$/g, "");
+		const previous = namespaces.get(namespace);
+		if (previous !== void 0) throw new Error(`Claude Agent SDK MCP servers ${previous + 1} and ${index + 1} have colliding tool names; give each server a unique \`name\` using letters, numbers, hyphens, or underscores.`);
+		namespaces.set(namespace, index);
+	}
+	return config;
+}
+async function transformMCPServerConfigToClaudeCode(config) {
+	let out;
+	if (config.url) {
+		const renderedConfig = renderAuthVars(config);
+		const oauthToken = renderedConfig.auth?.type === "oauth" ? (await getOAuthTokenWithExpiry(renderedConfig.auth, config.url)).accessToken : void 0;
+		const queryParams = getAuthQueryParams(renderedConfig);
+		out = {
+			type: "http",
+			url: applyQueryParams(config.url, queryParams),
+			headers: {
+				...config.headers ?? {},
+				...getAuthHeaders(renderedConfig, oauthToken)
+			}
+		};
+	} else if (config.command) out = {
+		type: "stdio",
+		command: config.command,
+		args: config.args ?? [],
+		...config.env && { env: config.env }
+	};
+	else if (config.path) out = {
+		type: "stdio",
+		command: config.path.endsWith(".py") ? process.platform === "win32" ? "python" : "python3" : process.execPath,
+		args: [config.path],
+		...config.env && { env: config.env }
+	};
+	else throw new Error("MCP configuration cannot be converted to Claude Agent SDK MCP server config");
+	return out;
+}
+//#endregion
+export { validateMCPConfigForClaudeCode as a, transformMCPToolsToOpenAi as i, transformMCPToolsToAnthropic as n, transformMCPToolsToGoogle as r, transformMCPConfigToClaudeCode as t };
+
+//# sourceMappingURL=transform-DAED8imp.js.map