promptfoo 0.125.0 → 0.125.1

package/dist/src/decisions-jYix_gCF.js

@@ -1,515 +0,0 @@
-import { E as sanitizeUrlForLogging, T as sanitizeUrlEncodedString, u as isCredentialHeader, x as sanitizeObject } from "./logger-Gff7RMNF.js";
-import { A as isAbortError, O as formatRateLimitErrorMessage, d as getCloudAuthHeaderName, f as getCloudBearerToken, h as isPromptfooCloudApiHost, w as HttpRateLimitError } from "./fetch-BCwjoIFd.js";
-import { a as getRequestTimeoutMs } from "./shared-BBI-NXjW.js";
-import { c as extractProviderResponseAttributes, h as withGenAISpan } from "./genaiTracer-CuSjHi4t.js";
-import { i as fetchWithCache } from "./cache-CEYhFUsH.js";
-import { n as renderVarsInObject } from "./render-DuOHcYot.js";
-import { N as hasSensitiveOpenAiCacheString, d as appendOpenAiApiPath, f as assertOpenAiApiModel } from "./util-CsTD_ROg.js";
-import { r as calculateOpenAIUsageCost } from "./billing-Gg_jbkR9.js";
-import { n as OpenAiGenericProvider, r as hasHeaderOverride } from "./openai-TU3iAci7.js";
-import { r as getResponsesTokenUsage, t as normalizeResponsesInput } from "./input-C6OUkYP4.js";
-import { n as escapeRegExp } from "./text-Fd7EOhdv.js";
-import { m as decodeUrlComponent } from "./server/index.js";
-import { z as z$1 } from "zod";
-import { createHash, randomUUID } from "node:crypto";
-import { LRUCache } from "lru-cache";
-//#region src/providers/openai/decisions.ts
-const cacheScopes = new LRUCache({
-	max: 256,
-	ttl: 18e5,
-	ttlAutopurge: true,
-	updateAgeOnGet: true
-});
-const choiceValue = z$1.union([z$1.string(), z$1.boolean()]);
-const probability = z$1.number().min(0).max(1);
-const DISTRIBUTION_TOLERANCE = .01 + 1e-12;
-const questionFields = {
-	name: z$1.string().optional(),
-	instructions: z$1.string()
-};
-const levelSchema = z$1.object({
-	label: z$1.string(),
-	description: z$1.string().optional()
-}).strict();
-const gradingLevelsSchema = z$1.array(z$1.union([z$1.string().transform((label) => ({ label })), levelSchema])).min(2).max(10);
-const questionSchema = z$1.discriminatedUnion("type", [
-	z$1.object({
-		...questionFields,
-		type: z$1.literal("predicate")
-	}).strict(),
-	z$1.object({
-		...questionFields,
-		type: z$1.literal("choice"),
-		choices: z$1.array(z$1.object({
-			value: choiceValue,
-			description: z$1.string().optional()
-		}).strict()).min(2).max(255).refine((choices) => new Set(choices.map((choice) => choice.value)).size === choices.length, { message: "Choice values must be unique within the question" })
-	}).strict(),
-	z$1.object({
-		...questionFields,
-		type: z$1.literal("score"),
-		levels: z$1.array(levelSchema).min(2).max(10)
-	}).strict()
-]);
-const questionsSchema = z$1.array(questionSchema).min(1).refine((questions) => {
-	const names = questions.map(({ name }) => name).filter((name) => name !== void 0);
-	return new Set(names).size === names.length;
-}, { message: "Question names must be unique within the request" });
-const inputSchema = z$1.union([z$1.string(), z$1.array(z$1.object({
-	type: z$1.literal("message").optional(),
-	role: z$1.literal("user"),
-	content: z$1.union([z$1.string(), z$1.array(z$1.discriminatedUnion("type", [z$1.object({
-		type: z$1.literal("input_text"),
-		text: z$1.string()
-	}), z$1.object({
-		type: z$1.literal("input_image"),
-		image_url: z$1.string().regex(/^data:image\/[^;,]+;base64,/i, "Decisions images must be inline base64 data URLs"),
-		detail: z$1.enum([
-			"auto",
-			"low",
-			"high",
-			"original"
-		]).nullable().optional()
-	})]))])
-}))]);
-const requestSchema = z$1.object({
-	model: z$1.string().trim().min(1),
-	input: inputSchema.refine((input) => typeof input === "string" || input.reduce((count, message) => count + (Array.isArray(message.content) ? message.content.filter((part) => part.type === "input_image").length : 0), 0) <= 128, { message: "Decisions accepts at most 128 images per request" }),
-	questions: questionsSchema,
-	safety_identifier: z$1.string().max(128).nullable().optional()
-});
-const answerName = { name: z$1.string().nullable() };
-const answerSchema = z$1.discriminatedUnion("type", [
-	z$1.object({
-		...answerName,
-		type: z$1.literal("refusal")
-	}),
-	z$1.object({
-		...answerName,
-		type: z$1.literal("predicate"),
-		probability
-	}),
-	z$1.object({
-		...answerName,
-		type: z$1.literal("choice"),
-		choice: choiceValue,
-		confidence: probability,
-		probabilities: z$1.array(z$1.object({
-			value: choiceValue,
-			probability
-		}))
-	}),
-	z$1.object({
-		...answerName,
-		type: z$1.literal("score"),
-		score: z$1.number().nonnegative(),
-		confidence: probability,
-		probabilities: z$1.array(z$1.object({
-			value: z$1.number().int(),
-			label: z$1.string(),
-			probability
-		}))
-	})
-]);
-const tokenCount = z$1.number().int().nonnegative();
-const responseSchema = z$1.object({
-	model: z$1.string().min(1),
-	answers: z$1.array(answerSchema),
-	usage: z$1.object({
-		input_tokens: tokenCount,
-		output_tokens: tokenCount,
-		total_tokens: tokenCount,
-		input_tokens_details: z$1.object({
-			cached_tokens: tokenCount.optional(),
-			cache_write_tokens: tokenCount.optional()
-		}).passthrough().optional(),
-		output_tokens_details: z$1.object({ reasoning_tokens: tokenCount.optional() }).passthrough().optional()
-	}).refine(({ input_tokens, output_tokens, total_tokens }) => total_tokens === input_tokens + output_tokens)
-});
-function hasSensitiveValue(value) {
-	if (typeof value === "string") return hasSensitiveOpenAiCacheString(value);
-	return value !== null && typeof value === "object" ? Object.values(value).some(hasSensitiveValue) : false;
-}
-/** Collect gateway authentication forms without changing the supplied headers. */
-function getHeaderCredentials(name, value) {
-	const trimmed = value.trim();
-	const credentials = [value, trimmed.replace(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+\s+/, "")];
-	const basic = /^Basic\s+([a-z\d+/]+={0,2})$/i.exec(trimmed);
-	if (basic) {
-		const bytes = Buffer.from(basic[1], "base64");
-		const decoded = bytes.toString("utf8");
-		const separator = decoded.indexOf(":");
-		if (separator !== -1 && bytes.toString("base64").replace(/=+$/, "") === basic[1].replace(/=+$/, "")) credentials.push(decoded, decoded.slice(0, separator), decoded.slice(separator + 1));
-	}
-	if (name.toLowerCase() === "cookie") for (const part of value.split(";")) {
-		const separator = part.indexOf("=");
-		if (separator !== -1) {
-			const raw = part.slice(separator + 1).trim();
-			const unquoted = raw.replace(/^"(.*)"$/, "$1");
-			const decoded = decodeUrlComponent(unquoted);
-			const decodedValue = decoded.replace(/^"(.*)"$/, "$1");
-			const cookieName = part.slice(0, separator).trim().replace(/^__(?:Host|Secure)-/i, "");
-			if (isCredentialHeader(cookieName, decodedValue) || /^(?:csrf|xsrf)$/i.test(cookieName) || /(?:session(?:[-_]?id)?|sessid|(?:^|[._-])sid)$/i.test(cookieName)) credentials.push(raw, unquoted, decoded, decodedValue);
-		}
-	}
-	return credentials;
-}
-/** Collect URL authentication forms without changing the gateway request URL. */
-function getUrlCredentials(value) {
-	let url;
-	try {
-		url = new URL(value);
-	} catch {
-		return [];
-	}
-	const credentials = [];
-	if (url.username || url.password) {
-		const raw = [url.username, url.password];
-		const decoded = raw.map(decodeUrlComponent);
-		const pair = decoded.join(":");
-		const basic = Buffer.from(pair).toString("base64");
-		credentials.push(...raw, ...decoded, raw.join(":"), pair, basic, `Basic ${basic}`);
-	}
-	const sanitizedSegments = sanitizeUrlForLogging(url.pathname).split("/");
-	for (const [index, segment] of url.pathname.split("/").entries()) if (sanitizedSegments[index] === "%5BREDACTED%5D") credentials.push(segment, decodeUrlComponent(segment));
-	for (const segment of url.search.slice(1).split(/[&;]/)) {
-		const separator = segment.indexOf("=");
-		if (separator !== -1 && sanitizeUrlEncodedString(segment) !== segment) {
-			const [, decoded] = Array.from(new URLSearchParams(segment))[0];
-			credentials.push(segment.slice(separator + 1), decoded);
-		}
-	}
-	return credentials;
-}
-/** Check correspondence before an eval can mistake a malformed result for a successful answer. */
-function answersMatchQuestions(answers, questions) {
-	return answers.length === questions.length && answers.every((answer, index) => {
-		const question = questions[index];
-		if (answer.name !== (question.name ?? null)) return false;
-		if (answer.type === "refusal") return true;
-		if ((answer.type === "choice" || answer.type === "score") && Math.abs(answer.probabilities.reduce((sum, item) => sum + item.probability, 0) - 1) > DISTRIBUTION_TOLERANCE) return false;
-		if (answer.type === "choice" && question.type === "choice") return question.choices.some(({ value }) => value === answer.choice) && answer.probabilities.length === question.choices.length && new Set(answer.probabilities.map(({ value }) => value)).size === question.choices.length && answer.probabilities.every(({ value }) => question.choices.some((choice) => choice.value === value));
-		if (answer.type === "score" && question.type === "score") {
-			const maxScore = question.levels.length - 1;
-			const expectedScore = answer.probabilities.reduce((sum, item) => sum + item.value * item.probability, 0);
-			return answer.score <= maxScore && Math.abs(answer.score - expectedScore) / maxScore <= DISTRIBUTION_TOLERANCE && answer.probabilities.length === question.levels.length && new Set(answer.probabilities.map(({ value }) => value)).size === question.levels.length && answer.probabilities.every(({ value, label }) => value >= 0 && label === question.levels[value]?.label);
-		}
-		return answer.type === question.type;
-	});
-}
-var OpenAiDecisionsProvider = class extends OpenAiGenericProvider {
-	get handlesOwnRetries() {
-		return true;
-	}
-	constructor(modelName, options = {}) {
-		const model = modelName || options.config?.model;
-		if (typeof model !== "string" || !model.trim()) throw new Error("OpenAI Decisions requires a model: use openai:decisions:<model> or config.model");
-		super(model, options);
-	}
-	id() {
-		return `openai:decisions:${this.modelName}`;
-	}
-	async callApi(prompt, context, options) {
-		const config = {
-			...this.config,
-			...context?.prompt?.config
-		};
-		const label = context?.prompt?.label;
-		if (context?.isGrading) {
-			if (label === "llm-rubric") return this.grade(prompt, config, context, options);
-			return { error: `OpenAI Decisions cannot grade \`${label}\` assertions. Use \`llm-rubric\` or \`classifier\`.` };
-		}
-		let input = prompt;
-		if (prompt.trimStart().startsWith("[")) try {
-			input = normalizeResponsesInput(JSON.parse(prompt));
-		} catch {}
-		return this.ask(input, config, context, options);
-	}
-	async callClassificationApi(prompt, options) {
-		const parsed = z$1.object({
-			instructions: z$1.string().min(1),
-			labels: z$1.union([z$1.array(z$1.string()).min(1), z$1.record(z$1.string(), z$1.string().nullable())])
-		}).safeParse(this.config);
-		if (!parsed.success) return { error: "OpenAI Decisions classifier needs `instructions` and `labels` (strings or a label-to-description map)." };
-		const { instructions, labels } = parsed.data;
-		const choices = Array.isArray(labels) ? labels.map((value) => ({ value })) : Object.entries(labels).map(([value, description]) => ({
-			value,
-			...description === null ? {} : { description }
-		}));
-		const result = await this.ask(prompt, {
-			...this.config,
-			questions: [{
-				name: "classification",
-				type: "choice",
-				instructions,
-				choices
-			}]
-		}, void 0, options);
-		if (result.error) return result;
-		const answer = responseSchema.parse(result.raw).answers[0];
-		const { output: _output, ...response } = result;
-		if (answer.type !== "choice") return {
-			...response,
-			error: "OpenAI Decisions refused to classify the input."
-		};
-		return {
-			...response,
-			classification: Object.fromEntries(answer.probabilities.map(({ value, probability }) => [value, probability]))
-		};
-	}
-	async grade(prompt, config, context, options) {
-		try {
-			const messages = z$1.array(z$1.object({ content: z$1.unknown().optional() })).safeParse(JSON.parse(prompt));
-			const textPart = z$1.object({
-				type: z$1.enum([
-					"text",
-					"input_text",
-					"output_text"
-				]),
-				text: z$1.string()
-			});
-			if (messages.success && messages.data.some(({ content }) => Array.isArray(content) && content.some((part) => !textPart.safeParse(part).success))) return { error: "OpenAI Decisions `llm-rubric` supports text output only; media attachments are not supported." };
-		} catch {}
-		const threshold = probability.safeParse(config.threshold ?? .5);
-		if (!threshold.success) return { error: "OpenAI Decisions `threshold` must be a number from 0 to 1." };
-		const { rubric, output } = context.vars;
-		if (rubric === void 0 || output === void 0) return { error: "OpenAI Decisions `llm-rubric` requires rubric and output variables." };
-		const levels = config.levels === void 0 ? void 0 : gradingLevelsSchema.safeParse(config.levels);
-		if (levels && !levels.success) return { error: "OpenAI Decisions `levels` must list 2 to 10 strings or {label, description?} objects, ordered low to high." };
-		const instructions = typeof rubric === "string" ? rubric : JSON.stringify(rubric);
-		const question = levels?.success ? {
-			name: "grade",
-			type: "score",
-			instructions,
-			levels: levels.data
-		} : {
-			name: "grade",
-			type: "predicate",
-			instructions
-		};
-		const result = await this.ask(typeof output === "string" ? output : JSON.stringify(output), {
-			...config,
-			questions: [question]
-		}, context, options);
-		if (result.error) return result;
-		const answer = responseSchema.parse(result.raw).answers[0];
-		if (answer.type !== "predicate" && answer.type !== "score") return {
-			...result,
-			output: void 0,
-			error: "OpenAI Decisions refused to grade the output."
-		};
-		const raw = answer.type === "predicate" ? answer.probability : answer.score;
-		const top = question.type === "score" ? question.levels.length - 1 : 1;
-		const score = raw / top;
-		const pass = score >= threshold.data;
-		const comparison = `< threshold ${threshold.data}`;
-		const reason = answer.type === "predicate" ? `Decisions predicate probability ${raw} ${comparison}` : `Decisions score ${raw} on levels 0–${top} (${score} normalized) ${comparison}`;
-		return {
-			...result,
-			output: {
-				pass,
-				score,
-				...!pass && { reason }
-			}
-		};
-	}
-	async ask(input, config, context, options) {
-		options?.abortSignal?.throwIfAborted();
-		const apiKey = this.getApiKey(config);
-		if ((config.apiKeyRequired ?? true) && !apiKey) throw new Error(this.getMissingApiKeyErrorMessage(config));
-		let body;
-		try {
-			body = requestSchema.parse({
-				model: this.modelName,
-				input,
-				questions: context?.isGrading && context.prompt.label === "llm-rubric" ? config.questions : renderVarsInObject(config.questions, context?.vars),
-				safety_identifier: renderVarsInObject(config.safety_identifier, context?.vars)
-			});
-			assertOpenAiApiModel(body.model, this.getApiUrl(config));
-		} catch (error) {
-			return { error: `Invalid OpenAI Decisions request: ${error instanceof z$1.ZodError ? error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ") : String(error)}` };
-		}
-		return withGenAISpan({
-			system: this.getGenAISystem(),
-			operationName: "chat",
-			model: body.model,
-			providerId: this.id(),
-			evalId: context?.evaluationId,
-			testIndex: context?.testIdx,
-			promptLabel: context?.prompt?.label,
-			traceparent: context?.traceparent,
-			requestBody: typeof input === "string" ? input : JSON.stringify(input)
-		}, () => this.callDecisions(body, config, apiKey, context, options), extractProviderResponseAttributes);
-	}
-	async callDecisions(body, config, apiKey, context, options) {
-		const headers = Object.fromEntries(Object.entries({
-			...hasHeaderOverride(config.headers, "Content-Type") ? {} : { "Content-Type": "application/json" },
-			...apiKey && !hasHeaderOverride(config.headers, "Authorization") ? { Authorization: `Bearer ${apiKey}` } : {},
-			...this.getOpenAiRequestHeaders(config.headers, config)
-		}).filter(([name]) => name.toLowerCase() !== "x-promptfoo-silent"));
-		const apiUrl = this.getApiUrl(config);
-		const cloudAuthHeaderName = isPromptfooCloudApiHost(apiUrl) ? getCloudAuthHeaderName() : void 0;
-		const cloudAuth = getCloudBearerToken(apiUrl);
-		if (cloudAuth && cloudAuthHeaderName && !hasHeaderOverride(headers, cloudAuthHeaderName)) {
-			const url = new URL(apiUrl);
-			if (cloudAuthHeaderName.toLowerCase() !== "authorization" || !(url.username || url.password)) headers[cloudAuthHeaderName] = cloudAuth;
-		}
-		const secrets = [
-			apiKey,
-			...getUrlCredentials(apiUrl),
-			...Object.entries(headers).filter(([name, value]) => name.toLowerCase() === cloudAuthHeaderName?.toLowerCase() || isCredentialHeader(name, value)).flatMap(([name, value]) => getHeaderCredentials(name, value))
-		].filter((secret) => Boolean(secret)).flatMap((secret) => {
-			const variants = [secret, JSON.stringify(secret).slice(1, -1)];
-			try {
-				return [...variants, encodeURIComponent(secret)];
-			} catch {
-				return variants;
-			}
-		});
-		headers["x-promptfoo-silent"] = "true";
-		const credentialPattern = new RegExp([.../* @__PURE__ */ new Set([...secrets, "[REDACTED]"])].sort((left, right) => right.length - left.length).map((secret) => secret.length > 1 ? escapeRegExp(secret) : `(?<!\\w)${escapeRegExp(secret)}(?!\\w)`).join("|"), "g");
-		const redactCredentials = (value, publicModel) => value.replace(credentialPattern, (match) => publicModel?.includes(match) ? match : "[REDACTED]");
-		const errorText = (value) => redactCredentials(String(sanitizeObject(String(value), { sanitizeUrls: true })));
-		const publicIdentifiers = new Set(body.questions.flatMap((question) => [question.name, ...question.type === "choice" ? question.choices.map(({ value }) => value) : question.type === "score" ? question.levels.map(({ label }) => label) : []]));
-		const responseData = (value, schema) => {
-			if (schema instanceof z$1.ZodOptional) schema = schema.unwrap();
-			if (schema instanceof z$1.ZodDiscriminatedUnion) schema = schema.options.find((option) => z$1.safeParse(option, value).success);
-			if (schema instanceof z$1.ZodLiteral && schema.safeParse(value).success) return value;
-			if (typeof value === "string") {
-				if (schema === responseSchema.shape.model) return redactCredentials(value, body.model);
-				return schema && publicIdentifiers.has(value) ? value : redactCredentials(value);
-			}
-			if (Array.isArray(value)) {
-				const element = schema instanceof z$1.ZodArray ? schema.element : void 0;
-				return value.map((item) => responseData(item, element));
-			}
-			if (value !== null && typeof value === "object") {
-				const shape = schema instanceof z$1.ZodObject ? schema.shape : void 0;
-				return Object.fromEntries(Object.entries(value).map(([key, item]) => {
-					const field = shape && Object.prototype.hasOwnProperty.call(shape, key) ? shape[key] : void 0;
-					return [field ? key : redactCredentials(key), responseData(item, field)];
-				}));
-			}
-			return value;
-		};
-		const responseHeaders = (values = {}) => Object.fromEntries(Object.entries(values).filter(([name]) => /^(?:retry-after(?:-ms)?|x-request-id|(?:x-)?ratelimit-(?:limit|remaining|reset)(?:-(?:requests|tokens))?)$/i.test(name)).map(([name, value]) => [name.toLowerCase(), errorText(value)]));
-		let deleteFromCache;
-		try {
-			const url = appendOpenAiApiPath(apiUrl, "decisions");
-			const transport = JSON.stringify([url, Array.from(new Headers(headers).entries()).sort()]);
-			let scope = cacheScopes.get(transport);
-			if (!scope) {
-				scope = randomUUID();
-				cacheScopes.set(transport, scope);
-			}
-			const bust = this.shouldBustCache(context) || hasSensitiveValue(body);
-			const cacheKey = bust ? void 0 : `openai-decisions:${createHash("sha256").update(JSON.stringify({
-				scope,
-				body
-			})).digest("hex")}`;
-			const response = await fetchWithCache(url, {
-				method: "POST",
-				headers,
-				body: JSON.stringify(body),
-				signal: options?.abortSignal,
-				skipCloudAuthInjection: cloudAuthHeaderName !== void 0
-			}, getRequestTimeoutMs(), "json", {
-				bust,
-				cacheKey,
-				repeatIndex: context?.repeatIndex,
-				sanitizeResponse: ({ data, statusText, headers }) => ({
-					data: responseData(data, responseSchema),
-					statusText: errorText(statusText),
-					headers: responseHeaders(headers)
-				})
-			}, config.maxRetries);
-			deleteFromCache = response.deleteFromCache;
-			const { data, status, latencyMs } = response;
-			const http = {
-				status,
-				statusText: errorText(response.statusText),
-				headers: responseHeaders(response.headers)
-			};
-			const cached = response.cached || response.coalesced === true;
-			const httpMetadata = cached ? {} : { http };
-			const apiError = z$1.object({ error: z$1.object({ message: z$1.string() }) }).safeParse(data);
-			if (status < 200 || status >= 300 || apiError.success) {
-				await deleteFromCache?.();
-				return {
-					error: `OpenAI Decisions API error (${status}): ${errorText(apiError.success ? apiError.data.error.message : response.statusText || "Request failed")}`,
-					metadata: httpMetadata
-				};
-			}
-			const result = responseSchema.safeParse(data);
-			if (!result.success) {
-				await deleteFromCache?.();
-				return {
-					error: "Invalid OpenAI Decisions API response: answers or usage do not match the request",
-					metadata: httpMetadata
-				};
-			}
-			const { answers, model, usage } = result.data;
-			const inputCost = config.inputCost ?? config.cost;
-			const outputCost = config.outputCost ?? config.cost;
-			const cost = inputCost !== void 0 && outputCost !== void 0 ? calculateOpenAIUsageCost(model, {
-				...config,
-				inputCost,
-				outputCost
-			}, usage, { cachedResponse: cached }) : void 0;
-			const accounting = {
-				cached,
-				latencyMs,
-				tokenUsage: cached ? {
-					total: usage.total_tokens,
-					cached: usage.total_tokens
-				} : {
-					...getResponsesTokenUsage(result.data, false),
-					cached: usage.input_tokens_details?.cached_tokens
-				},
-				...cost === void 0 ? {} : { cost }
-			};
-			if (!answersMatchQuestions(answers, body.questions)) {
-				await deleteFromCache?.();
-				return {
-					...accounting,
-					error: "Invalid OpenAI Decisions API response: answers or usage do not match the request",
-					metadata: httpMetadata
-				};
-			}
-			return {
-				...accounting,
-				output: JSON.stringify({ answers }),
-				raw: data,
-				metadata: {
-					...httpMetadata,
-					model,
-					requestId: http.headers["x-request-id"]
-				},
-				...answers.every((answer) => answer.type === "refusal") ? { isRefusal: true } : {}
-			};
-		} catch (error) {
-			options?.abortSignal?.throwIfAborted();
-			if (isAbortError(error)) throw error;
-			await deleteFromCache?.();
-			if (error instanceof HttpRateLimitError) return {
-				error: `OpenAI Decisions API error: ${errorText(formatRateLimitErrorMessage(error))}`,
-				metadata: {
-					rateLimitKind: error.kind,
-					http: {
-						status: error.status,
-						statusText: errorText(error.statusText),
-						headers: {
-							...responseHeaders(error.headers),
-							...error.retryAfterMs === void 0 ? {} : { "retry-after-ms": String(error.retryAfterMs) }
-						}
-					}
-				}
-			};
-			return { error: `OpenAI Decisions API call failed: ${errorText(error)}` };
-		}
-	}
-};
-//#endregion
-export { OpenAiDecisionsProvider };
-
-//# sourceMappingURL=decisions-jYix_gCF.js.map