@use-lattice/litmus 0.121.3

package/dist/src/meteor-DUiCJRC-.js

@@ -0,0 +1,134 @@
+import { t as invariant } from "./invariant-Ddh24eXh.js";
+//#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();
+	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();
+	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 }) {
+	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
+export { handleMeteorAssertion };
+
+//# sourceMappingURL=meteor-DUiCJRC-.js.map

package/dist/src/modelslab-00cveB8L.cjs

@@ -0,0 +1,163 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_fetch = require("./fetch-BTxakTSg.cjs");
+const require_cache = require("./cache-DsCxFlsZ.cjs");
+const require_blobs = require("./blobs-BgcNn97m.cjs");
+const require_extractor = require("./extractor-DnMD3fwt.cjs");
+const require_text = require("./text-CW1cyrwj.cjs");
+//#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 || require_logger.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 {
+			require_logger.logger.debug("[ModelsLab] Image generation request", {
+				model: this.modelName,
+				prompt: require_text.ellipsize(prompt, 50)
+			});
+			const response = await require_cache.fetchWithCache(`${MODELSLAB_BASE_URL}/images/text2img`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(requestBody)
+			}, require_fetch.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);
+				require_logger.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: `![${require_text.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 (!require_extractor.isBlobStorageEnabled()) return { url: imageUrl };
+		try {
+			const response = await require_fetch.fetchWithProxy(imageUrl);
+			if (!response.ok) {
+				require_logger.logger.warn("[ModelsLab] Failed to download image for blob storage", {
+					url: imageUrl,
+					status: response.status
+				});
+				return { url: imageUrl };
+			}
+			const { ref } = await require_blobs.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) {
+			require_logger.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 require_cache.fetchWithCache(fetchUrl, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({ key: this.apiKey })
+				}, require_fetch.REQUEST_TIMEOUT_MS, "json", true)).data;
+				require_logger.logger.debug("[ModelsLab] Poll attempt", {
+					attempt: attempt + 1,
+					requestId,
+					status: data.status
+				});
+				if (data.status === "success" || data.status === "error") return data;
+			} catch (error) {
+				require_logger.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
+exports.ModelsLabImageProvider = ModelsLabImageProvider;
+
+//# sourceMappingURL=modelslab-00cveB8L.cjs.map

package/dist/src/modelslab-D9sCU_L7.js

@@ -0,0 +1,163 @@
+import { r as logger, x as getEnvString } from "./logger-C40ZGil9.js";
+import { h as REQUEST_TIMEOUT_MS, t as fetchWithProxy } from "./fetch-DQckpUFz.js";
+import { r as fetchWithCache } from "./cache-BkrqU5Ba.js";
+import { n as storeBlob } from "./blobs-BY8MDmpo.js";
+import { n as isBlobStorageEnabled } from "./extractor-DtlL28vL.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-D9sCU_L7.js.map