kaijibot 2026.8.21 → 2026.8.29

package/dist/model-selection-BNkt6VsY.js

@@ -0,0 +1,381 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
+import { S as resolveThinkingDefault, T as normalizeModelRef, _ as resolvePersistedOverrideModelRef, h as resolveModelRefFromString, r as buildConfiguredModelCatalog, t as buildAllowedModelSet, w as modelKey, y as resolveReasoningDefault } from "./model-selection-Bq91MzO2.js";
+import { r as normalizeProviderId } from "./provider-id-DjOGAXK8.js";
+import { i as resolveAgentConfig } from "./agent-scope-z3lpbLWu.js";
+import "./defaults-ZxwOnZ1C.js";
+import { o as resolveContextTokensForModel } from "./context-CJMC7SyI.js";
+import { t as applyModelOverrideToSessionEntry } from "./model-overrides-eNKEcXJm.js";
+import { t as clearSessionAuthProfileOverride } from "./session-override-CGqy8cfR.js";
+import { t as resolveStoredModelOverride } from "./stored-model-override-DLwX1DpU.js";
+//#region src/auto-reply/reply/model-selection.ts
+function createFastTestModelSelectionState(params) {
+	return {
+		provider: params.provider,
+		model: params.model,
+		allowedModelKeys: /* @__PURE__ */ new Set(),
+		allowedModelCatalog: [],
+		resetModelOverride: false,
+		resolveDefaultThinkingLevel: async () => params.agentCfg?.thinkingDefault,
+		resolveDefaultReasoningLevel: async () => "off",
+		needsModelCatalog: false
+	};
+}
+function shouldLogModelSelectionTiming() {
+	return process.env.KAIJIBOT_DEBUG_INGRESS_TIMING === "1";
+}
+let modelCatalogRuntimePromise;
+let sessionStoreRuntimePromise;
+function loadModelCatalogRuntime() {
+	modelCatalogRuntimePromise ??= import("./agents/model-catalog.runtime.js");
+	return modelCatalogRuntimePromise;
+}
+function loadSessionStoreRuntime() {
+	sessionStoreRuntimePromise ??= import("./store.runtime-D6t_wvEo.js");
+	return sessionStoreRuntimePromise;
+}
+const FUZZY_VARIANT_TOKENS = [
+	"lightning",
+	"preview",
+	"mini",
+	"fast",
+	"turbo",
+	"lite",
+	"beta",
+	"small",
+	"nano"
+];
+function boundedLevenshteinDistance(a, b, maxDistance) {
+	if (a === b) return 0;
+	if (!a || !b) return null;
+	const aLen = a.length;
+	const bLen = b.length;
+	if (Math.abs(aLen - bLen) > maxDistance) return null;
+	const prev = Array.from({ length: bLen + 1 }, (_, idx) => idx);
+	const curr = Array.from({ length: bLen + 1 }, () => 0);
+	for (let i = 1; i <= aLen; i++) {
+		curr[0] = i;
+		let rowMin = curr[0];
+		const aChar = a.charCodeAt(i - 1);
+		for (let j = 1; j <= bLen; j++) {
+			const cost = aChar === b.charCodeAt(j - 1) ? 0 : 1;
+			curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+			if (curr[j] < rowMin) rowMin = curr[j];
+		}
+		if (rowMin > maxDistance) return null;
+		for (let j = 0; j <= bLen; j++) prev[j] = curr[j] ?? 0;
+	}
+	const dist = prev[bLen] ?? null;
+	if (dist == null || dist > maxDistance) return null;
+	return dist;
+}
+function scoreFuzzyMatch(params) {
+	const provider = normalizeProviderId(params.provider);
+	const model = params.model;
+	const fragment = normalizeLowercaseStringOrEmpty(params.fragment);
+	const providerLower = normalizeLowercaseStringOrEmpty(provider);
+	const modelLower = normalizeLowercaseStringOrEmpty(model);
+	const haystack = `${providerLower}/${modelLower}`;
+	const key = modelKey(provider, model);
+	const scoreFragment = (value, weights) => {
+		if (!fragment) return 0;
+		let score = 0;
+		if (value === fragment) score = Math.max(score, weights.exact);
+		if (value.startsWith(fragment)) score = Math.max(score, weights.starts);
+		if (value.includes(fragment)) score = Math.max(score, weights.includes);
+		return score;
+	};
+	let score = 0;
+	score += scoreFragment(haystack, {
+		exact: 220,
+		starts: 140,
+		includes: 110
+	});
+	score += scoreFragment(providerLower, {
+		exact: 180,
+		starts: 120,
+		includes: 90
+	});
+	score += scoreFragment(modelLower, {
+		exact: 160,
+		starts: 110,
+		includes: 80
+	});
+	const distModel = boundedLevenshteinDistance(fragment, modelLower, 3);
+	if (distModel != null) score += (3 - distModel) * 70;
+	const aliases = params.aliasIndex.byKey.get(key) ?? [];
+	for (const alias of aliases) score += scoreFragment(normalizeLowercaseStringOrEmpty(alias), {
+		exact: 140,
+		starts: 90,
+		includes: 60
+	});
+	if (modelLower.startsWith(providerLower)) score += 30;
+	const fragmentVariants = FUZZY_VARIANT_TOKENS.filter((token) => fragment.includes(token));
+	const modelVariants = FUZZY_VARIANT_TOKENS.filter((token) => modelLower.includes(token));
+	const variantMatchCount = fragmentVariants.filter((token) => modelLower.includes(token)).length;
+	const variantCount = modelVariants.length;
+	if (fragmentVariants.length === 0 && variantCount > 0) score -= variantCount * 30;
+	else if (fragmentVariants.length > 0) {
+		if (variantMatchCount > 0) score += variantMatchCount * 40;
+		if (variantMatchCount === 0) score -= 20;
+	}
+	const isDefault = provider === normalizeProviderId(params.defaultProvider) && model === params.defaultModel;
+	if (isDefault) score += 20;
+	return {
+		score,
+		isDefault,
+		variantCount,
+		variantMatchCount,
+		modelLength: modelLower.length,
+		key
+	};
+}
+async function createModelSelectionState(params) {
+	const timingEnabled = shouldLogModelSelectionTiming();
+	const startMs = timingEnabled ? Date.now() : 0;
+	const logStage = (stage, extra) => {
+		if (!timingEnabled) return;
+		const suffix = extra ? ` ${extra}` : "";
+		console.log(`[model-selection] session=${params.sessionKey ?? "(no-session)"} stage=${stage} elapsedMs=${Date.now() - startMs}${suffix}`);
+	};
+	const { cfg, agentCfg, sessionEntry, sessionStore, sessionKey, parentSessionKey, storePath, defaultProvider, defaultModel } = params;
+	let provider = params.provider;
+	let model = params.model;
+	const hasAllowlist = agentCfg?.models && Object.keys(agentCfg.models).length > 0;
+	const configuredModelCatalog = buildConfiguredModelCatalog({ cfg });
+	const needsModelCatalog = params.hasModelDirective;
+	let allowedModelKeys = /* @__PURE__ */ new Set();
+	let allowedModelCatalog = configuredModelCatalog;
+	let modelCatalog = null;
+	let resetModelOverride = false;
+	const agentEntry = params.agentId ? resolveAgentConfig(cfg, params.agentId) : void 0;
+	const directStoredOverride = resolvePersistedOverrideModelRef({
+		defaultProvider,
+		overrideProvider: sessionEntry?.providerOverride,
+		overrideModel: sessionEntry?.modelOverride
+	});
+	if (needsModelCatalog) {
+		modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
+		logStage("catalog-loaded", `entries=${modelCatalog.length}`);
+		const allowed = buildAllowedModelSet({
+			cfg,
+			catalog: modelCatalog,
+			defaultProvider,
+			defaultModel,
+			agentId: params.agentId
+		});
+		allowedModelCatalog = allowed.allowedCatalog;
+		allowedModelKeys = allowed.allowedKeys;
+		logStage("allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
+	} else if (hasAllowlist) {
+		const allowed = buildAllowedModelSet({
+			cfg,
+			catalog: configuredModelCatalog,
+			defaultProvider,
+			defaultModel,
+			agentId: params.agentId
+		});
+		allowedModelCatalog = allowed.allowedCatalog;
+		allowedModelKeys = allowed.allowedKeys;
+		logStage("configured-allowlist-built", `allowed=${allowedModelCatalog.length} keys=${allowedModelKeys.size}`);
+	} else if (configuredModelCatalog.length > 0) logStage("configured-catalog-ready", `entries=${configuredModelCatalog.length}`);
+	if (sessionEntry && sessionStore && sessionKey && directStoredOverride) {
+		const normalizedOverride = normalizeModelRef(directStoredOverride.provider, directStoredOverride.model);
+		const key = modelKey(normalizedOverride.provider, normalizedOverride.model);
+		if (allowedModelKeys.size > 0 && !allowedModelKeys.has(key)) {
+			const { updated } = applyModelOverrideToSessionEntry({
+				entry: sessionEntry,
+				selection: {
+					provider: defaultProvider,
+					model: defaultModel,
+					isDefault: true
+				}
+			});
+			if (updated) {
+				sessionStore[sessionKey] = sessionEntry;
+				if (storePath) await (await loadSessionStoreRuntime()).updateSessionStore(storePath, (store) => {
+					store[sessionKey] = sessionEntry;
+				});
+			}
+			resetModelOverride = updated;
+		}
+	}
+	const storedOverride = resolveStoredModelOverride({
+		sessionEntry,
+		sessionStore,
+		sessionKey,
+		parentSessionKey,
+		defaultProvider
+	});
+	const skipStoredOverride = params.hasResolvedHeartbeatModelOverride === true;
+	if (storedOverride?.model && !skipStoredOverride) {
+		const normalizedStoredOverride = normalizeModelRef(storedOverride.provider || defaultProvider, storedOverride.model);
+		const key = modelKey(normalizedStoredOverride.provider, normalizedStoredOverride.model);
+		if (allowedModelKeys.size === 0 || allowedModelKeys.has(key)) {
+			provider = normalizedStoredOverride.provider;
+			model = normalizedStoredOverride.model;
+		}
+	}
+	if (sessionEntry && sessionStore && sessionKey && sessionEntry.authProfileOverride) {
+		const { ensureAuthProfileStore } = await import("./agents/auth-profiles.runtime.js");
+		const store = ensureAuthProfileStore(void 0, { allowKeychainPrompt: false });
+		logStage("auth-profile-store-loaded", `profiles=${Object.keys(store.profiles).length}`);
+		const profile = store.profiles[sessionEntry.authProfileOverride];
+		const providerKey = normalizeProviderId(provider);
+		if (!profile || normalizeProviderId(profile.provider) !== providerKey) await clearSessionAuthProfileOverride({
+			sessionEntry,
+			sessionStore,
+			sessionKey,
+			storePath
+		});
+	}
+	let defaultThinkingLevel;
+	const resolveDefaultThinkingLevel = async () => {
+		if (defaultThinkingLevel) return defaultThinkingLevel;
+		let catalogForThinking = modelCatalog ?? allowedModelCatalog;
+		if (!catalogForThinking || catalogForThinking.length === 0) {
+			modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
+			logStage("catalog-loaded-for-thinking", `entries=${modelCatalog.length}`);
+			catalogForThinking = modelCatalog;
+		}
+		const resolved = resolveThinkingDefault({
+			cfg,
+			provider,
+			model,
+			catalog: catalogForThinking
+		});
+		defaultThinkingLevel = agentEntry?.thinkingDefault ?? resolved ?? agentCfg?.thinkingDefault ?? "off";
+		return defaultThinkingLevel;
+	};
+	const resolveDefaultReasoningLevel = async () => {
+		let catalogForReasoning = modelCatalog ?? allowedModelCatalog;
+		if (!catalogForReasoning || catalogForReasoning.length === 0) {
+			modelCatalog = await (await loadModelCatalogRuntime()).loadModelCatalog({ config: cfg });
+			logStage("catalog-loaded-for-reasoning", `entries=${modelCatalog.length}`);
+			catalogForReasoning = modelCatalog;
+		}
+		return resolveReasoningDefault({
+			provider,
+			model,
+			catalog: catalogForReasoning
+		});
+	};
+	return {
+		provider,
+		model,
+		allowedModelKeys,
+		allowedModelCatalog,
+		resetModelOverride,
+		resolveDefaultThinkingLevel,
+		resolveDefaultReasoningLevel,
+		needsModelCatalog
+	};
+}
+function resolveModelDirectiveSelection(params) {
+	const { raw, defaultProvider, defaultModel, aliasIndex, allowedModelKeys } = params;
+	const rawTrimmed = raw.trim();
+	const rawLower = normalizeLowercaseStringOrEmpty(rawTrimmed);
+	const pickAliasForKey = (provider, model) => aliasIndex.byKey.get(modelKey(provider, model))?.[0];
+	const buildSelection = (provider, model) => {
+		const alias = pickAliasForKey(provider, model);
+		return {
+			provider,
+			model,
+			isDefault: provider === defaultProvider && model === defaultModel,
+			...alias ? { alias } : void 0
+		};
+	};
+	const resolveFuzzy = (params) => {
+		const fragment = normalizeLowercaseStringOrEmpty(params.fragment);
+		if (!fragment) return {};
+		const providerFilter = params.provider ? normalizeProviderId(params.provider) : void 0;
+		const candidates = [];
+		for (const key of allowedModelKeys) {
+			const slash = key.indexOf("/");
+			if (slash <= 0) continue;
+			const provider = normalizeProviderId(key.slice(0, slash));
+			const model = key.slice(slash + 1);
+			if (providerFilter && provider !== providerFilter) continue;
+			candidates.push({
+				provider,
+				model
+			});
+		}
+		if (!params.provider) {
+			const aliasMatches = [];
+			for (const [aliasKey, entry] of aliasIndex.byAlias.entries()) {
+				if (!aliasKey.includes(fragment)) continue;
+				aliasMatches.push({
+					provider: entry.ref.provider,
+					model: entry.ref.model
+				});
+			}
+			for (const match of aliasMatches) {
+				const key = modelKey(match.provider, match.model);
+				if (!allowedModelKeys.has(key)) continue;
+				if (!candidates.some((c) => c.provider === match.provider && c.model === match.model)) candidates.push(match);
+			}
+		}
+		if (candidates.length === 0) return {};
+		const bestScored = candidates.map((candidate) => {
+			const details = scoreFuzzyMatch({
+				provider: candidate.provider,
+				model: candidate.model,
+				fragment,
+				aliasIndex,
+				defaultProvider,
+				defaultModel
+			});
+			return Object.assign({ candidate }, details);
+		}).toSorted((a, b) => {
+			if (b.score !== a.score) return b.score - a.score;
+			if (a.isDefault !== b.isDefault) return a.isDefault ? -1 : 1;
+			if (a.variantMatchCount !== b.variantMatchCount) return b.variantMatchCount - a.variantMatchCount;
+			if (a.variantCount !== b.variantCount) return a.variantCount - b.variantCount;
+			if (a.modelLength !== b.modelLength) return a.modelLength - b.modelLength;
+			return a.key.localeCompare(b.key);
+		})[0];
+		const best = bestScored?.candidate;
+		if (!best || !bestScored) return {};
+		const minScore = providerFilter ? 90 : 120;
+		if (bestScored.score < minScore) return {};
+		return { selection: buildSelection(best.provider, best.model) };
+	};
+	const resolved = resolveModelRefFromString({
+		raw: rawTrimmed,
+		defaultProvider,
+		aliasIndex
+	});
+	if (!resolved) {
+		const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
+		if (fuzzy.selection || fuzzy.error) return fuzzy;
+		return { error: `Unrecognized model "${rawTrimmed}". Use /models to list providers, or /models <provider> to list models.` };
+	}
+	const resolvedKey = modelKey(resolved.ref.provider, resolved.ref.model);
+	if (allowedModelKeys.size === 0 || allowedModelKeys.has(resolvedKey)) return { selection: {
+		provider: resolved.ref.provider,
+		model: resolved.ref.model,
+		isDefault: resolved.ref.provider === defaultProvider && resolved.ref.model === defaultModel,
+		alias: resolved.alias
+	} };
+	if (rawLower.includes("/")) {
+		const slash = rawTrimmed.indexOf("/");
+		const fuzzy = resolveFuzzy({
+			provider: normalizeProviderId(rawTrimmed.slice(0, slash).trim()),
+			fragment: rawTrimmed.slice(slash + 1).trim()
+		});
+		if (fuzzy.selection || fuzzy.error) return fuzzy;
+	}
+	const fuzzy = resolveFuzzy({ fragment: rawTrimmed });
+	if (fuzzy.selection || fuzzy.error) return fuzzy;
+	return { error: `Model "${resolved.ref.provider}/${resolved.ref.model}" is not allowed. Use /models to list providers, or /models <provider> to list models.` };
+}
+function resolveContextTokens(params) {
+	return params.agentCfg?.contextTokens ?? resolveContextTokensForModel({
+		cfg: params.cfg,
+		provider: params.provider,
+		model: params.model,
+		allowAsyncLoad: false
+	}) ?? 2e5;
+}
+//#endregion
+export { resolveModelDirectiveSelection as i, createModelSelectionState as n, resolveContextTokens as r, createFastTestModelSelectionState as t };

package/dist/model-suppression-BLpblK4C.js

@@ -0,0 +1,28 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
+import { r as normalizeProviderId } from "./provider-id-DjOGAXK8.js";
+import { O as resolveProviderBuiltInModelSuppression } from "./provider-runtime-DSAVX2DR.js";
+//#region src/agents/model-suppression.ts
+function resolveBuiltInModelSuppression(params) {
+	const provider = normalizeProviderId(params.provider ?? "");
+	const modelId = normalizeLowercaseStringOrEmpty(params.id);
+	if (!provider || !modelId) return;
+	return resolveProviderBuiltInModelSuppression({
+		...params.config ? { config: params.config } : {},
+		env: process.env,
+		context: {
+			...params.config ? { config: params.config } : {},
+			env: process.env,
+			provider,
+			modelId,
+			...params.baseUrl ? { baseUrl: params.baseUrl } : {}
+		}
+	});
+}
+function shouldSuppressBuiltInModel(params) {
+	return resolveBuiltInModelSuppression(params)?.suppress ?? false;
+}
+function buildSuppressedBuiltInModelError(params) {
+	return resolveBuiltInModelSuppression(params)?.errorMessage;
+}
+//#endregion
+export { shouldSuppressBuiltInModel as n, buildSuppressedBuiltInModelError as t };

package/dist/model-suppression.runtime-CzgXh3-Q.js

@@ -0,0 +1,7 @@
+import { n as shouldSuppressBuiltInModel$1 } from "./model-suppression-BLpblK4C.js";
+//#region src/agents/model-suppression.runtime.ts
+function shouldSuppressBuiltInModel(...args) {
+	return shouldSuppressBuiltInModel$1(...args);
+}
+//#endregion
+export { shouldSuppressBuiltInModel };

package/dist/model-suppression.runtime.js

@@ -1 +1 @@
-export * from "./model-suppression.runtime-R-qnGNBa.js";
+export * from "./model-suppression.runtime-CzgXh3-Q.js";

package/dist/models-BUxoFu33.js

@@ -0,0 +1,47 @@
+import { o as normalizeOptionalLowercaseString } from "./string-coerce-xZwG7Dq8.js";
+import { a as normalizeModelCompat } from "./provider-model-compat-DfOMY_2L.js";
+import "./provider-model-shared-CxQysvS-.js";
+import "./text-runtime-B3UrMt6T.js";
+//#region extensions/github-copilot/models.ts
+const PROVIDER_ID = "github-copilot";
+const CODEX_GPT_54_MODEL_ID = "gpt-5.4";
+const CODEX_TEMPLATE_MODEL_IDS = ["gpt-5.2-codex"];
+const DEFAULT_CONTEXT_WINDOW = 128e3;
+const DEFAULT_MAX_TOKENS = 8192;
+function resolveCopilotTransportApi(modelId) {
+	return (normalizeOptionalLowercaseString(modelId) ?? "").includes("claude") ? "anthropic-messages" : "openai-responses";
+}
+function resolveCopilotForwardCompatModel(ctx) {
+	const trimmedModelId = ctx.modelId.trim();
+	if (!trimmedModelId) return;
+	const lowerModelId = normalizeOptionalLowercaseString(trimmedModelId) ?? "";
+	if (ctx.modelRegistry.find("github-copilot", lowerModelId)) return;
+	if (lowerModelId === CODEX_GPT_54_MODEL_ID) for (const templateId of CODEX_TEMPLATE_MODEL_IDS) {
+		const template = ctx.modelRegistry.find(PROVIDER_ID, templateId);
+		if (!template) continue;
+		return normalizeModelCompat({
+			...template,
+			id: trimmedModelId,
+			name: trimmedModelId
+		});
+	}
+	const reasoning = /^o[13](\b|$)/.test(lowerModelId);
+	return normalizeModelCompat({
+		id: trimmedModelId,
+		name: trimmedModelId,
+		provider: PROVIDER_ID,
+		api: resolveCopilotTransportApi(trimmedModelId),
+		reasoning,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS
+	});
+}
+//#endregion
+export { resolveCopilotForwardCompatModel as n, resolveCopilotTransportApi as r, PROVIDER_ID as t };

package/dist/models-Ch34kBry.js

@@ -0,0 +1,18 @@
+import { r as discoverOpenAICompatibleLocalModels } from "./provider-self-hosted-setup-l_z2VcmU.js";
+import "./provider-setup-Bf_9tp4f.js";
+import { i as VLLM_PROVIDER_LABEL } from "./defaults-DW-KEml1.js";
+//#region extensions/vllm/models.ts
+async function buildVllmProvider(params) {
+	const baseUrl = (params?.baseUrl?.trim() || "http://127.0.0.1:8000/v1").replace(/\/+$/, "");
+	return {
+		baseUrl,
+		api: "openai-completions",
+		models: await discoverOpenAICompatibleLocalModels({
+			baseUrl,
+			apiKey: params?.apiKey,
+			label: VLLM_PROVIDER_LABEL
+		})
+	};
+}
+//#endregion
+export { buildVllmProvider as t };

package/dist/models-CxT1_oJh.js

@@ -0,0 +1,157 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
+import "./text-runtime-B3UrMt6T.js";
+//#region extensions/huggingface/models.ts
+const HUGGINGFACE_BASE_URL = "https://router.huggingface.co/v1";
+const HUGGINGFACE_POLICY_SUFFIXES = ["cheapest", "fastest"];
+const HUGGINGFACE_DISCOVERY_TIMEOUT_MS = 3e4;
+const HUGGINGFACE_DEFAULT_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0
+};
+const HUGGINGFACE_DEFAULT_CONTEXT_WINDOW = 131072;
+const HUGGINGFACE_DEFAULT_MAX_TOKENS = 8192;
+const HUGGINGFACE_MODEL_CATALOG = [
+	{
+		id: "deepseek-ai/DeepSeek-R1",
+		name: "DeepSeek R1",
+		reasoning: true,
+		input: ["text"],
+		contextWindow: 131072,
+		maxTokens: 8192,
+		cost: {
+			input: 3,
+			output: 7,
+			cacheRead: 3,
+			cacheWrite: 3
+		}
+	},
+	{
+		id: "deepseek-ai/DeepSeek-V3.1",
+		name: "DeepSeek V3.1",
+		reasoning: false,
+		input: ["text"],
+		contextWindow: 131072,
+		maxTokens: 8192,
+		cost: {
+			input: .6,
+			output: 1.25,
+			cacheRead: .6,
+			cacheWrite: .6
+		}
+	},
+	{
+		id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+		name: "Llama 3.3 70B Instruct Turbo",
+		reasoning: false,
+		input: ["text"],
+		contextWindow: 131072,
+		maxTokens: 8192,
+		cost: {
+			input: .88,
+			output: .88,
+			cacheRead: .88,
+			cacheWrite: .88
+		}
+	},
+	{
+		id: "openai/gpt-oss-120b",
+		name: "GPT-OSS 120B",
+		reasoning: false,
+		input: ["text"],
+		contextWindow: 131072,
+		maxTokens: 8192,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		}
+	}
+];
+function isHuggingfacePolicyLocked(modelRef) {
+	const ref = String(modelRef).trim();
+	return HUGGINGFACE_POLICY_SUFFIXES.some((suffix) => ref.endsWith(`:${suffix}`) || ref === suffix);
+}
+function buildHuggingfaceModelDefinition(model) {
+	return {
+		id: model.id,
+		name: model.name,
+		reasoning: model.reasoning,
+		input: model.input,
+		cost: model.cost,
+		contextWindow: model.contextWindow,
+		maxTokens: model.maxTokens
+	};
+}
+function isReasoningModelHeuristic(modelId) {
+	const lower = normalizeLowercaseStringOrEmpty(modelId);
+	return lower.includes("r1") || lower.includes("reason") || lower.includes("thinking") || lower.includes("reasoner") || lower.includes("grok") || lower.includes("qwq");
+}
+function inferredMetaFromModelId(id) {
+	const base = id.split("/").pop() ?? id;
+	const reasoning = isReasoningModelHeuristic(id);
+	return {
+		name: base.replace(/-/g, " ").replace(/\b(\w)/g, (c) => c.toUpperCase()),
+		reasoning
+	};
+}
+function displayNameFromApiEntry(entry, inferredName) {
+	const fromApi = typeof entry.name === "string" && entry.name.trim() || typeof entry.title === "string" && entry.title.trim() || typeof entry.display_name === "string" && entry.display_name.trim();
+	if (fromApi) return fromApi;
+	if (typeof entry.owned_by === "string" && entry.owned_by.trim()) {
+		const base = entry.id.split("/").pop() ?? entry.id;
+		return `${entry.owned_by.trim()}/${base}`;
+	}
+	return inferredName;
+}
+async function discoverHuggingfaceModels(apiKey, timeoutMs = HUGGINGFACE_DISCOVERY_TIMEOUT_MS) {
+	if (process.env.VITEST === "true" || false) return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+	const trimmedKey = apiKey?.trim();
+	if (!trimmedKey) return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+	try {
+		const response = await fetch(`${HUGGINGFACE_BASE_URL}/models`, {
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: {
+				Authorization: `Bearer ${trimmedKey}`,
+				"Content-Type": "application/json"
+			}
+		});
+		if (!response.ok) return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+		const data = (await response.json())?.data;
+		if (!Array.isArray(data) || data.length === 0) return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+		const catalogById = new Map(HUGGINGFACE_MODEL_CATALOG.map((model) => [model.id, model]));
+		const seen = /* @__PURE__ */ new Set();
+		const models = [];
+		for (const entry of data) {
+			const id = typeof entry?.id === "string" ? entry.id.trim() : "";
+			if (!id || seen.has(id)) continue;
+			seen.add(id);
+			const catalogEntry = catalogById.get(id);
+			if (catalogEntry) {
+				models.push(buildHuggingfaceModelDefinition(catalogEntry));
+				continue;
+			}
+			const inferred = inferredMetaFromModelId(id);
+			const name = displayNameFromApiEntry(entry, inferred.name);
+			const modalities = entry.architecture?.input_modalities;
+			const input = Array.isArray(modalities) && modalities.includes("image") ? ["text", "image"] : ["text"];
+			const providerWithContext = (Array.isArray(entry.providers) ? entry.providers : []).find((provider) => typeof provider?.context_length === "number" && provider.context_length > 0);
+			models.push({
+				id,
+				name,
+				reasoning: inferred.reasoning,
+				input,
+				cost: HUGGINGFACE_DEFAULT_COST,
+				contextWindow: providerWithContext?.context_length ?? HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
+				maxTokens: HUGGINGFACE_DEFAULT_MAX_TOKENS
+			});
+		}
+		return models.length > 0 ? models : HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+	} catch {
+		return HUGGINGFACE_MODEL_CATALOG.map(buildHuggingfaceModelDefinition);
+	}
+}
+//#endregion
+export { buildHuggingfaceModelDefinition as a, HUGGINGFACE_POLICY_SUFFIXES as i, HUGGINGFACE_DISCOVERY_TIMEOUT_MS as n, discoverHuggingfaceModels as o, HUGGINGFACE_MODEL_CATALOG as r, isHuggingfacePolicyLocked as s, HUGGINGFACE_BASE_URL as t };

package/dist/models-D4gmkPz-.js

@@ -0,0 +1,2 @@
+import { a as modelsListCommand, i as modelsStatusCommand } from "./models-DUS7kA8D.js";
+export { modelsListCommand, modelsStatusCommand };