@use-lattice/litmus 0.121.3

package/dist/src/server-BOuAXb06.cjs

@@ -0,0 +1,238 @@
+const require_logger = require("./logger-DyfK9PBt.cjs");
+const require_fetch = require("./fetch-BTxakTSg.cjs");
+const require_accounts = require("./accounts-Bt1oJb1Z.cjs");
+let readline = require("readline");
+readline = require_logger.__toESM(readline);
+//#region src/redteam/remoteGeneration.ts
+/**
+* Gets the remote generation API endpoint URL.
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The remote generation URL
+*/
+function getRemoteGenerationUrl() {
+	const envUrl = require_logger.getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) return envUrl;
+	const cloudConfig = new require_fetch.CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task";
+	return "https://api.promptfoo.app/api/v1/task";
+}
+/**
+* Check if remote generation should never be used.
+* Respects both the general and redteam-specific disable flags.
+* @returns true if remote generation is disabled
+*/
+function neverGenerateRemote() {
+	if (require_logger.getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION")) return true;
+	return require_logger.getEnvBool("PROMPTFOO_DISABLE_REDTEAM_REMOTE_GENERATION");
+}
+/**
+* Check if remote generation should never be used for non-redteam features.
+* This allows granular control: disable redteam remote generation while allowing
+* regular SimulatedUser to use remote generation.
+* @returns true if ALL remote generation is disabled
+*/
+function neverGenerateRemoteForRegularEvals() {
+	return require_logger.getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION");
+}
+/**
+* Builds a remote URL with a substituted pathname, honoring env vars / cloud config.
+*/
+function buildRemoteUrl(pathname, fallback) {
+	if (neverGenerateRemote()) return null;
+	const envUrl = require_logger.getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) try {
+		const url = new URL(envUrl);
+		url.pathname = pathname;
+		return url.toString();
+	} catch {
+		return fallback;
+	}
+	const cloudConfig = new require_fetch.CloudConfig();
+	if (cloudConfig.isEnabled()) return `${cloudConfig.getApiHost()}${pathname}`;
+	return fallback;
+}
+/**
+* Gets the URL for checking remote API health based on configuration.
+* @returns The health check URL, or null if remote generation is disabled.
+*/
+function getRemoteHealthUrl() {
+	return buildRemoteUrl("/health", "https://api.promptfoo.app/health");
+}
+/**
+* Gets the URL for checking remote API version based on configuration.
+* @returns The version check URL, or null if remote generation is disabled.
+*/
+function getRemoteVersionUrl() {
+	return buildRemoteUrl("/version", "https://api.promptfoo.app/version");
+}
+/**
+* Determines if remote generation should be used based on configuration.
+* @returns true if remote generation should be used
+*/
+function shouldGenerateRemote() {
+	if (neverGenerateRemote()) return false;
+	if (require_accounts.isLoggedIntoCloud()) return true;
+	return !require_logger.getEnvString("OPENAI_API_KEY") || (require_logger.state.remote ?? false);
+}
+/**
+* Gets the URL for unaligned model inference (harmful content generation).
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The unaligned inference URL
+*/
+function getRemoteGenerationUrlForUnaligned() {
+	const envUrl = require_logger.getEnvString("PROMPTFOO_UNALIGNED_INFERENCE_ENDPOINT");
+	if (envUrl) return envUrl;
+	const cloudConfig = new require_fetch.CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task/harmful";
+	return "https://api.promptfoo.app/api/v1/task/harmful";
+}
+//#endregion
+//#region src/util/readline.ts
+/**
+* Factory function for creating readline interface.
+* This abstraction makes it easier to mock in tests and prevents open handles.
+*/
+function createReadlineInterface() {
+	return readline.default.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+}
+/**
+* Prompts the user with a question and returns their answer.
+* Automatically handles cleanup of the readline interface.
+*/
+async function promptUser(question) {
+	return new Promise((resolve, reject) => {
+		let rl = null;
+		try {
+			rl = createReadlineInterface();
+			rl.on("error", (err) => {
+				if (rl) rl.close();
+				reject(err);
+			});
+			rl.question(question, (answer) => {
+				if (rl) rl.close();
+				resolve(answer);
+			});
+		} catch (err) {
+			if (rl) rl.close();
+			reject(err);
+		}
+	});
+}
+/**
+* Prompts the user with a yes/no question and returns a boolean.
+* @param question The question to ask
+* @param defaultYes If true, empty response defaults to yes. If false, defaults to no.
+*/
+async function promptYesNo(question, defaultYes = false) {
+	const answer = await promptUser(`${question} ${defaultYes ? "(Y/n): " : "(y/N): "}`);
+	if (defaultYes) return !answer.trim().toLowerCase().startsWith("n");
+	return answer.trim().toLowerCase().startsWith("y");
+}
+//#endregion
+//#region src/util/server.ts
+const BrowserBehavior = {
+	ASK: 0,
+	OPEN: 1,
+	SKIP: 2,
+	OPEN_TO_REPORT: 3,
+	OPEN_TO_REDTEAM_CREATE: 4,
+	OPEN_TO_EVAL_SETUP: 5
+};
+BrowserBehavior.ASK, BrowserBehavior.OPEN, BrowserBehavior.SKIP, BrowserBehavior.OPEN_TO_REPORT, BrowserBehavior.OPEN_TO_REDTEAM_CREATE, BrowserBehavior.OPEN_TO_EVAL_SETUP;
+const featureCache = /* @__PURE__ */ new Map();
+/**
+* Checks if a server supports a specific feature based on build date
+* @param featureName - Name of the feature (for caching and logging)
+* @param requiredBuildDate - Minimum build date when feature was added (ISO string)
+* @returns Promise<boolean> - true if server supports the feature
+*/
+async function checkServerFeatureSupport(featureName, requiredBuildDate) {
+	const cacheKey = `${featureName}`;
+	if (featureCache.has(cacheKey)) return featureCache.get(cacheKey);
+	let supported = false;
+	try {
+		require_logger.logger.debug(`[Feature Detection] Checking server support for feature: ${featureName}`);
+		const versionUrl = getRemoteVersionUrl();
+		if (versionUrl) {
+			const data = await (await require_fetch.fetchWithProxy(versionUrl, {
+				method: "GET",
+				headers: { "Content-Type": "application/json" }
+			})).json();
+			if (data.buildDate) {
+				supported = new Date(data.buildDate) >= new Date(requiredBuildDate);
+				require_logger.logger.debug(`[Feature Detection] ${featureName}: buildDate=${data.buildDate}, required=${requiredBuildDate}, supported=${supported}`);
+			} else {
+				require_logger.logger.debug(`[Feature Detection] ${featureName}: no version info, assuming not supported`);
+				supported = false;
+			}
+		} else {
+			require_logger.logger.debug(`[Feature Detection] No remote URL available for ${featureName}, assuming local server supports it`);
+			supported = true;
+		}
+	} catch (error) {
+		require_logger.logger.debug(`[Feature Detection] Version check failed for ${featureName}, assuming not supported: ${error}`);
+		supported = false;
+	}
+	featureCache.set(cacheKey, supported);
+	return supported;
+}
+//#endregion
+Object.defineProperty(exports, "BrowserBehavior", {
+	enumerable: true,
+	get: function() {
+		return BrowserBehavior;
+	}
+});
+Object.defineProperty(exports, "checkServerFeatureSupport", {
+	enumerable: true,
+	get: function() {
+		return checkServerFeatureSupport;
+	}
+});
+Object.defineProperty(exports, "getRemoteGenerationUrl", {
+	enumerable: true,
+	get: function() {
+		return getRemoteGenerationUrl;
+	}
+});
+Object.defineProperty(exports, "getRemoteGenerationUrlForUnaligned", {
+	enumerable: true,
+	get: function() {
+		return getRemoteGenerationUrlForUnaligned;
+	}
+});
+Object.defineProperty(exports, "getRemoteHealthUrl", {
+	enumerable: true,
+	get: function() {
+		return getRemoteHealthUrl;
+	}
+});
+Object.defineProperty(exports, "neverGenerateRemote", {
+	enumerable: true,
+	get: function() {
+		return neverGenerateRemote;
+	}
+});
+Object.defineProperty(exports, "neverGenerateRemoteForRegularEvals", {
+	enumerable: true,
+	get: function() {
+		return neverGenerateRemoteForRegularEvals;
+	}
+});
+Object.defineProperty(exports, "promptYesNo", {
+	enumerable: true,
+	get: function() {
+		return promptYesNo;
+	}
+});
+Object.defineProperty(exports, "shouldGenerateRemote", {
+	enumerable: true,
+	get: function() {
+		return shouldGenerateRemote;
+	}
+});
+
+//# sourceMappingURL=server-BOuAXb06.cjs.map

