@use-lattice/litmus 0.121.3

package/dist/src/messages-B5ADWTTv.js

@@ -0,0 +1,245 @@
+import { b as getEnvInt, r as logger, x as getEnvString, y as getEnvFloat } from "./logger-C40ZGil9.js";
+import { d as maybeLoadToolsFromExternalFile, u as maybeLoadResponseFormatFromExternalFile } from "./util-DuntT1Ga.js";
+import { T as transformTools, w as transformToolChoice } from "./fetch-DQckpUFz.js";
+import { a as isCacheEnabled, i as getCache } from "./cache-BkrqU5Ba.js";
+import { n as withGenAISpan } from "./genaiTracer-D3fD9dNV.js";
+import { i as normalizeFinishReason, n as MCPClient } from "./chat-CcDgZFJ4.js";
+import { a as createEmptyTokenUsage } from "./tokenUsageUtils-NYT-WKS6.js";
+import { n as transformMCPToolsToAnthropic } from "./transform-CY1wbpRy.js";
+import { a as parseMessages, i as outputFromMessage, n as calculateAnthropicCost, o as processAnthropicTools, r as getTokenUsage, t as ANTHROPIC_MODELS } from "./util-BkKlTkI2.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
+function parseEnvFloat(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseFloat(value);
+	return Number.isNaN(parsed) ? void 0 : parsed;
+}
+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 ?? parseEnvFloat(this.env?.ANTHROPIC_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-B5ADWTTv.js.map

package/dist/src/messages-BCnZfqrS.cjs

@@ -0,0 +1,257 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_util = require("./util-CTh0bfOm.cjs");
+const require_fetch = require("./fetch-BTxakTSg.cjs");
+const require_cache = require("./cache-DsCxFlsZ.cjs");
+const require_genaiTracer = require("./genaiTracer-CyZrmaK0.cjs");
+const require_chat = require("./chat-CXX3xzkk.cjs");
+const require_tokenUsageUtils = require("./tokenUsageUtils-bVa1ga6f.cjs");
+const require_transform = require("./transform-Bv6gG2MJ.cjs");
+const require_util$1 = require("./util-D17oBwo7.cjs");
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = require_logger.__toESM(_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_ai_sdk.default({
+			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 || require_logger.getEnvString("ANTHROPIC_API_KEY");
+	}
+	getApiBaseUrl() {
+		return this.config?.apiBaseUrl || this.env?.ANTHROPIC_BASE_URL || require_logger.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
+function parseEnvFloat(value) {
+	if (value === void 0) return;
+	const parsed = Number.parseFloat(value);
+	return Number.isNaN(parsed) ? void 0 : parsed;
+}
+var AnthropicMessagesProvider = class AnthropicMessagesProvider extends AnthropicGenericProvider {
+	mcpClient = null;
+	initializationPromise = null;
+	static ANTHROPIC_MODELS = require_util$1.ANTHROPIC_MODELS;
+	static ANTHROPIC_MODELS_NAMES = require_util$1.ANTHROPIC_MODELS.map((model) => model.id);
+	constructor(modelName, options = {}) {
+		if (!AnthropicMessagesProvider.ANTHROPIC_MODELS_NAMES.includes(modelName)) require_logger.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 require_chat.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 require_genaiTracer.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 } = require_util$1.parseMessages(prompt);
+		let mcpTools = [];
+		if (this.mcpClient) mcpTools = require_transform.transformMCPToolsToAnthropic(this.mcpClient.getAllTools());
+		const { processedTools: processedConfigTools, requiredBetaFeatures } = require_util$1.processAnthropicTools(require_fetch.transformTools(await require_util.maybeLoadToolsFromExternalFile(config.tools, context?.vars) || [], "anthropic"));
+		const allTools = [...mcpTools, ...processedConfigTools];
+		const processedOutputFormat = require_util.maybeLoadResponseFormatFromExternalFile(config.output_format, context?.vars);
+		const shouldStream = config.stream ?? false;
+		const params = {
+			model: this.modelName,
+			...system ? { system } : {},
+			max_tokens: config?.max_tokens || require_logger.getEnvInt("ANTHROPIC_MAX_TOKENS", config.thinking || thinking ? 2048 : 1024),
+			messages: extractedMessages,
+			stream: shouldStream,
+			temperature: config.thinking || thinking ? config.temperature : config.temperature ?? parseEnvFloat(this.env?.ANTHROPIC_TEMPERATURE) ?? require_logger.getEnvFloat("ANTHROPIC_TEMPERATURE", 0),
+			...allTools.length > 0 ? { tools: allTools } : {},
+			...config.tool_choice ? { tool_choice: require_fetch.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 : {}
+		};
+		require_logger.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 require_cache.getCache();
+		const cacheKey = `anthropic:${JSON.stringify(params)}`;
+		if (require_cache.isCacheEnabled()) {
+			const cachedResponse = await cache.get(cacheKey);
+			if (cachedResponse) {
+				require_logger.logger.debug(`Returning cached response for ${prompt}: ${cachedResponse}`);
+				try {
+					const parsedCachedResponse = JSON.parse(cachedResponse);
+					const finishReason = require_chat.normalizeFinishReason(parsedCachedResponse.stop_reason);
+					let output = require_util$1.outputFromMessage(parsedCachedResponse, config.showThinking ?? true);
+					if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+						output = JSON.parse(output);
+					} catch (error) {
+						require_logger.logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+					}
+					return {
+						output,
+						tokenUsage: require_util$1.getTokenUsage(parsedCachedResponse, true),
+						...finishReason && { finishReason },
+						cost: require_util$1.calculateAnthropicCost(this.modelName, config, parsedCachedResponse.usage?.input_tokens, parsedCachedResponse.usage?.output_tokens),
+						cached: true
+					};
+				} catch {
+					return {
+						output: cachedResponse,
+						tokenUsage: require_tokenUsageUtils.createEmptyTokenUsage()
+					};
+				}
+			}
+		}
+		try {
+			if (shouldStream) {
+				const finalMessage = await (await this.anthropic.messages.stream(params, { ...typeof headers === "object" && Object.keys(headers).length > 0 ? { headers } : {} })).finalMessage();
+				require_logger.logger.debug(`Anthropic Messages API streaming complete`, { finalMessage });
+				if (require_cache.isCacheEnabled()) try {
+					await cache.set(cacheKey, JSON.stringify(finalMessage));
+				} catch (err) {
+					require_logger.logger.error(`Failed to cache response: ${String(err)}`);
+				}
+				const finishReason = require_chat.normalizeFinishReason(finalMessage.stop_reason);
+				let output = require_util$1.outputFromMessage(finalMessage, config.showThinking ?? true);
+				if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+					output = JSON.parse(output);
+				} catch (error) {
+					require_logger.logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+				}
+				return {
+					output,
+					tokenUsage: require_util$1.getTokenUsage(finalMessage, false),
+					...finishReason && { finishReason },
+					cost: require_util$1.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 } : {} });
+				require_logger.logger.debug(`Anthropic Messages API response`, { response });
+				if (require_cache.isCacheEnabled()) try {
+					await cache.set(cacheKey, JSON.stringify(response));
+				} catch (err) {
+					require_logger.logger.error(`Failed to cache response: ${String(err)}`);
+				}
+				const finishReason = require_chat.normalizeFinishReason(response.stop_reason);
+				let output = require_util$1.outputFromMessage(response, config.showThinking ?? true);
+				if (processedOutputFormat?.type === "json_schema" && typeof output === "string") try {
+					output = JSON.parse(output);
+				} catch (error) {
+					require_logger.logger.error(`Failed to parse JSON output from structured outputs: ${error}`);
+				}
+				return {
+					output,
+					tokenUsage: require_util$1.getTokenUsage(response, false),
+					...finishReason && { finishReason },
+					cost: require_util$1.calculateAnthropicCost(this.modelName, config, response.usage?.input_tokens, response.usage?.output_tokens)
+				};
+			}
+		} catch (err) {
+			require_logger.logger.error(`Anthropic Messages API call error: ${err instanceof Error ? err.message : String(err)}`);
+			if (err instanceof _anthropic_ai_sdk.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
+Object.defineProperty(exports, "AnthropicGenericProvider", {
+	enumerable: true,
+	get: function() {
+		return AnthropicGenericProvider;
+	}
+});
+Object.defineProperty(exports, "AnthropicMessagesProvider", {
+	enumerable: true,
+	get: function() {
+		return AnthropicMessagesProvider;
+	}
+});
+
+//# sourceMappingURL=messages-BCnZfqrS.cjs.map

package/dist/src/meteor-DLZZ3osF.cjs

@@ -0,0 +1,134 @@
+const require_invariant = require("./invariant-kfQ8Bu82.cjs");
+//#region src/assertions/meteor.ts
+let PorterStemmer;
+let WordNet;
+async function ensureNaturalPackage() {
+	if (PorterStemmer && WordNet) return;
+	try {
+		const natural = await import("natural");
+		PorterStemmer = natural.PorterStemmer;
+		WordNet = natural.WordNet;
+	} catch (_err) {
+		throw new Error("The \"natural\" package is required for METEOR assertions. Install it with: npm install natural@^8.1.0");
+	}
+}
+function preprocessWord(word) {
+	return word.toLowerCase();
+}
+function generateEnums(candidate, reference, preprocess = preprocessWord) {
+	if (typeof candidate === "string") throw new TypeError(`"candidate" expects pre-tokenized candidate (string[]): ${candidate}`);
+	if (typeof reference === "string") throw new TypeError(`"reference" expects pre-tokenized reference (string[]): ${reference}`);
+	return [candidate.map((word, idx) => [idx, preprocess(word)]), reference.map((word, idx) => [idx, preprocess(word)])];
+}
+function matchExactEnums(enumCandidateList, enumReferenceList) {
+	const wordMatch = [];
+	const candidateCopy = [...enumCandidateList];
+	const referenceCopy = [...enumReferenceList];
+	for (let i = candidateCopy.length - 1; i >= 0; i--) for (let j = referenceCopy.length - 1; j >= 0; j--) if (candidateCopy[i][1] === referenceCopy[j][1]) {
+		wordMatch.push([candidateCopy[i][0], referenceCopy[j][0]]);
+		candidateCopy.splice(i, 1);
+		referenceCopy.splice(j, 1);
+		break;
+	}
+	return [
+		wordMatch,
+		candidateCopy,
+		referenceCopy
+	];
+}
+async function matchStemEnums(enumCandidateList, enumReferenceList, stemmer) {
+	await ensureNaturalPackage();
+	require_invariant.invariant(PorterStemmer, "PorterStemmer should be loaded");
+	const actualStemmer = stemmer || PorterStemmer;
+	const candidateCopy = [...enumCandidateList];
+	const referenceCopy = [...enumReferenceList];
+	const candidateStems = candidateCopy.map(([idx, word]) => [idx, actualStemmer.stem(word)]);
+	const referenceStems = referenceCopy.map(([idx, word]) => [idx, actualStemmer.stem(word)]);
+	return matchExactEnums(candidateStems.map(([idx, stem]) => [idx, stem]), referenceStems.map(([idx, stem]) => [idx, stem]));
+}
+async function matchSynonymEnums(enumCandidateList, enumReferenceList, wordnet) {
+	await ensureNaturalPackage();
+	require_invariant.invariant(WordNet, "WordNet should be loaded");
+	const actualWordNet = wordnet || new WordNet();
+	const wordMatch = [];
+	const candidateCopy = [...enumCandidateList];
+	const referenceCopy = [...enumReferenceList];
+	for (let i = candidateCopy.length - 1; i >= 0; i--) {
+		const candidateWord = candidateCopy[i][1];
+		const candidateSynsets = await new Promise((resolve) => {
+			actualWordNet.lookup(candidateWord, (results) => resolve(results));
+		});
+		const candidateSynonymSet = new Set([candidateWord, ...candidateSynsets.flatMap((synset) => synset.synonyms.filter((syn) => !syn.includes("_")))]);
+		for (let j = referenceCopy.length - 1; j >= 0; j--) {
+			const referenceWord = referenceCopy[j][1];
+			if (candidateSynonymSet.has(referenceWord)) {
+				wordMatch.push([candidateCopy[i][0], referenceCopy[j][0]]);
+				candidateCopy.splice(i, 1);
+				referenceCopy.splice(j, 1);
+				break;
+			}
+		}
+	}
+	return [
+		wordMatch,
+		candidateCopy,
+		referenceCopy
+	];
+}
+function countChunks(matches) {
+	if (matches.length === 0) return 0;
+	let chunks = 1;
+	for (let i = 0; i < matches.length - 1; i++) if (matches[i + 1][0] !== matches[i][0] + 1 || matches[i + 1][1] !== matches[i][1] + 1) chunks++;
+	return chunks;
+}
+async function calculateSingleMeteorScore(reference, candidate, alpha = .9, beta = 3, gamma = .5) {
+	const [enumCandidate, enumReference] = generateEnums(candidate, reference);
+	const translationLength = enumCandidate.length;
+	const referenceLength = enumReference.length;
+	const [exactMatches, remainingCandidate, remainingReference] = matchExactEnums(enumCandidate, enumReference);
+	const [stemMatches, remainingCandidateAfterStem, remainingReferenceAfterStem] = await matchStemEnums(remainingCandidate, remainingReference);
+	const [synonymMatches, ,] = await matchSynonymEnums(remainingCandidateAfterStem, remainingReferenceAfterStem);
+	const allMatches = [
+		...exactMatches,
+		...stemMatches,
+		...synonymMatches
+	].sort((a, b) => a[0] - b[0]);
+	const matchesCount = allMatches.length;
+	if (matchesCount === 0) return 0;
+	let fragFrac = 0;
+	let fmean = 0;
+	if (translationLength === 0 || referenceLength === 0 || matchesCount === 0) return 0;
+	const precision = matchesCount / translationLength;
+	const recall = matchesCount / referenceLength;
+	const denominator = alpha * precision + (1 - alpha) * recall;
+	if (denominator === 0) return 0;
+	fmean = precision * recall / denominator;
+	fragFrac = countChunks(allMatches) / matchesCount;
+	return (1 - gamma * Math.pow(fragFrac, beta)) * fmean;
+}
+async function calculateMeteorScore(candidate, references, alpha = .9, beta = 3, gamma = .5) {
+	if (!candidate || references.length === 0) throw new Error("Invalid inputs");
+	const scores = await Promise.all(references.map((reference) => calculateSingleMeteorScore(reference.split(/\s+/).map((word) => word.replace(/\.+$/, "")), candidate.split(/\s+/).map((word) => word.replace(/\.+$/, "")), alpha, beta, gamma)));
+	return Math.max(...scores);
+}
+async function handleMeteorAssertion({ assertion, inverse, outputString, renderedValue }) {
+	require_invariant.invariant(typeof renderedValue === "string" || Array.isArray(renderedValue) && renderedValue.every((v) => typeof v === "string"), "\"meteor\" assertion must have a string or array of strings value");
+	const references = Array.isArray(renderedValue) ? renderedValue : [renderedValue];
+	const meteorAssertion = assertion;
+	const alpha = meteorAssertion.alpha ?? .9;
+	const beta = meteorAssertion.beta ?? 3;
+	const gamma = meteorAssertion.gamma ?? .5;
+	const threshold = meteorAssertion.threshold ?? .5;
+	const score = await calculateMeteorScore(outputString, references, alpha, beta, gamma);
+	const pass = inverse ? score < threshold : score >= threshold;
+	return {
+		pass,
+		score: inverse ? 1 - score : score,
+		reason: pass ? "METEOR assertion passed" : `METEOR score ${score.toFixed(4)} did not meet threshold ${threshold}`,
+		assertion
+	};
+}
+//#endregion
+exports.handleMeteorAssertion = handleMeteorAssertion;
+
+//# sourceMappingURL=meteor-DLZZ3osF.cjs.map