@happyvertical/smrt-inference 0.0.0-stage → 0.60.15

package/dist/chunks/provider-config-4Bx8N52X.js

@@ -0,0 +1,1847 @@
+import { INFERENCE_FUSION_MODES, INFERENCE_MODES, INFERENCE_PRESETS, INFERENCE_TIERS, InferenceUnavailableError, builtInInferenceResolver, compareInferenceTiers, getInferenceExecutor, getInferenceResolver, importOptionalDependency, inferenceTargetKind, isInferenceMode, isInferencePresetId, isInferenceTier, isInferenceTierRequest, isInferenceUnavailableError, resolveAutoTier, setInferenceExecutor, setInferenceResolver } from "@happyvertical/smrt-core";
+import { SmrtError } from "@happyvertical/smrt-core/smrt-error";
+//#region src/errors.ts
+var InferenceConfigError = class extends SmrtError {
+	issues;
+	constructor(issues) {
+		super(`Invalid inference config: ${issues.map((issue) => issue.message).join("; ")}`, "INFERENCE_CONFIG_INVALID", "configuration", { issues });
+		this.issues = issues;
+	}
+};
+var InferenceExhaustedError = class extends SmrtError {
+	/** The failure that ended the walk. */
+	reason;
+	/** The full fallback trail, ending with `to: null`. */
+	substitutions;
+	/** Text already streamed to the caller, for a `partial` ending. */
+	partialText;
+	constructor(input) {
+		const last = input.substitutions.at(-1);
+		super(input.reason === "partial" ? `Inference candidate ${last?.from ?? "unknown"} failed after streaming; no other candidate may extend its reply.` : `No inference candidate answered tier "${input.tierRequested}" (last failure: ${input.reason}).`, "INFERENCE_EXHAUSTED", "ai", {
+			reason: input.reason,
+			tierRequested: input.tierRequested,
+			substitutions: input.substitutions
+		}, input.cause instanceof Error ? input.cause : void 0);
+		this.reason = input.reason;
+		this.substitutions = input.substitutions;
+		if (input.partialText !== void 0) this.partialText = input.partialText;
+	}
+};
+var InferenceFusionError = class extends SmrtError {
+	result;
+	constructor(result, cause) {
+		const failures = result.seats.filter((seat) => seat.failure).map((seat) => `${seat.name}: ${seat.failure?.reason}`);
+		super(`Fusion "${result.fusionKey}" produced no answer (run ${result.runId}${failures.length > 0 ? `; ${failures.join(", ")}` : ""}).`, "INFERENCE_FUSION_FAILED", "ai", {
+			runId: result.runId,
+			fusionKey: result.fusionKey,
+			failures
+		}, cause instanceof Error ? cause : void 0);
+		this.result = result;
+	}
+};
+//#endregion
+//#region src/fusion-store.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("smrt.inference.fusions");
+function fusionStore() {
+	const holder = globalThis;
+	holder[STORE_KEY] ??= /* @__PURE__ */ new Map();
+	return holder[STORE_KEY];
+}
+function lookupFusion(key, config) {
+	const fromConfig = config?.fusions;
+	if (fromConfig && Object.hasOwn(fromConfig, key)) return fromConfig[key];
+	return fusionStore().get(key);
+}
+function isPromptRegistered(key) {
+	const registry = globalThis.__smrtPromptRegistry;
+	return registry instanceof Map && registry.has(key);
+}
+//#endregion
+//#region src/config.ts
+var CHAIN_KINDS = ["alias", "candidates"];
+var KEYLESS_PLACEHOLDER$1 = "smrt-local";
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text$1(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+var EXECUTOR_KINDS = [...CHAIN_KINDS, "fusion"];
+function hasInferenceChains(config) {
+	if (!config) return false;
+	if (isRecord$1(config.aliases) && Object.keys(config.aliases).length > 0) return true;
+	if (isRecord$1(config.fusions) && Object.keys(config.fusions).length > 0) return true;
+	return Object.values(config.tiers ?? {}).some((target) => EXECUTOR_KINDS.includes(inferenceTargetKind(target)));
+}
+function checkCandidate(candidate, path, aliases, issues) {
+	if (!isRecord$1(candidate)) {
+		issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} must be an object`
+		});
+		return;
+	}
+	const alias = text$1(candidate.alias);
+	if (candidate.alias !== void 0) {
+		if (!alias) issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path}.alias must be a non-empty string`
+		});
+		else if (!Object.hasOwn(aliases, alias)) issues.push({
+			path,
+			code: "alias-unknown",
+			message: `${path} references unknown alias "${alias}"`
+		});
+		const extra = [
+			"provider",
+			"model",
+			"preset",
+			"baseUrl",
+			"apiKeyEnv"
+		].find((key) => candidate[key] !== void 0);
+		if (extra) issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} names an alias and "${extra}"; an alias candidate takes nothing else`
+		});
+		return;
+	}
+	const preset = text$1(candidate.preset);
+	if (candidate.preset !== void 0) {
+		if (!preset || !isInferencePresetId(preset)) issues.push({
+			path,
+			code: "preset-unknown",
+			message: `${path} names unknown preset "${String(candidate.preset)}"; expected one of ${Object.keys(INFERENCE_PRESETS).join(", ")}`
+		});
+		if (!text$1(candidate.model)) issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} names preset "${String(candidate.preset)}" without a model`
+		});
+		if (candidate.provider !== void 0) issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} names both a preset and a provider`
+		});
+		return;
+	}
+	if (!text$1(candidate.provider) && !text$1(candidate.model)) {
+		issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} needs an alias, a preset, or a provider and model`
+		});
+		return;
+	}
+	if ((text$1(candidate.apiKeyEnv) || text$1(candidate.apiKey)) && !text$1(candidate.baseUrl)) issues.push({
+		path,
+		code: "candidate-key-without-endpoint",
+		message: `${path} brings its own key without a baseUrl; a key travels only with its own endpoint (name the provider's baseUrl, or drop apiKeyEnv to use the provider's own key variable)`
+	});
+}
+function checkCandidateList(list, path, aliases, issues) {
+	if (!Array.isArray(list) || list.length === 0) {
+		issues.push({
+			path,
+			code: "alias-empty",
+			message: `${path} has no candidates`
+		});
+		return;
+	}
+	list.forEach((candidate, index) => {
+		checkCandidate(candidate, `${path}[${index}]`, aliases, issues);
+	});
+}
+function checkTarget(target, path, aliases, issues, config) {
+	const kind = inferenceTargetKind(target);
+	if (kind === "alias") {
+		const name = text$1(target.alias);
+		if (!name) issues.push({
+			path,
+			code: "candidate-invalid",
+			message: `${path} has kind "alias" without an alias name`
+		});
+		else if (!Object.hasOwn(aliases, name)) issues.push({
+			path,
+			code: "alias-unknown",
+			message: `${path} points at unknown alias "${name}"`
+		});
+	} else if (kind === "candidates") checkCandidateList(target.candidates, `${path}.candidates`, aliases, issues);
+	else if (kind === "fusion") {
+		const name = text$1(target.fusion);
+		if (!name) issues.push({
+			path,
+			code: "fusion-invalid",
+			message: `${path} has kind "fusion" without a fusion key`
+		});
+		else if (!lookupFusion(name, config)) issues.push({
+			path,
+			code: "fusion-unknown",
+			message: `${path} points at unknown fusion "${name}" (define it with defineFusion() or inference.fusions)`
+		});
+	}
+}
+var FUSION_SEAT_COUNTS = {
+	single: 1,
+	pair: 3,
+	handoff: 2
+};
+var FUSION_GATE_CONTINUE = "continue";
+var FUSION_GATE_SEAT = "gate";
+function findFusionDefinitionIssues(definition, path, config) {
+	const issues = [];
+	const invalid = (at, message) => issues.push({
+		path: at,
+		code: "fusion-invalid",
+		message
+	});
+	if (!isRecord$1(definition)) {
+		invalid(path, `${path} must be an object with mode and seats`);
+		return issues;
+	}
+	const mode = definition.mode;
+	const known = INFERENCE_FUSION_MODES.includes(mode);
+	if (!known) invalid(`${path}.mode`, `${path}.mode must be one of ${INFERENCE_FUSION_MODES.join(", ")}; got "${String(mode)}"`);
+	if (definition.description !== void 0 && typeof definition.description !== "string") invalid(`${path}.description`, `${path}.description must be a string`);
+	const seats = definition.seats;
+	if (!Array.isArray(seats)) invalid(`${path}.seats`, `${path}.seats must be an array of seats`);
+	else {
+		const expected = known ? FUSION_SEAT_COUNTS[mode] : void 0;
+		if (expected !== void 0 && seats.length !== expected) invalid(`${path}.seats`, `${path}.seats must hold exactly ${expected} seat(s) for mode "${String(mode)}"; got ${seats.length}`);
+		const aliases = isRecord$1(config?.aliases) ? config.aliases : {};
+		const names = /* @__PURE__ */ new Map();
+		seats.forEach((seat, index) => {
+			const at = `${path}.seats[${index}]`;
+			if (!isRecord$1(seat)) {
+				invalid(at, `${at} must be an object with prompt and target`);
+				return;
+			}
+			const prompt = text$1(seat.prompt);
+			if (!prompt) invalid(`${at}.prompt`, `${at}.prompt must name a registered prompt key`);
+			if (seat.name !== void 0 && !text$1(seat.name)) invalid(`${at}.name`, `${at}.name must be a non-empty string`);
+			const name = text$1(seat.name) ?? prompt;
+			if (name) {
+				const first = names.get(name);
+				if (name === "gate") invalid(`${at}.name`, `${at}.name "${FUSION_GATE_SEAT}" is reserved for the decision gate's usage row`);
+				else if (first !== void 0) invalid(`${at}.name`, `${at} has the same name "${name}" as seats[${first}]; name each seat (the name defaults to the prompt key)`);
+				else names.set(name, index);
+			}
+			if (seat.temperature !== void 0 && (typeof seat.temperature !== "number" || !Number.isFinite(seat.temperature))) invalid(`${at}.temperature`, `${at}.temperature must be a number`);
+			if (seat.output !== void 0 && seat.output !== "text" && seat.output !== "json") invalid(`${at}.output`, `${at}.output must be "text" or "json"`);
+			const target = seat.target;
+			if (typeof target === "string") {
+				if (!isInferenceTierRequest(target)) invalid(`${at}.target`, `${at}.target "${target}" is not a tier (auto, ${INFERENCE_TIERS.join(", ")})`);
+			} else if (isRecord$1(target)) if (inferenceTargetKind(target) === "fusion") issues.push({
+				path: `${at}.target`,
+				code: "fusion-nested",
+				message: `${at}.target names another fusion; seats run a tier, an alias or a model, never a fusion`
+			});
+			else checkTarget(target, `${at}.target`, aliases, issues, config);
+			else invalid(`${at}.target`, `${at}.target must be a tier name or a target ({ alias }, { candidates } or { provider, model })`);
+		});
+	}
+	const gate = definition.gate;
+	if (gate !== void 0) if (mode !== "pair" && mode !== "handoff") invalid(`${path}.gate`, `${path}.gate applies to pair and handoff only`);
+	else if (!isRecord$1(gate)) invalid(`${path}.gate`, `${path}.gate must be an object`);
+	else {
+		if (!text$1(gate.criteria)) invalid(`${path}.gate.criteria`, `${path}.gate.criteria must be a non-empty string`);
+		const when = gate.sufficientWhen;
+		if (!isRecord$1(when)) invalid(`${path}.gate.sufficientWhen`, `${path}.gate.sufficientWhen must be { choice, minConfidence }`);
+		else {
+			const choice = text$1(when.choice);
+			if (!choice || choice === "continue") invalid(`${path}.gate.sufficientWhen.choice`, `${path}.gate.sufficientWhen.choice must be a non-empty label other than "${FUSION_GATE_CONTINUE}"`);
+			const min = when.minConfidence;
+			if (typeof min !== "number" || !Number.isFinite(min) || min < 0 || min > 1) invalid(`${path}.gate.sufficientWhen.minConfidence`, `${path}.gate.sufficientWhen.minConfidence must be a number in [0, 1]`);
+		}
+	}
+	return issues;
+}
+function findFusionDefinitionPromptIssues(definition, path) {
+	if (!isRecord$1(definition) || !Array.isArray(definition.seats)) return [];
+	const issues = [];
+	definition.seats.forEach((seat, index) => {
+		const prompt = isRecord$1(seat) ? text$1(seat.prompt) : void 0;
+		if (prompt && !isPromptRegistered(prompt)) {
+			const at = `${path}.seats[${index}].prompt`;
+			issues.push({
+				path: at,
+				code: "fusion-prompt-unknown",
+				message: `${at} names prompt "${prompt}", which no definePrompt() registered`
+			});
+		}
+	});
+	return issues;
+}
+function findFusionPromptIssues(config) {
+	if (!isRecord$1(config?.fusions)) return [];
+	return Object.entries(config.fusions).flatMap(([key, definition]) => findFusionDefinitionPromptIssues(definition, `inference.fusions.${key}`));
+}
+function validateInferenceTarget(target, path, config) {
+	const issues = [];
+	checkTarget(target, path, isRecord$1(config?.aliases) ? config.aliases : {}, issues, config);
+	if (issues.length > 0) throw new InferenceConfigError(issues);
+}
+function aliasEdges(alias) {
+	if (!isRecord$1(alias) || !Array.isArray(alias.candidates)) return [];
+	return alias.candidates.map((candidate) => isRecord$1(candidate) ? text$1(candidate.alias) : void 0).filter((name) => !!name);
+}
+function findInferenceConfigIssues(config) {
+	const issues = [];
+	if (!config) return issues;
+	const aliases = isRecord$1(config.aliases) ? config.aliases : {};
+	for (const [name, alias] of Object.entries(aliases)) {
+		const path = `inference.aliases.${name}`;
+		if (!isRecord$1(alias)) {
+			issues.push({
+				path,
+				code: "alias-empty",
+				message: `${path} must be an object with candidates`
+			});
+			continue;
+		}
+		checkCandidateList(alias.candidates, `${path}.candidates`, aliases, issues);
+	}
+	for (const tier of INFERENCE_TIERS) {
+		const target = config.tiers?.[tier];
+		if (!target) continue;
+		checkTarget(target, `inference.tiers.${tier}`, aliases, issues, config);
+	}
+	if (config.fusions !== void 0 && !isRecord$1(config.fusions)) issues.push({
+		path: "inference.fusions",
+		code: "fusion-invalid",
+		message: "inference.fusions must be an object of named fusions"
+	});
+	else for (const [key, definition] of Object.entries(config.fusions ?? {})) issues.push(...findFusionDefinitionIssues(definition, `inference.fusions.${key}`, config));
+	const state = /* @__PURE__ */ new Map();
+	const reported = /* @__PURE__ */ new Set();
+	const visit = (name, stack) => {
+		if (state.get(name) === "done") return;
+		if (state.get(name) === "visiting") {
+			const cycle = [...stack.slice(stack.indexOf(name)), name];
+			const key = [...cycle.slice(0, -1)].sort().join("|");
+			if (!reported.has(key)) {
+				reported.add(key);
+				issues.push({
+					path: `inference.aliases.${name}`,
+					code: "alias-cycle",
+					message: `inference.aliases has a cycle: ${cycle.join(" -> ")}`
+				});
+			}
+			return;
+		}
+		state.set(name, "visiting");
+		for (const next of aliasEdges(aliases[name])) if (Object.hasOwn(aliases, next)) visit(next, [...stack, name]);
+		state.set(name, "done");
+	};
+	for (const name of Object.keys(aliases)) visit(name, []);
+	return issues;
+}
+function validateInferenceConfig(config) {
+	const issues = [...findInferenceConfigIssues(config), ...findFusionPromptIssues(config)];
+	if (issues.length > 0) throw new InferenceConfigError(issues);
+}
+function readEnv(name) {
+	const env = globalThis.process?.env;
+	return text$1(env?.[name]);
+}
+function candidateLabel(candidate) {
+	const model = text$1(candidate.model);
+	const preset = text$1(candidate.preset);
+	if (preset) return `preset:${preset}/${model ?? "default"}`;
+	const provider = text$1(candidate.provider);
+	if (!provider && !model) return "default";
+	return `${provider ?? "default"}/${model ?? "default"}`;
+}
+function candidateToStep(candidate, tier, alias) {
+	const label = candidateLabel(candidate);
+	const model = text$1(candidate.model);
+	const params = isRecord$1(candidate.params) ? candidate.params : void 0;
+	const keyEnv = text$1(candidate.apiKeyEnv);
+	const key = text$1(candidate.apiKey) ?? (keyEnv ? readEnv(keyEnv) : void 0);
+	const missingKey = !!keyEnv && !key && !text$1(candidate.apiKey);
+	const preset = text$1(candidate.preset);
+	let target;
+	if (preset && isInferencePresetId(preset)) {
+		const definition = INFERENCE_PRESETS[preset];
+		target = {
+			provider: "openai",
+			baseUrl: text$1(candidate.baseUrl) ?? definition.baseUrl,
+			...model ? { model } : {},
+			apiKey: key ?? KEYLESS_PLACEHOLDER$1
+		};
+		const presetNeedsKey = definition.requiresApiKey && !key;
+		return {
+			tier,
+			label,
+			target,
+			...params ? { params } : {},
+			identity: JSON.stringify([
+				"preset",
+				preset,
+				model,
+				target.baseUrl,
+				key
+			]),
+			...missingKey || presetNeedsKey ? { unavailable: "credential" } : {},
+			...alias ? { alias } : {}
+		};
+	}
+	const provider = text$1(candidate.provider);
+	const baseUrl = text$1(candidate.baseUrl);
+	target = {
+		...provider ? { provider } : {},
+		...model ? { model } : {},
+		...baseUrl ? { baseUrl } : {},
+		...key ? { apiKey: key } : baseUrl ? { apiKey: KEYLESS_PLACEHOLDER$1 } : {}
+	};
+	return {
+		tier,
+		label,
+		target,
+		...params ? { params } : {},
+		identity: JSON.stringify([
+			provider,
+			model,
+			baseUrl,
+			key ?? keyEnv
+		]),
+		...missingKey ? { unavailable: "credential" } : {},
+		...alias ? { alias } : {}
+	};
+}
+function expandCandidates(candidates, tier, aliases, owner, visiting, out) {
+	for (const candidate of candidates) {
+		const nested = text$1(candidate.alias);
+		if (nested) expandAlias(nested, tier, aliases, visiting, out);
+		else out.push(candidateToStep(candidate, tier, owner));
+	}
+}
+function expandAlias(name, tier, aliases, visiting, out) {
+	if (visiting.has(name)) throw new InferenceConfigError([{
+		path: `inference.aliases.${name}`,
+		code: "alias-cycle",
+		message: `inference.aliases has a cycle through "${name}"`
+	}]);
+	const alias = aliases[name];
+	if (!alias || !Array.isArray(alias.candidates)) throw new InferenceConfigError([{
+		path: `inference.aliases.${name}`,
+		code: "alias-unknown",
+		message: `unknown alias "${name}"`
+	}]);
+	visiting.add(name);
+	expandCandidates(alias.candidates, tier, aliases, name, visiting, out);
+	visiting.delete(name);
+}
+function expandTarget(target, tier, config) {
+	const aliases = config?.aliases ?? {};
+	const kind = inferenceTargetKind(target);
+	const out = [];
+	if (kind === "alias") expandAlias(String(target.alias ?? ""), tier, aliases, /* @__PURE__ */ new Set(), out);
+	else if (kind === "candidates") expandCandidates(target.candidates ?? [], tier, aliases, void 0, /* @__PURE__ */ new Set(), out);
+	else if (kind === "single") {
+		const { kind: _kind, latency: _latency, params, ...single } = target;
+		const provider = text$1(single.provider);
+		const model = text$1(single.model);
+		out.push({
+			tier,
+			label: candidateLabel({
+				provider,
+				model
+			}),
+			target: { ...single },
+			...isRecord$1(params) ? { params } : {},
+			identity: JSON.stringify([
+				provider,
+				model,
+				text$1(single.baseUrl),
+				text$1(single.apiKey)
+			])
+		});
+	}
+	const source = target.source;
+	if (kind !== "single" && source !== void 0) {
+		for (const step of out) if (step.target.source === void 0) step.target = {
+			...step.target,
+			source
+		};
+	}
+	return out;
+}
+//#endregion
+//#region src/classify.ts
+var MAX_CAUSE_DEPTH = 8;
+var QUOTA_CODES = /* @__PURE__ */ new Set([
+	"insufficient_quota",
+	"billing_hard_limit_reached",
+	"billing_not_active",
+	"quota_exceeded",
+	"subscription_sharing_usage_limit_exceeded"
+]);
+var QUOTA_NAMES = /* @__PURE__ */ new Set(["ChatGPTPlanUsageLimitError"]);
+var CREDENTIAL_CODES = /* @__PURE__ */ new Set([
+	"AUTH_ERROR",
+	"INFERENCE_TARGET_UNBOUND",
+	"invalid_api_key",
+	"authentication_error",
+	"permission_error",
+	"subscription_sharing_invalid_user"
+]);
+var CREDENTIAL_NAMES = /* @__PURE__ */ new Set([
+	"AuthenticationError",
+	"PermissionDeniedError",
+	"AIProviderNotConfiguredError",
+	"ChatGPTPlanSessionRevokedError"
+]);
+var MISSING_MODEL_CODES = /* @__PURE__ */ new Set(["MODEL_NOT_FOUND", "model_not_found"]);
+var MISSING_MODEL_NAMES = /* @__PURE__ */ new Set(["ModelNotFoundError", "NotFoundError"]);
+var REFUSAL_CODES = /* @__PURE__ */ new Set(["CONTENT_FILTERED", "content_filter"]);
+var REFUSAL_NAMES = /* @__PURE__ */ new Set(["ContentFilterError"]);
+var RATE_LIMIT_CODES = /* @__PURE__ */ new Set(["RATE_LIMIT", "rate_limit_exceeded"]);
+var RATE_LIMIT_NAMES = /* @__PURE__ */ new Set(["RateLimitError"]);
+var TRANSIENT_CODES = /* @__PURE__ */ new Set([
+	"AI_TIMEOUT",
+	"AI_INTERRUPTED",
+	"STREAM_INTERRUPTED",
+	"API_ERROR",
+	"UNKNOWN_ERROR",
+	"overloaded_error",
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"ECONNABORTED",
+	"ETIMEDOUT",
+	"EPIPE",
+	"EAI_AGAIN",
+	"ENOTFOUND",
+	"ENETUNREACH",
+	"EHOSTUNREACH",
+	"UND_ERR_SOCKET",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_BODY_TIMEOUT"
+]);
+var TRANSIENT_NAMES = /* @__PURE__ */ new Set([
+	"TimeoutError",
+	"APIConnectionError",
+	"APIConnectionTimeoutError",
+	"InternalServerError"
+]);
+var TRANSIENT_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	409,
+	425,
+	500,
+	502,
+	503,
+	504,
+	529
+]);
+var REQUEST_ERROR_CODES = /* @__PURE__ */ new Set([
+	"invalid_request_error",
+	"CONTEXT_LENGTH_EXCEEDED",
+	"context_length_exceeded",
+	"INVALID_INPUT"
+]);
+var ABORT_CODES = /* @__PURE__ */ new Set(["AI_ABORTED", "ABORT_ERR"]);
+var ABORT_NAMES = /* @__PURE__ */ new Set(["AbortError"]);
+function asObject(value) {
+	return value !== null && typeof value === "object" ? value : void 0;
+}
+function collectFacts(error) {
+	const facts = {
+		names: /* @__PURE__ */ new Set(),
+		codes: /* @__PURE__ */ new Set(),
+		statuses: /* @__PURE__ */ new Set(),
+		rateLimitNotSoon: false,
+		retryable: false
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [{
+		value: error,
+		depth: 0
+	}];
+	while (queue.length > 0) {
+		const { value, depth } = queue.shift();
+		const record = asObject(value);
+		if (!record || seen.has(record) || depth > MAX_CAUSE_DEPTH) continue;
+		seen.add(record);
+		const name = typeof record.name === "string" ? record.name : value.constructor?.name;
+		if (typeof name === "string" && name !== "Error" && name !== "Object") facts.names.add(name);
+		for (const key of ["code", "type"]) {
+			const code = record[key];
+			if (typeof code === "string" && code !== "") facts.codes.add(code);
+		}
+		for (const key of ["status", "statusCode"]) {
+			const status = record[key];
+			if (typeof status === "number" && Number.isInteger(status)) facts.statuses.add(status);
+		}
+		const response = asObject(record.response);
+		if (typeof response?.status === "number") facts.statuses.add(response.status);
+		if (record.retryable === true) facts.retryable = true;
+		if ((RATE_LIMIT_NAMES.has(String(name)) || record.code === "RATE_LIMIT") && record.retryable === false) facts.rateLimitNotSoon = true;
+		for (const next of [
+			record.cause,
+			record.error,
+			asObject(record.context)?.originalError
+		]) if (next !== void 0) queue.push({
+			value: next,
+			depth: depth + 1
+		});
+	}
+	return facts;
+}
+function hasAny(set, members) {
+	for (const value of set) if (members.has(value)) return true;
+	return false;
+}
+function isInferenceAbort(error) {
+	const facts = collectFacts(error);
+	return hasAny(facts.codes, ABORT_CODES) || hasAny(facts.names, ABORT_NAMES);
+}
+function classifyInferenceFailure(error) {
+	const unavailable = error;
+	if (unavailable && typeof unavailable === "object" && unavailable.code === "AI_UNAVAILABLE" && unavailable.reason === "capability") return "missing-capability";
+	const facts = collectFacts(error);
+	const { names, codes, statuses } = facts;
+	if (hasAny(codes, ABORT_CODES) || hasAny(names, ABORT_NAMES)) return;
+	if (hasAny(codes, QUOTA_CODES) || hasAny(names, QUOTA_NAMES) || statuses.has(402)) return "quota";
+	if (hasAny(codes, CREDENTIAL_CODES) || hasAny(names, CREDENTIAL_NAMES) || statuses.has(401) || statuses.has(403)) return "credential";
+	if (hasAny(codes, MISSING_MODEL_CODES) || hasAny(names, MISSING_MODEL_NAMES) || statuses.has(404)) return "missing-model";
+	if (hasAny(codes, REFUSAL_CODES) || hasAny(names, REFUSAL_NAMES)) return "refusal";
+	if (hasAny(codes, RATE_LIMIT_CODES) || hasAny(names, RATE_LIMIT_NAMES) || statuses.has(429)) return facts.rateLimitNotSoon ? "quota" : "transient";
+	for (const status of statuses) if (TRANSIENT_STATUSES.has(status)) return "transient";
+	for (const status of statuses) if (status >= 400 && status < 500) return void 0;
+	if (hasAny(codes, REQUEST_ERROR_CODES)) return void 0;
+	if (hasAny(codes, TRANSIENT_CODES) || hasAny(names, TRANSIENT_NAMES) || facts.retryable) return "transient";
+}
+//#endregion
+//#region src/executor.ts
+var RefusalSignal = class extends Error {
+	code = "CONTENT_FILTERED";
+};
+var MissingCapabilitySignal = class extends Error {
+	constructor(label, missing, source) {
+		super(`${label} lacks ${missing.join(" and ")} (capabilities: ${source})`);
+		this.missing = missing;
+		this.source = source;
+		this.name = "MissingCapabilitySignal";
+	}
+	missing;
+	source;
+	code = "MISSING_CAPABILITY";
+};
+function wantsJson(options) {
+	const type = options.responseFormat?.type;
+	return type === "json_object" || type === "json_schema";
+}
+function wantsTools(options) {
+	return Array.isArray(options.tools) && options.tools.length > 0;
+}
+var REFUSAL_FINISH = /* @__PURE__ */ new Set(["refusal", "content_filter"]);
+function lowerTier(tier) {
+	const index = INFERENCE_TIERS.indexOf(tier);
+	return index > 0 ? INFERENCE_TIERS[index - 1] : void 0;
+}
+function defaultSleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function method(client, name) {
+	const fn = client[name];
+	if (typeof fn !== "function") throw new TypeError(`Inference client does not implement ${name}().`);
+	return fn.bind(client);
+}
+var ChainCall = class {
+	constructor(context, options, operation, callerOptions) {
+		this.context = context;
+		this.options = options;
+		this.operation = operation;
+		this.callerOptions = callerOptions;
+		this.started = options.now();
+	}
+	context;
+	options;
+	operation;
+	callerOptions;
+	started;
+	substitutions = [];
+	lastStep;
+	get tierRequested() {
+		return this.callerOptions.usageTags?.tierRequested ?? this.context.request.tier;
+	}
+	/**
+	* Check a candidate's capabilities against the request before calling it
+	* (#4758). Without a detector (older core) or a requirement, it fits.
+	*/
+	async capabilityFit(step) {
+		const effective = {
+			...step.params ?? {},
+			...this.callerOptions
+		};
+		const json = wantsJson(effective);
+		const tools = wantsTools(effective);
+		if (!json && !tools || !this.context.capabilitiesFor) return { ok: true };
+		let capabilities;
+		try {
+			capabilities = await this.context.capabilitiesFor(step.target);
+		} catch {
+			return { ok: true };
+		}
+		const fallback = this.callerOptions.capabilityFallback ?? {};
+		const adjust = { fallbacks: [] };
+		const missing = [];
+		if (json && !capabilities.json) if (fallback.json === "text") {
+			adjust.dropJson = true;
+			adjust.fallbacks.push("json→text");
+		} else missing.push("json");
+		if (tools && !capabilities.tools) if (fallback.tools === "drop") {
+			adjust.dropTools = true;
+			adjust.fallbacks.push("tools→none");
+		} else missing.push("tools");
+		if (missing.length > 0) return {
+			ok: false,
+			error: new MissingCapabilitySignal(step.label, missing, capabilities.source)
+		};
+		return adjust.fallbacks.length > 0 ? {
+			ok: true,
+			adjust
+		} : { ok: true };
+	}
+	callOptions(step, emit, finish, adjust) {
+		const { usageTags: callerTags, onProgress, onFinishReason, onRefusal, capabilityFallback: _capabilityFallback, ...rest } = this.callerOptions;
+		const model = typeof step.target.model === "string" ? step.target.model : void 0;
+		const options = {
+			...step.params ?? {},
+			...rest,
+			...model ? { model } : {},
+			usageTags: {
+				...callerTags ?? {},
+				...typeof step.target.source === "string" && step.target.source ? { source: step.target.source } : {},
+				tierRequested: this.tierRequested,
+				tierResolved: step.tier,
+				...this.substitutions.length > 0 ? { substitutions: JSON.stringify(this.substitutions) } : {},
+				...adjust && adjust.fallbacks.length > 0 ? { capabilityFallback: adjust.fallbacks.join(",") } : {}
+			},
+			...onProgress ? { onProgress: (chunk) => {
+				emit(chunk);
+				onProgress(chunk);
+			} } : {},
+			onFinishReason: (reason) => {
+				finish.reason = reason;
+				if (onFinishReason) finish.replay.push(() => onFinishReason(reason));
+			},
+			...onRefusal ? { onRefusal: (refusal) => {
+				finish.replay.push(() => onRefusal(refusal));
+			} } : {}
+		};
+		if (adjust?.dropJson) delete options.responseFormat;
+		if (adjust?.dropTools) delete options.tools;
+		return options;
+	}
+	async attemptOnce(step, invoke, isRefusal, adjust) {
+		let emitted = "";
+		const emit = (chunk) => {
+			emitted += chunk;
+		};
+		const finish = { replay: [] };
+		try {
+			const value = await invoke(await this.context.clientFor(step.target), this.callOptions(step, emit, finish, adjust), emit);
+			if ((finish.reason !== void 0 && REFUSAL_FINISH.has(finish.reason) || (isRefusal?.(value) ?? false)) && emitted === "") return {
+				ok: false,
+				cls: "refusal",
+				error: new RefusalSignal(`${step.label} declined the request`),
+				emitted
+			};
+			for (const replay of finish.replay) replay();
+			return {
+				ok: true,
+				value
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				cls: classifyInferenceFailure(error),
+				error,
+				emitted
+			};
+		}
+	}
+	async attempt(step, invoke, isRefusal, adjust) {
+		const first = await this.attemptOnce(step, invoke, isRefusal, adjust);
+		if (first.ok || first.cls !== "transient" || first.emitted !== "") return first;
+		await this.options.sleep(this.options.retryDelayMs());
+		return this.attemptOnce(step, invoke, isRefusal, adjust);
+	}
+	async recordFailure(outcome, reason) {
+		const step = this.lastStep;
+		const { tierResolved: _unanswered, ...callerTags } = this.callerOptions.usageTags ?? {};
+		try {
+			await this.context.recordUsage({
+				...typeof step?.target.provider === "string" ? { provider: step.target.provider } : {},
+				...typeof step?.target.model === "string" ? { model: step.target.model } : {},
+				operation: this.operation,
+				duration: Math.max(0, this.options.now() - this.started),
+				tags: {
+					...callerTags,
+					tierRequested: this.tierRequested,
+					outcome,
+					reason,
+					substitutions: JSON.stringify(this.substitutions)
+				}
+			});
+		} catch {}
+	}
+	async run(invoke, isRefusal, partialValue) {
+		const { context } = this;
+		const attempted = /* @__PURE__ */ new Set();
+		let pending;
+		let tier = context.resolution.tierResolved;
+		let steps = expandResolved(context.resolution.target, tier, context.config);
+		for (;;) {
+			for (const step of steps) {
+				if (attempted.has(step.identity)) continue;
+				attempted.add(step.identity);
+				if (pending) this.substitutions.push({
+					from: pending.label,
+					to: step.label,
+					reason: pending.reason
+				});
+				pending = void 0;
+				this.lastStep = step;
+				if (step.unavailable) {
+					pending = {
+						label: step.label,
+						reason: step.unavailable
+					};
+					continue;
+				}
+				const fit = await this.capabilityFit(step);
+				if (!fit.ok) {
+					pending = {
+						label: step.label,
+						reason: "missing-capability",
+						error: fit.error
+					};
+					continue;
+				}
+				const outcome = await this.attempt(step, invoke, isRefusal, fit.adjust);
+				if (outcome.ok) return outcome.value;
+				if (outcome.emitted !== "") {
+					this.substitutions.push({
+						from: step.label,
+						to: null,
+						reason: "partial"
+					});
+					await this.recordFailure("partial", outcome.cls ?? "unclassified");
+					if (context.allowPartial && partialValue) return partialValue(outcome.emitted);
+					throw new InferenceExhaustedError({
+						reason: "partial",
+						substitutions: [...this.substitutions],
+						tierRequested: this.tierRequested,
+						partialText: outcome.emitted,
+						cause: outcome.error
+					});
+				}
+				if (outcome.cls === void 0) {
+					if (!isInferenceAbort(outcome.error) && !isInferenceUnavailableError(outcome.error)) {
+						this.substitutions.push({
+							from: step.label,
+							to: null,
+							reason: "unclassified"
+						});
+						await this.recordFailure("failed", "unclassified");
+					}
+					throw outcome.error;
+				}
+				pending = {
+					label: step.label,
+					reason: outcome.cls,
+					error: outcome.error
+				};
+			}
+			if (context.config?.degrade === false) break;
+			const next = lowerTier(tier);
+			if (!next) break;
+			if (context.minimumTier && compareInferenceTiers(next, context.minimumTier) < 0) break;
+			const resolution = await context.resolveTier(next);
+			if (resolution.unavailable) break;
+			tier = resolution.tierResolved;
+			steps = expandResolved(resolution.target, tier, context.config);
+		}
+		if (pending) this.substitutions.push({
+			from: pending.label,
+			to: null,
+			reason: pending.reason
+		});
+		const reason = pending?.reason ?? "unclassified";
+		await this.recordFailure("failed", reason);
+		throw new InferenceExhaustedError({
+			reason,
+			substitutions: [...this.substitutions],
+			tierRequested: this.tierRequested,
+			cause: pending?.error
+		});
+	}
+};
+function expandResolved(target, tier, config) {
+	validateInferenceTarget(target, `resolution.${tier}`, config);
+	return expandTarget(target, tier, config);
+}
+function createChunkQueue(onClose) {
+	const chunks = [];
+	let wake;
+	let done = false;
+	let closed = false;
+	let failure;
+	return {
+		/** True once the consumer stopped reading. */
+		get closed() {
+			return closed;
+		},
+		push(chunk) {
+			if (closed) return;
+			chunks.push(chunk);
+			wake?.();
+		},
+		end(error) {
+			done = true;
+			failure = error;
+			wake?.();
+		},
+		async *drain() {
+			try {
+				for (;;) {
+					if (chunks.length > 0) {
+						yield chunks.shift();
+						continue;
+					}
+					if (done) {
+						if (failure) throw failure.error;
+						return;
+					}
+					await new Promise((resolve) => {
+						wake = resolve;
+					});
+					wake = void 0;
+				}
+			} finally {
+				if (!done) {
+					closed = true;
+					chunks.length = 0;
+					onClose();
+				}
+			}
+		}
+	};
+}
+function isRefusalResponse(value) {
+	const reason = value?.finishReason;
+	return typeof reason === "string" && REFUSAL_FINISH.has(reason);
+}
+var lastValidated;
+function validateChainConfig(config) {
+	const key = JSON.stringify(config ?? null);
+	if (key === lastValidated) return;
+	validateInferenceConfig(config);
+	lastValidated = key;
+}
+function createChainClient(context, options = {}) {
+	validateChainConfig(context.config);
+	const resolved = {
+		retryDelayMs: options.retryDelayMs ?? (() => 200 + Math.random() * 300),
+		sleep: options.sleep ?? defaultSleep,
+		now: options.now ?? (() => Date.now())
+	};
+	const call = (operation, callerOptions) => new ChainCall(context, resolved, operation, callerOptions ?? {});
+	return {
+		message(text, callerOptions) {
+			return call("message", callerOptions).run((client, opts) => client.message(text, opts), void 0, (partial) => partial);
+		},
+		chat(messages, callerOptions) {
+			return call("chat", callerOptions).run((client, opts) => Promise.resolve(method(client, "chat")(messages, opts)), isRefusalResponse);
+		},
+		complete(prompt, callerOptions) {
+			return call("complete", callerOptions).run((client, opts) => Promise.resolve(method(client, "complete")(prompt, opts)), isRefusalResponse);
+		},
+		stream(messages, callerOptions) {
+			const controller = new AbortController();
+			const queue = createChunkQueue(() => controller.abort());
+			const callerSignal = callerOptions?.signal;
+			const signal = callerSignal ? AbortSignal.any([callerSignal, controller.signal]) : controller.signal;
+			call("stream", {
+				...callerOptions ?? {},
+				signal
+			}).run(async (client, opts, emit) => {
+				const iterable = method(client, "stream")(messages, opts);
+				for await (const chunk of iterable) {
+					if (queue.closed) break;
+					emit(chunk);
+					queue.push(chunk);
+				}
+			}, void 0, () => void 0).then(() => queue.end(), (error) => queue.end({ error }));
+			return queue.drain();
+		},
+		async embed(...args) {
+			const steps = expandTarget(context.resolution.target, context.resolution.tierResolved, context.config);
+			const step = steps.find((candidate) => !candidate.unavailable);
+			if (!step) throw new InferenceExhaustedError({
+				reason: steps[0]?.unavailable ?? "unclassified",
+				substitutions: [],
+				tierRequested: context.request.tier
+			});
+			return method(await context.clientFor(step.target), "embed")(...args);
+		}
+	};
+}
+//#endregion
+//#region src/fusion.ts
+function defineFusion(input) {
+	const key = typeof input?.key === "string" ? input.key.trim() : "";
+	if (!key) throw new InferenceConfigError([{
+		path: "fusions",
+		code: "fusion-invalid",
+		message: "defineFusion() needs a non-empty key"
+	}]);
+	const { key: _key, ...definition } = input;
+	const path = `fusions.${key}`;
+	const issues = findFusionDefinitionIssues(definition, path, void 0).filter((issue) => issue.code !== "alias-unknown");
+	issues.push(...findFusionDefinitionPromptIssues(definition, path));
+	if (issues.length > 0) throw new InferenceConfigError(issues);
+	const store = fusionStore();
+	const existing = store.get(key);
+	if (existing) {
+		if (JSON.stringify(existing) !== JSON.stringify(definition)) throw new InferenceConfigError([{
+			path,
+			code: "fusion-invalid",
+			message: `fusion "${key}" is already defined with a different definition`
+		}]);
+		return existing;
+	}
+	const frozen = structuredClone(definition);
+	store.set(key, frozen);
+	return frozen;
+}
+function getFusion(key) {
+	return fusionStore().get(key);
+}
+function listFusions() {
+	return [...fusionStore().keys()];
+}
+function clearFusions() {
+	fusionStore().clear();
+}
+var RESOLVER_KEY = /* @__PURE__ */ Symbol.for("smrt.inference.fusionPromptResolver");
+function setFusionPromptResolver(resolver) {
+	const holder = globalThis;
+	if (resolver) holder[RESOLVER_KEY] = resolver;
+	else delete holder[RESOLVER_KEY];
+}
+var PROMPTS_SPECIFIER = "@happyvertical/smrt-prompts";
+async function loadPrompts() {
+	try {
+		return await import(
+			/* @vite-ignore */
+			PROMPTS_SPECIFIER
+);
+	} catch {
+		return await importOptionalDependency(PROMPTS_SPECIFIER, "Fusion seats resolve prompts through @happyvertical/smrt-prompts; install it, register it with registerOptionalDependency(), or call setFusionPromptResolver().");
+	}
+}
+var defaultPromptResolver = async (key, options) => {
+	const resolved = await (await loadPrompts()).resolvePrompt(key, {
+		...options.tenantId !== void 0 ? { tenantId: options.tenantId } : {},
+		...options.db ? { db: options.db } : {}
+	});
+	const params = {};
+	if (typeof resolved.ai.temperature === "number") params.temperature = resolved.ai.temperature;
+	if (typeof resolved.ai.maxTokens === "number") params.maxTokens = resolved.ai.maxTokens;
+	return {
+		instructions: resolved.text,
+		...resolved.ai.usageTags ? { usageTags: resolved.ai.usageTags } : {},
+		params
+	};
+};
+function promptResolver() {
+	return globalThis[RESOLVER_KEY] ?? defaultPromptResolver;
+}
+var ENTRY_TAGS = /* @__PURE__ */ new Set([
+	"promptKey",
+	"promptLayer",
+	"templateHash",
+	"tierRequested",
+	"tierResolved",
+	"substitutions",
+	"runId",
+	"fusionKey",
+	"seat"
+]);
+var TRANSPORT_OPTIONS = ["signal", "timeout"];
+var MAX_MESSAGE = 300;
+function seatName(seat) {
+	return (seat.name ?? seat.prompt).trim();
+}
+function targetLabel(target) {
+	if (typeof target === "string") return `tier:${target}`;
+	const kind = inferenceTargetKind(target);
+	if (kind === "alias") return `alias:${String(target.alias)}`;
+	if (kind === "candidates") return "candidates";
+	return candidateLabel({
+		...typeof target.provider === "string" ? { provider: target.provider } : {},
+		...typeof target.model === "string" ? { model: target.model } : {}
+	});
+}
+function shortMessage(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.length > MAX_MESSAGE ? `${message.slice(0, MAX_MESSAGE)}\u2026` : message;
+}
+function errorCode(error) {
+	const code = error?.code;
+	return typeof code === "string" ? code : void 0;
+}
+function parseSubstitutions(value) {
+	if (typeof value !== "string" || value === "") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) && parsed.length > 0 ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function newRunId() {
+	const crypto = globalThis.crypto;
+	if (crypto?.randomUUID) return crypto.randomUUID();
+	return `run-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function seatOutputText(seat) {
+	if (seat.raw !== void 0) return seat.raw;
+	return seat.text ?? "";
+}
+function seatHeading(seat) {
+	return `seat "${seat.name}" (${seat.model ?? seat.target})`;
+}
+function describeSeat(seat, role) {
+	if (seat.status === "failed") {
+		const failure = seat.failure;
+		return `--- ${role} ${seatHeading(seat)} FAILED (${failure?.reason ?? "unclassified"}): ${failure?.message ?? "no answer"} ---
+This seat produced no output; answer from the other material.`;
+	}
+	const note = seat.raw !== void 0 ? " (asked for JSON; the reply did not parse, raw text follows)" : "";
+	return `--- ${role} ${seatHeading(seat)}${note} ---
+${seatOutputText(seat)}
+--- end of ${seat.name} ---`;
+}
+var FusionRun = class {
+	constructor(context, key, definition, callerOptions, options) {
+		this.context = context;
+		this.key = key;
+		this.definition = definition;
+		this.options = options;
+		this.started = options.now();
+		const { usageTags, model: _model, ...rest } = callerOptions;
+		this.callerTags = Object.fromEntries(Object.entries(usageTags ?? {}).filter(([tag]) => !ENTRY_TAGS.has(tag)));
+		this.finalOptions = rest;
+		this.transport = {};
+		for (const name of TRANSPORT_OPTIONS) if (rest[name] !== void 0) this.transport[name] = rest[name];
+		this.signal = rest.signal;
+		this.entryPromptKey = context.request.promptKey ?? (typeof usageTags?.promptKey === "string" && usageTags.promptKey !== "" ? usageTags.promptKey : void 0);
+		this.seats = definition.seats.map((seat) => ({
+			name: seatName(seat),
+			prompt: seat.prompt,
+			status: "not-run",
+			target: targetLabel(seat.target)
+		}));
+	}
+	context;
+	key;
+	definition;
+	options;
+	runId = newRunId();
+	seats;
+	usage = /* @__PURE__ */ new Map();
+	gate;
+	started;
+	callerTags;
+	finalOptions;
+	transport;
+	signal;
+	entryPromptKey;
+	/** Resolve a seat's target into the context its chain runs in. */
+	async seatContext(seat, index, track) {
+		const { context } = this;
+		let resolution;
+		let config = context.config;
+		let tier = context.resolution.tierResolved;
+		const resolveTier = (next) => context.resolveTier(next, { promptKey: seat.prompt });
+		if (typeof seat.target === "string") {
+			tier = seat.target === "auto" ? resolveAutoTier(context.config) : seat.target;
+			resolution = await resolveTier(tier);
+			if (resolution.unavailable) throw new InferenceUnavailableError({
+				reason: resolution.unavailable,
+				...resolution.mode ? { mode: resolution.mode } : {},
+				tier: resolution.tierResolved,
+				owner: `fusion "${this.key}" seat "${seatName(seat)}"`
+			});
+		} else {
+			resolution = {
+				tierResolved: tier,
+				target: { ...seat.target },
+				via: "config"
+			};
+			config = {
+				...context.config ?? {},
+				degrade: false
+			};
+		}
+		if (inferenceTargetKind(resolution.target) === "fusion") throw new InferenceConfigError([{
+			path: `fusions.${this.key}.seats[${index}].target`,
+			code: "fusion-nested",
+			message: `fusion "${this.key}" seat "${seatName(seat)}" resolved tier "${resolution.tierResolved}" to another fusion; a seat never runs a fusion`
+		}]);
+		return {
+			...context,
+			request: {
+				...context.request,
+				tier,
+				promptKey: seat.prompt
+			},
+			resolution,
+			config,
+			resolveTier,
+			allowPartial: false,
+			clientFor: async (target) => {
+				const client = await context.clientFor(target);
+				return {
+					...client,
+					message: async (text, callOptions) => {
+						const answer = await client.message(text, callOptions);
+						track(target, callOptions ?? {});
+						return answer;
+					}
+				};
+			}
+		};
+	}
+	/**
+	* Run one seat. A model failure kills the seat (recorded, never thrown);
+	* a config error, a caller abort, or a final seat that already streamed
+	* text rethrows.
+	*/
+	async runSeat(index, input, final) {
+		const seat = this.definition.seats[index];
+		const result = this.seats[index];
+		const started = this.options.now();
+		let answered = {
+			target: {},
+			tags: {}
+		};
+		let options = {};
+		result.status = "ok";
+		try {
+			const prompt = await promptResolver()(seat.prompt, {
+				...this.context.request.tenantId !== void 0 ? { tenantId: this.context.request.tenantId } : {},
+				...this.context.db ? { db: this.context.db } : {}
+			});
+			const chain = createChainClient(await this.seatContext(seat, index, (target2, opts) => {
+				answered = {
+					target: target2,
+					tags: opts.usageTags ?? {}
+				};
+			}), this.options);
+			const passed = final ? this.finalOptions : this.transport;
+			options = {
+				...prompt.params ?? {},
+				...passed,
+				...seat.temperature !== void 0 ? { temperature: seat.temperature } : {},
+				...seat.output === "json" ? {
+					responseFormat: { type: "json_object" },
+					capabilityFallback: {
+						...passed.capabilityFallback ?? {},
+						json: "text"
+					}
+				} : {},
+				history: [{
+					role: "system",
+					content: prompt.instructions
+				}],
+				usageTags: {
+					...this.callerTags,
+					...prompt.usageTags ?? {},
+					promptKey: seat.prompt,
+					runId: this.runId,
+					fusionKey: this.key,
+					seat: result.name
+				}
+			};
+			const text = await chain.message(input, options);
+			const target = answered.target;
+			result.model = candidateLabel({
+				...typeof target.provider === "string" ? { provider: target.provider } : {},
+				...typeof target.model === "string" ? { model: target.model } : typeof options.model === "string" ? { model: options.model } : {}
+			});
+			const substitutions = parseSubstitutions(answered.tags.substitutions);
+			if (substitutions) result.substitutions = substitutions;
+			if (seat.output === "json") try {
+				result.json = JSON.parse(text);
+				result.text = text;
+			} catch (error) {
+				result.raw = text;
+				result.parseError = shortMessage(error);
+			}
+			else result.text = text;
+		} catch (error) {
+			if (error instanceof InferenceConfigError || isInferenceAbort(error) || final && error instanceof InferenceExhaustedError && error.reason === "partial") {
+				result.status = "failed";
+				result.failure = {
+					reason: error instanceof InferenceExhaustedError ? error.reason : error instanceof InferenceConfigError ? "config" : "aborted",
+					message: shortMessage(error)
+				};
+				throw error;
+			}
+			result.status = "failed";
+			const code = errorCode(error);
+			result.failure = {
+				reason: error instanceof InferenceExhaustedError ? error.reason : classifyInferenceFailure(error) ?? "unclassified",
+				message: shortMessage(error),
+				...code ? { code } : {}
+			};
+			if (error instanceof InferenceExhaustedError) result.substitutions = error.substitutions;
+		} finally {
+			result.durationMs = Math.max(0, this.options.now() - started);
+		}
+		return result;
+	}
+	/** The gate: one typed-decision call over the outputs so far. */
+	async runGate(gate, input, outputs) {
+		const live = outputs.filter((seat) => seat.status === "ok");
+		if (live.length === 0) return { status: "not-run" };
+		if (!this.context.decide) return { status: "unavailable" };
+		const choice = gate.sufficientWhen.choice;
+		try {
+			const result = await this.context.decide({
+				state: {
+					input,
+					outputs: live.map((seat) => ({
+						seat: seat.name,
+						model: seat.model ?? seat.target,
+						text: seatOutputText(seat)
+					}))
+				},
+				questions: { gate: {
+					type: "choice",
+					instructions: gate.criteria,
+					criteria: {
+						[choice]: "The outputs so far already satisfy the instructions; the remaining stage is not needed.",
+						[FUSION_GATE_CONTINUE]: "The remaining stage is still needed."
+					}
+				} }
+			}, {
+				usageTags: {
+					...this.callerTags,
+					runId: this.runId,
+					fusionKey: this.key,
+					seat: FUSION_GATE_SEAT
+				},
+				...this.signal ? { signal: this.signal } : {}
+			});
+			if (!result) return { status: "unavailable" };
+			const answer = result.answers.gate;
+			if (!answer || answer.type !== "choice") return {
+				status: "error",
+				message: "decision provider returned no choice for the gate"
+			};
+			return {
+				status: answer.choice === choice && answer.confidence >= gate.sufficientWhen.minConfidence ? "sufficient" : "insufficient",
+				choice: answer.choice,
+				confidence: answer.confidence,
+				model: `${result.provenance.provider}/${result.provenance.model}`
+			};
+		} catch (error) {
+			if (isInferenceAbort(error)) throw error;
+			return {
+				status: "error",
+				message: shortMessage(error)
+			};
+		}
+	}
+	skip(index) {
+		const seat = this.seats[index];
+		seat.status = "skipped";
+	}
+	firstLive(...indices) {
+		return indices.map((index) => this.seats[index]).find((seat) => seat.status === "ok");
+	}
+	async interpret(input) {
+		const { definition } = this;
+		if (definition.mode === "single") {
+			const seat = await this.runSeat(0, input, true);
+			return seat.status === "ok" ? seatOutputText(seat) : void 0;
+		}
+		if (definition.mode === "pair") {
+			const settled = await Promise.allSettled([this.runSeat(0, input, false), this.runSeat(1, input, false)]);
+			const rejected = settled.find((entry) => entry.status === "rejected");
+			if (rejected) throw rejected.reason;
+			const [first, second] = settled.map((entry) => entry.value);
+			if (first.status !== "ok" && second.status !== "ok") return void 0;
+			if (definition.gate) {
+				this.gate = await this.runGate(definition.gate, input, [first, second]);
+				if (this.gate.status === "sufficient") {
+					this.skip(2);
+					return seatOutputText(this.firstLive(0, 1));
+				}
+			}
+			const merge = await this.runSeat(2, [
+				input,
+				"",
+				"Two seats answered the request above in parallel. Merge their outputs into one answer.",
+				describeSeat(first, "Output of"),
+				describeSeat(second, "Output of")
+			].join("\n"), true);
+			if (merge.status === "ok") return seatOutputText(merge);
+			return seatOutputText(this.firstLive(0, 1));
+		}
+		const draft = await this.runSeat(0, input, false);
+		if (definition.gate) {
+			this.gate = await this.runGate(definition.gate, input, [draft]);
+			if (this.gate.status === "sufficient") {
+				this.skip(1);
+				return seatOutputText(draft);
+			}
+		}
+		const answer = await this.runSeat(1, [
+			input,
+			"",
+			"Another seat drafted an answer to the request above. Review the draft and give the final answer.",
+			describeSeat(draft, "Draft from")
+		].join("\n"), true);
+		if (answer.status === "ok") return seatOutputText(answer);
+		if (draft.status === "ok") return seatOutputText(draft);
+	}
+	result(status, text) {
+		for (const seat of this.seats) {
+			const usage = this.usage.get(seat.name);
+			if (usage) seat.usage = usage;
+		}
+		return {
+			runId: this.runId,
+			fusionKey: this.key,
+			mode: this.definition.mode,
+			status,
+			text,
+			seats: this.seats.map((seat) => ({ ...seat })),
+			...this.gate ? { gate: this.gate } : {},
+			durationMs: Math.max(0, this.options.now() - this.started)
+		};
+	}
+	async record(result) {
+		if (!this.context.recordRun) return;
+		const ran = result.seats.filter((seat) => seat.status === "ok" || seat.status === "failed");
+		try {
+			await this.context.recordRun({
+				id: result.runId,
+				fusionKey: result.fusionKey,
+				mode: result.mode,
+				...this.entryPromptKey ? { promptKey: this.entryPromptKey } : {},
+				seats: ran.length,
+				degradedSeats: ran.filter(isDegraded).length,
+				status: result.status,
+				duration: result.durationMs,
+				details: {
+					seats: result.seats.map((seat) => ({
+						persona: seat.name,
+						prompt: seat.prompt,
+						status: seat.status,
+						target: seat.target,
+						...seat.model ? { model: seat.model } : {},
+						...seat.usage ? { usage: seat.usage } : {},
+						...seat.substitutions ? { substitutions: seat.substitutions } : {},
+						...seat.failure ? { failure: {
+							reason: seat.failure.reason,
+							...seat.failure.code ? { code: seat.failure.code } : {}
+						} } : {},
+						...seat.raw !== void 0 ? { json: "unparsed" } : {},
+						...seat.json !== void 0 ? { json: "parsed" } : {},
+						...seat.durationMs !== void 0 ? { durationMs: seat.durationMs } : {}
+					})),
+					...result.gate ? { gate: {
+						status: result.gate.status,
+						...result.gate.choice ? { choice: result.gate.choice } : {},
+						...result.gate.confidence !== void 0 ? { confidence: result.gate.confidence } : {},
+						...result.gate.model ? { model: result.gate.model } : {}
+					} } : {}
+				}
+			});
+		} catch {}
+	}
+	async run(input) {
+		const stop = this.context.observeUsage?.(this.runId, (event) => {
+			const seat = event.tags.seat;
+			if (!seat) return;
+			const usage = this.usage.get(seat) ?? {
+				promptTokens: 0,
+				completionTokens: 0,
+				totalTokens: 0
+			};
+			usage.promptTokens += event.promptTokens;
+			usage.completionTokens += event.completionTokens;
+			usage.totalTokens += event.totalTokens;
+			if (event.estimatedCost !== void 0) usage.estimatedCost = (usage.estimatedCost ?? 0) + event.estimatedCost;
+			this.usage.set(seat, usage);
+		});
+		try {
+			let text;
+			try {
+				text = await this.interpret(input);
+			} catch (error) {
+				const failed = this.result("failed", "");
+				await this.record(failed);
+				if (error instanceof InferenceConfigError || isInferenceAbort(error)) throw error;
+				throw new InferenceFusionError(failed, error);
+			}
+			if (text === void 0) {
+				const failed = this.result("failed", "");
+				await this.record(failed);
+				throw new InferenceFusionError(failed);
+			}
+			const degraded = this.seats.some(isDegraded);
+			const done = this.result(degraded ? "degraded" : "ok", text);
+			await this.record(done);
+			return done;
+		} finally {
+			stop?.();
+		}
+	}
+};
+function isDegraded(seat) {
+	return seat.status === "failed" || seat.status === "ok" && (seat.substitutions?.length ?? 0) > 0;
+}
+function fusionFor(context) {
+	const key = String(context.resolution.target.fusion ?? "").trim();
+	const definition = key ? lookupFusion(key, context.config) : void 0;
+	if (!definition) throw new InferenceConfigError([{
+		path: `resolution.${context.resolution.tierResolved}`,
+		code: "fusion-unknown",
+		message: `tier "${context.resolution.tierResolved}" names unknown fusion "${key}"`
+	}]);
+	const path = Object.hasOwn(context.config?.fusions ?? {}, key) ? `inference.fusions.${key}` : `fusions.${key}`;
+	const issues = [...findFusionDefinitionIssues(definition, path, context.config), ...findFusionDefinitionPromptIssues(definition, path)];
+	if (issues.length > 0) throw new InferenceConfigError(issues);
+	return {
+		key,
+		definition
+	};
+}
+function runFusion(context, input, callerOptions = {}, options = {}) {
+	const { key, definition } = fusionFor(context);
+	return new FusionRun(context, key, definition, callerOptions, {
+		retryDelayMs: options.retryDelayMs ?? (() => 200 + Math.random() * 300),
+		sleep: options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+		now: options.now ?? (() => Date.now())
+	}).run(input);
+}
+function unsupported(method) {
+	throw new TypeError(`A fusion target runs through message(); ${method}() is not supported (#4753).`);
+}
+function createFusionClient(context, options = {}) {
+	fusionFor(context);
+	return {
+		async message(text, callerOptions) {
+			const { onFusionResult, ...rest } = callerOptions ?? {};
+			const result = await runFusion(context, text, rest, options);
+			if (typeof onFusionResult === "function") onFusionResult(result);
+			return result.text;
+		},
+		chat: () => unsupported("chat"),
+		complete: () => unsupported("complete"),
+		stream: () => unsupported("stream"),
+		embed: () => unsupported("embed")
+	};
+}
+function createChainExecutor(options = {}) {
+	return {
+		kinds: EXECUTOR_KINDS,
+		createClient: (context) => inferenceTargetKind(context.resolution.target) === "fusion" ? createFusionClient(context, options) : createChainClient(context, options)
+	};
+}
+//#endregion
+//#region src/register.ts
+var OWN_RESOLVER = /* @__PURE__ */ Symbol.for("smrt.inference.chainResolver");
+function createInferenceResolver(base) {
+	let validated;
+	const validate = (config) => {
+		if (!hasInferenceChains(config)) return;
+		const key = JSON.stringify(config);
+		if (key === validated) return;
+		validateInferenceConfig(config);
+		validated = key;
+	};
+	const resolver = { async resolve(request, context) {
+		validate(context.config);
+		return base ? base.resolve(request, context) : void 0;
+	} };
+	if (base && typeof base.mode === "function") {
+		const mode = base.mode.bind(base);
+		resolver.mode = (request) => mode(request);
+	}
+	resolver[OWN_RESOLVER] = true;
+	return resolver;
+}
+function registerInference(options = {}) {
+	setInferenceExecutor(createChainExecutor(options.executor));
+	const current = getInferenceResolver();
+	if (current[OWN_RESOLVER]) return;
+	setInferenceResolver(createInferenceResolver(current === builtInInferenceResolver ? void 0 : current));
+}
+function isInferenceRegistered() {
+	const executor = getInferenceExecutor();
+	return !!executor && executor.kinds.includes("alias");
+}
+//#endregion
+//#region src/provider-config.ts
+var INFERENCE_PROVIDER_CONFIG_SECRET_TYPE = "inference.provider-config";
+var INFERENCE_PROVIDER_CONFIG_SOURCES = [
+	"byo",
+	"local",
+	"hosted"
+];
+var InferenceProviderConfigError = class extends SmrtError {
+	issues;
+	constructor(issues) {
+		super(`Invalid inference provider config: ${issues.join("; ")}`, "INFERENCE_PROVIDER_CONFIG_INVALID", "configuration", { issues });
+		this.issues = issues;
+	}
+};
+var INFERENCE_PROVIDER_PARAM_KEYS = [
+	"temperature",
+	"maxTokens",
+	"topP",
+	"topK",
+	"frequencyPenalty",
+	"presencePenalty",
+	"seed",
+	"stop"
+];
+var PARAM_KEYS = INFERENCE_PROVIDER_PARAM_KEYS;
+function isParamValue(value) {
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value === "string") return true;
+	return Array.isArray(value) && value.length <= 16 && value.every((entry) => typeof entry === "string");
+}
+function safeParams(params) {
+	if (!params) return void 0;
+	const out = {};
+	for (const key of PARAM_KEYS) {
+		const value = params[key];
+		if (value !== void 0 && isParamValue(value)) out[key] = Array.isArray(value) ? [...value] : value;
+	}
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+var BINDING_FIELDS = [
+	"provider",
+	"baseUrl",
+	"model",
+	"apiKey",
+	"preset"
+];
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function hasBinding(binding) {
+	return !!binding && (!!binding.provider || !!binding.preset);
+}
+function parseBinding(value, path, issues) {
+	if (value === void 0) return void 0;
+	if (!isRecord(value)) {
+		issues.push(`${path} must be an object`);
+		return;
+	}
+	const binding = {};
+	for (const field of BINDING_FIELDS) {
+		const raw = value[field];
+		if (raw === void 0 || raw === null || raw === "") continue;
+		const parsed = text(raw);
+		if (!parsed) {
+			issues.push(`${path}.${field} must be a non-empty string`);
+			continue;
+		}
+		binding[field] = parsed;
+	}
+	if (value.params !== void 0) if (!isRecord(value.params)) issues.push(`${path}.params must be an object`);
+	else {
+		for (const [key, param] of Object.entries(value.params)) if (!PARAM_KEYS.includes(key)) issues.push(`${path}.params.${key} is not a supported generation option (${INFERENCE_PROVIDER_PARAM_KEYS.join(", ")})`);
+		else if (!isParamValue(param)) issues.push(`${path}.params.${key} must be a number or string`);
+		const params = safeParams(value.params);
+		if (params) binding.params = params;
+	}
+	if (binding.preset) {
+		if (!isInferencePresetId(binding.preset)) issues.push(`${path}.preset is not a known preset`);
+		else {
+			if (!binding.model) issues.push(`${path}.model is required with preset`);
+			if (INFERENCE_PRESETS[binding.preset].requiresApiKey && !binding.apiKey) issues.push(`${path}.apiKey is required by preset`);
+		}
+		if (binding.provider) issues.push(`${path} names both provider and preset`);
+	} else if (Object.keys(binding).length > 0 && !binding.provider) issues.push(`${path}.provider is required`);
+	if (binding.baseUrl && !isPlainEndpoint(binding.baseUrl)) issues.push(`${path}.baseUrl must be an http(s) URL without credentials, query or fragment`);
+	if (binding.provider && !binding.preset) {
+		if (!binding.baseUrl) issues.push(`${path}.baseUrl is required (a stored binding names its own endpoint)`);
+		if (!binding.apiKey) issues.push(`${path}.apiKey is required (a placeholder such as 'smrt-local' for a keyless local server)`);
+	}
+	return binding;
+}
+function parseInferenceProviderConfig(value) {
+	let raw = value;
+	if (typeof raw === "string") try {
+		raw = JSON.parse(raw);
+	} catch {
+		throw new InferenceProviderConfigError(["value is not JSON"]);
+	}
+	if (!isRecord(raw)) throw new InferenceProviderConfigError(["value must be an object"]);
+	const issues = [];
+	const config = { ...parseBinding(Object.fromEntries(Object.entries(raw).filter(([key]) => key !== "tiers" && key !== "source" && key !== "version" && key !== "mode" && key !== "gatewayKeyAlias")), "config", issues) ?? {} };
+	if (raw.version !== void 0 && raw.version !== 1) issues.push("version must be 1");
+	else if (raw.version === 1) config.version = 1;
+	if (raw.source !== void 0) if (INFERENCE_PROVIDER_CONFIG_SOURCES.includes(raw.source)) config.source = raw.source;
+	else issues.push(`source must be one of ${INFERENCE_PROVIDER_CONFIG_SOURCES.join(", ")}`);
+	if (raw.mode !== void 0) if (isInferenceMode(raw.mode)) config.mode = raw.mode;
+	else issues.push(`mode must be one of ${INFERENCE_MODES.join(", ")}`);
+	if (raw.gatewayKeyAlias !== void 0) {
+		const alias = text(raw.gatewayKeyAlias);
+		if (!alias || alias.length > 200) issues.push("gatewayKeyAlias must be a non-empty string of at most 200 characters");
+		else if (config.source !== "hosted") issues.push("gatewayKeyAlias needs source 'hosted'");
+		else config.gatewayKeyAlias = alias;
+	}
+	if (raw.tiers !== void 0) if (!isRecord(raw.tiers)) issues.push("tiers must be an object");
+	else {
+		const tiers = {};
+		for (const [tier, binding] of Object.entries(raw.tiers)) {
+			if (!isInferenceTier(tier)) {
+				issues.push(`tiers.${tier} is not a tier (${INFERENCE_TIERS.join(", ")})`);
+				continue;
+			}
+			const parsed = parseBinding(binding, `tiers.${tier}`, issues);
+			if (parsed && hasBinding(parsed)) tiers[tier] = parsed;
+		}
+		if (Object.keys(tiers).length > 0) config.tiers = tiers;
+	}
+	for (const known of Object.keys(raw)) if (![
+		...BINDING_FIELDS,
+		"params",
+		"tiers",
+		"source",
+		"version",
+		"mode",
+		"gatewayKeyAlias"
+	].includes(known)) issues.push(`config.${known} is not a provider config field`);
+	if (issues.length > 0) throw new InferenceProviderConfigError(issues);
+	return config;
+}
+function isPlainEndpoint(baseUrl) {
+	try {
+		const url = new URL(baseUrl);
+		return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.search && !url.hash;
+	} catch {
+		return false;
+	}
+}
+function isLoopbackUrl(baseUrl) {
+	if (!baseUrl) return false;
+	try {
+		const host = new URL(baseUrl).hostname.toLowerCase();
+		return host === "localhost" || host.endsWith(".localhost") || host === "[::1]" || host === "::1" || host === "0.0.0.0" || /^127\.\d+\.\d+\.\d+$/.test(host);
+	} catch {
+		return false;
+	}
+}
+function inferenceProviderSource(config, binding) {
+	if (config.source) return config.source;
+	if (binding.preset && isInferencePresetId(binding.preset)) return INFERENCE_PRESETS[binding.preset].requiresApiKey ? "byo" : "local";
+	if (binding.provider?.toLowerCase() === "ollama") return "local";
+	return isLoopbackUrl(binding.baseUrl) ? "local" : "byo";
+}
+var KEYLESS_PLACEHOLDER = "smrt-local";
+function bindingToTarget(config, binding) {
+	const source = inferenceProviderSource(config, binding);
+	const usageTags = config.gatewayKeyAlias ? { usageTags: { gatewayKeyAlias: config.gatewayKeyAlias } } : {};
+	if (binding.preset && isInferencePresetId(binding.preset)) return {
+		provider: "openai",
+		baseUrl: binding.baseUrl ?? INFERENCE_PRESETS[binding.preset].baseUrl,
+		...binding.model ? { model: binding.model } : {},
+		apiKey: binding.apiKey ?? KEYLESS_PLACEHOLDER,
+		...safeParams(binding.params) ? { params: safeParams(binding.params) } : {},
+		source,
+		...usageTags
+	};
+	return {
+		...binding.provider ? { provider: binding.provider } : {},
+		...binding.model ? { model: binding.model } : {},
+		...binding.baseUrl ? { baseUrl: binding.baseUrl } : {},
+		...binding.apiKey ? { apiKey: binding.apiKey } : {},
+		...safeParams(binding.params) ? { params: safeParams(binding.params) } : {},
+		source,
+		...usageTags
+	};
+}
+function inferenceProviderBindingFor(config, tier) {
+	if (!config) return void 0;
+	const own = config.tiers?.[tier];
+	if (hasBinding(own)) return own;
+	return hasBinding(config) ? config : void 0;
+}
+function inferenceProviderTargets(config) {
+	const targets = {};
+	if (!config) return targets;
+	for (const tier of INFERENCE_TIERS) {
+		const binding = inferenceProviderBindingFor(config, tier);
+		if (binding) targets[tier] = bindingToTarget(config, binding);
+	}
+	return targets;
+}
+function redactBinding(binding) {
+	const params = safeParams(binding.params);
+	return {
+		...binding.provider ? { provider: binding.provider } : {},
+		...binding.preset ? { preset: binding.preset } : {},
+		...binding.baseUrl ? { baseUrl: binding.baseUrl } : {},
+		...binding.model ? { model: binding.model } : {},
+		...params ? { params } : {},
+		hasApiKey: !!binding.apiKey && binding.apiKey !== KEYLESS_PLACEHOLDER
+	};
+}
+function redactInferenceProviderConfig(config) {
+	const { tiers, version, source, mode, gatewayKeyAlias, ...binding } = config;
+	const redacted = {
+		...redactBinding(binding),
+		...version ? { version } : {},
+		...source ? { source } : {},
+		...mode ? { mode } : {},
+		...gatewayKeyAlias ? { gatewayKeyAlias } : {}
+	};
+	if (tiers) {
+		redacted.tiers = {};
+		for (const [tier, value] of Object.entries(tiers)) if (value) redacted.tiers[tier] = redactBinding(value);
+	}
+	return redacted;
+}
+function redactInferenceTarget(target) {
+	const params = safeParams(target.params);
+	return {
+		...target.provider ? { provider: target.provider } : {},
+		...target.baseUrl ? { baseUrl: target.baseUrl } : {},
+		...target.model ? { model: target.model } : {},
+		...target.latency ? { latency: target.latency } : {},
+		...target.source ? { source: target.source } : {},
+		...params ? { params } : {},
+		...target.usageTags ? { usageTags: { ...target.usageTags } } : {},
+		hasApiKey: !!target.apiKey && target.apiKey !== KEYLESS_PLACEHOLDER
+	};
+}
+function inferenceProviderConfigSecretName(scope) {
+	const userId = text(scope.userId);
+	return userId ? `${INFERENCE_PROVIDER_CONFIG_SECRET_TYPE}:user:${userId}` : `${INFERENCE_PROVIDER_CONFIG_SECRET_TYPE}:tenant`;
+}
+//#endregion
+export { candidateLabel as A, InferenceExhaustedError as B, createChainClient as C, EXECUTOR_KINDS as D, CHAIN_KINDS as E, findInferenceConfigIssues as F, hasInferenceChains as I, validateInferenceConfig as L, expandTarget as M, findFusionDefinitionIssues as N, FUSION_GATE_CONTINUE as O, findFusionPromptIssues as P, validateInferenceTarget as R, setFusionPromptResolver as S, isInferenceAbort as T, InferenceFusionError as V, createFusionClient as _, inferenceProviderBindingFor as a, listFusions as b, inferenceProviderTargets as c, redactInferenceTarget as d, createInferenceResolver as f, createChainExecutor as g, clearFusions as h, InferenceProviderConfigError as i, candidateToStep as j, FUSION_SEAT_COUNTS as k, parseInferenceProviderConfig as l, registerInference as m, INFERENCE_PROVIDER_CONFIG_SOURCES as n, inferenceProviderConfigSecretName as o, isInferenceRegistered as p, INFERENCE_PROVIDER_PARAM_KEYS as r, inferenceProviderSource as s, INFERENCE_PROVIDER_CONFIG_SECRET_TYPE as t, redactInferenceProviderConfig as u, defineFusion as v, classifyInferenceFailure as w, runFusion as x, getFusion as y, InferenceConfigError as z };
+
+//# sourceMappingURL=provider-config-4Bx8N52X.js.map