package/dist/src/server-CtI-EWzm.cjs

@@ -0,0 +1,2 @@
+const require_server = require("./server-BOuAXb06.cjs");
+exports.checkServerFeatureSupport = require_server.checkServerFeatureSupport;

package/dist/src/server-Cy3DZymt.js

@@ -0,0 +1,189 @@
+import { t as __exportAll } from "./chunk-DEq-mXcV.js";
+import { T as state, r as logger, v as getEnvBool, x as getEnvString } from "./logger-C40ZGil9.js";
+import { a as CloudConfig, t as fetchWithProxy } from "./fetch-DQckpUFz.js";
+import { o as isLoggedIntoCloud } from "./accounts-DjOU8Rm3.js";
+import readline from "readline";
+//#region src/redteam/remoteGeneration.ts
+/**
+* Gets the remote generation API endpoint URL.
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The remote generation URL
+*/
+function getRemoteGenerationUrl() {
+	const envUrl = getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) return envUrl;
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task";
+	return "https://api.promptfoo.app/api/v1/task";
+}
+/**
+* Check if remote generation should never be used.
+* Respects both the general and redteam-specific disable flags.
+* @returns true if remote generation is disabled
+*/
+function neverGenerateRemote() {
+	if (getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION")) return true;
+	return getEnvBool("PROMPTFOO_DISABLE_REDTEAM_REMOTE_GENERATION");
+}
+/**
+* Check if remote generation should never be used for non-redteam features.
+* This allows granular control: disable redteam remote generation while allowing
+* regular SimulatedUser to use remote generation.
+* @returns true if ALL remote generation is disabled
+*/
+function neverGenerateRemoteForRegularEvals() {
+	return getEnvBool("PROMPTFOO_DISABLE_REMOTE_GENERATION");
+}
+/**
+* Builds a remote URL with a substituted pathname, honoring env vars / cloud config.
+*/
+function buildRemoteUrl(pathname, fallback) {
+	if (neverGenerateRemote()) return null;
+	const envUrl = getEnvString("PROMPTFOO_REMOTE_GENERATION_URL");
+	if (envUrl) try {
+		const url = new URL(envUrl);
+		url.pathname = pathname;
+		return url.toString();
+	} catch {
+		return fallback;
+	}
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return `${cloudConfig.getApiHost()}${pathname}`;
+	return fallback;
+}
+/**
+* Gets the URL for checking remote API health based on configuration.
+* @returns The health check URL, or null if remote generation is disabled.
+*/
+function getRemoteHealthUrl() {
+	return buildRemoteUrl("/health", "https://api.promptfoo.app/health");
+}
+/**
+* Gets the URL for checking remote API version based on configuration.
+* @returns The version check URL, or null if remote generation is disabled.
+*/
+function getRemoteVersionUrl() {
+	return buildRemoteUrl("/version", "https://api.promptfoo.app/version");
+}
+/**
+* Determines if remote generation should be used based on configuration.
+* @returns true if remote generation should be used
+*/
+function shouldGenerateRemote() {
+	if (neverGenerateRemote()) return false;
+	if (isLoggedIntoCloud()) return true;
+	return !getEnvString("OPENAI_API_KEY") || (state.remote ?? false);
+}
+/**
+* Gets the URL for unaligned model inference (harmful content generation).
+* Prioritizes: env var > cloud config > default endpoint.
+* @returns The unaligned inference URL
+*/
+function getRemoteGenerationUrlForUnaligned() {
+	const envUrl = getEnvString("PROMPTFOO_UNALIGNED_INFERENCE_ENDPOINT");
+	if (envUrl) return envUrl;
+	const cloudConfig = new CloudConfig();
+	if (cloudConfig.isEnabled()) return cloudConfig.getApiHost() + "/api/v1/task/harmful";
+	return "https://api.promptfoo.app/api/v1/task/harmful";
+}
+//#endregion
+//#region src/util/readline.ts
+/**
+* Factory function for creating readline interface.
+* This abstraction makes it easier to mock in tests and prevents open handles.
+*/
+function createReadlineInterface() {
+	return readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+}
+/**
+* Prompts the user with a question and returns their answer.
+* Automatically handles cleanup of the readline interface.
+*/
+async function promptUser(question) {
+	return new Promise((resolve, reject) => {
+		let rl = null;
+		try {
+			rl = createReadlineInterface();
+			rl.on("error", (err) => {
+				if (rl) rl.close();
+				reject(err);
+			});
+			rl.question(question, (answer) => {
+				if (rl) rl.close();
+				resolve(answer);
+			});
+		} catch (err) {
+			if (rl) rl.close();
+			reject(err);
+		}
+	});
+}
+/**
+* Prompts the user with a yes/no question and returns a boolean.
+* @param question The question to ask
+* @param defaultYes If true, empty response defaults to yes. If false, defaults to no.
+*/
+async function promptYesNo(question, defaultYes = false) {
+	const answer = await promptUser(`${question} ${defaultYes ? "(Y/n): " : "(y/N): "}`);
+	if (defaultYes) return !answer.trim().toLowerCase().startsWith("n");
+	return answer.trim().toLowerCase().startsWith("y");
+}
+//#endregion
+//#region src/util/server.ts
+var server_exports = /* @__PURE__ */ __exportAll({
+	BrowserBehavior: () => BrowserBehavior,
+	checkServerFeatureSupport: () => checkServerFeatureSupport
+});
+const BrowserBehavior = {
+	ASK: 0,
+	OPEN: 1,
+	SKIP: 2,
+	OPEN_TO_REPORT: 3,
+	OPEN_TO_REDTEAM_CREATE: 4,
+	OPEN_TO_EVAL_SETUP: 5
+};
+BrowserBehavior.ASK, BrowserBehavior.OPEN, BrowserBehavior.SKIP, BrowserBehavior.OPEN_TO_REPORT, BrowserBehavior.OPEN_TO_REDTEAM_CREATE, BrowserBehavior.OPEN_TO_EVAL_SETUP;
+const featureCache = /* @__PURE__ */ new Map();
+/**
+* Checks if a server supports a specific feature based on build date
+* @param featureName - Name of the feature (for caching and logging)
+* @param requiredBuildDate - Minimum build date when feature was added (ISO string)
+* @returns Promise<boolean> - true if server supports the feature
+*/
+async function checkServerFeatureSupport(featureName, requiredBuildDate) {
+	const cacheKey = `${featureName}`;
+	if (featureCache.has(cacheKey)) return featureCache.get(cacheKey);
+	let supported = false;
+	try {
+		logger.debug(`[Feature Detection] Checking server support for feature: ${featureName}`);
+		const versionUrl = getRemoteVersionUrl();
+		if (versionUrl) {
+			const data = await (await fetchWithProxy(versionUrl, {
+				method: "GET",
+				headers: { "Content-Type": "application/json" }
+			})).json();
+			if (data.buildDate) {
+				supported = new Date(data.buildDate) >= new Date(requiredBuildDate);
+				logger.debug(`[Feature Detection] ${featureName}: buildDate=${data.buildDate}, required=${requiredBuildDate}, supported=${supported}`);
+			} else {
+				logger.debug(`[Feature Detection] ${featureName}: no version info, assuming not supported`);
+				supported = false;
+			}
+		} else {
+			logger.debug(`[Feature Detection] No remote URL available for ${featureName}, assuming local server supports it`);
+			supported = true;
+		}
+	} catch (error) {
+		logger.debug(`[Feature Detection] Version check failed for ${featureName}, assuming not supported: ${error}`);
+		supported = false;
+	}
+	featureCache.set(cacheKey, supported);
+	return supported;
+}
+//#endregion
+export { getRemoteGenerationUrlForUnaligned as a, neverGenerateRemoteForRegularEvals as c, getRemoteGenerationUrl as i, shouldGenerateRemote as l, server_exports as n, getRemoteHealthUrl as o, promptYesNo as r, neverGenerateRemote as s, checkServerFeatureSupport as t };
+
+//# sourceMappingURL=server-Cy3DZymt.js.map

package/dist/src/slack-CP8xBePa.js

@@ -0,0 +1,135 @@
+import { r as logger } from "./logger-C40ZGil9.js";
+import { WebClient } from "@slack/web-api";
+//#region src/providers/slack.ts
+var SlackProvider = class {
+	client;
+	options;
+	constructor(options = {}) {
+		this.options = options;
+		const token = options.config?.token || process.env.SLACK_BOT_TOKEN;
+		if (!token) throw new Error("Slack provider requires a token. Set SLACK_BOT_TOKEN or provide it in config.");
+		if (!options.config?.channel) throw new Error("Slack provider requires a channel ID");
+		this.client = new WebClient(token);
+	}
+	id() {
+		return this.options.id || "slack";
+	}
+	async callApi(prompt, _context, _options) {
+		const config = this.options.config;
+		const channel = config.channel;
+		const timeout = config.timeout || 6e4;
+		const responseStrategy = config.responseStrategy || "first";
+		try {
+			const messageText = config.formatMessage ? config.formatMessage(prompt) : prompt;
+			const startTime = Date.now();
+			const postResult = await this.client.chat.postMessage({
+				channel,
+				text: messageText,
+				thread_ts: config.threadTs,
+				mrkdwn: true
+			});
+			if (!postResult.ok || !postResult.ts) throw new Error("Failed to post message to Slack");
+			const messageTs = postResult.ts;
+			let responseText;
+			const responseMetadata = {
+				messageTs,
+				channel
+			};
+			switch (responseStrategy) {
+				case "timeout":
+					responseText = await this.collectResponsesUntilTimeout(channel, messageTs, timeout);
+					break;
+				case "user":
+					if (!config.waitForUser) throw new Error("waitForUser must be specified when using \"user\" response strategy");
+					responseText = await this.waitForUserResponse(channel, messageTs, config.waitForUser, timeout);
+					responseMetadata.waitForUser = config.waitForUser;
+					break;
+				default:
+					responseText = await this.waitForFirstResponse(channel, messageTs, timeout);
+					break;
+			}
+			if (config.includeThread) responseMetadata.threadTs = messageTs;
+			responseMetadata.responseTime = Date.now() - startTime;
+			return {
+				output: responseText,
+				metadata: responseMetadata
+			};
+		} catch (error) {
+			logger.error(`Slack provider error: ${error}`);
+			if (error?.data?.error) {
+				const slackError = error.data.error;
+				switch (slackError) {
+					case "channel_not_found": return { error: `Channel ${channel} not found. Please check the channel ID.` };
+					case "not_in_channel": return { error: `Bot is not in channel ${channel}. Please invite the bot first.` };
+					case "missing_scope": return { error: "Bot token is missing required scopes. Please check permissions." };
+					case "ratelimited": return { error: "Slack API rate limit exceeded. Please try again later." };
+					default: return { error: `Slack API error: ${slackError}` };
+				}
+			}
+			return { error: error instanceof Error ? error.message : "Unknown error" };
+		}
+	}
+	async waitForFirstResponse(channel, afterTs, timeout) {
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 10
+			});
+			if (result.messages && result.messages.length > 0) {
+				const response = result.messages.filter((msg) => msg.ts !== afterTs && msg.type === "message" && !msg.bot_id).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0"))[0];
+				if (response && response.text) return response.text;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		throw new Error(`Timeout waiting for Slack response after ${timeout}ms`);
+	}
+	async waitForUserResponse(channel, afterTs, userId, timeout) {
+		const startTime = Date.now();
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 20
+			});
+			if (result.messages && result.messages.length > 0) {
+				const response = result.messages.filter((msg) => msg.ts !== afterTs && msg.type === "message" && msg.user === userId).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0"))[0];
+				if (response && response.text) return response.text;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		throw new Error(`Timeout waiting for response from user ${userId} after ${timeout}ms`);
+	}
+	async collectResponsesUntilTimeout(channel, afterTs, timeout) {
+		const startTime = Date.now();
+		const responses = [];
+		const seenTimestamps = new Set([afterTs]);
+		while (Date.now() - startTime < timeout) try {
+			const result = await this.client.conversations.history({
+				channel,
+				oldest: afterTs,
+				limit: 50
+			});
+			if (result.messages && result.messages.length > 0) result.messages.filter((msg) => !seenTimestamps.has(msg.ts || "") && msg.type === "message" && !msg.bot_id).sort((a, b) => parseFloat(a.ts || "0") - parseFloat(b.ts || "0")).forEach((msg) => {
+				if (msg.ts) seenTimestamps.add(msg.ts);
+				if (msg.text) responses.push(msg.text);
+			});
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+		} catch (error) {
+			logger.error(`Error fetching Slack messages: ${error}`);
+			throw error;
+		}
+		return responses.join("\n\n");
+	}
+};
+//#endregion
+export { SlackProvider };
+
+//# sourceMappingURL=slack-CP8xBePa.js.map