openclaw/dist/provider-model-route-zfHlXKpI.js

Multi-channel AI gateway with extensible messaging integrations

import { r as normalizeProviderId } from "./provider-id-DMd-TDFp.js";
import { i as resolveMergedModelProviderEntry } from "./model-provider-config-DX4Bzd5F.js";
import { n as resolveProviderModelCatalogId, r as resolveProviderModelRoutes } from "./provider-model-routes-jLTliGaX.js";
import { t as splitTrailingAuthProfile } from "./model-ref-profile-BIKs-96s.js";
//#region src/agents/provider-model-route.ts
/** Generic core consumers for provider-owned model route facts. */
/** Canonicalizes a model id only when its provider owns catalog equivalence. */
function canonicalizeProviderModelId(providerId, modelId) {
	const provider = normalizeProviderId(providerId);
	return provider && resolveProviderModelCatalogId({
		provider,
		modelId
	}) || modelId;
}
function normalizeRouteBaseUrl(value) {
	try {
		const url = new URL(value);
		url.pathname = url.pathname.replace(/\/+$/u, "") || "/";
		return url.toString();
	} catch {
		return value.replace(/\/+$/u, "");
	}
}
function routeTupleMatches(source, route) {
	return source.api === route.api && typeof source.baseUrl === "string" && normalizeRouteBaseUrl(source.baseUrl) === normalizeRouteBaseUrl(route.baseUrl);
}
/** True when materialized model metadata belongs to the selected provider route. */
function modelMatchesProviderModelRoute(params) {
	if (routeTupleMatches(params, params.route)) return true;
	if (typeof params.api !== "string" || !params.api.trim() || params.api !== params.route.api || typeof params.baseUrl !== "string" || !params.baseUrl.trim()) return false;
	const configuredProvider = {
		api: params.api,
		baseUrl: params.baseUrl,
		models: []
	};
	const provider = normalizeProviderId(params.provider);
	const resolution = resolveProviderModelRoutes({
		provider,
		config: { models: { providers: { [provider]: configuredProvider } } }
	});
	return resolution?.kind === "routes" && resolution.routes.some((candidate) => candidate.authRequirement === params.route.authRequirement && routeTupleMatches(candidate, params.route));
}
/** Creates catalog equivalence and physical-route matching from provider facts. */
function createProviderModelCatalogRoutePolicy(providerId) {
	const provider = normalizeProviderId(providerId);
	return {
		resolveIdentity: (entry) => {
			if (normalizeProviderId(entry.provider) !== provider) return null;
			const id = resolveProviderModelCatalogId({
				provider,
				modelId: splitTrailingAuthProfile(entry.id).model
			});
			return id ? {
				id,
				key: `${provider}/${id}`
			} : null;
		},
		matchesRoute: (entry, route) => normalizeProviderId(entry.provider) === provider && modelMatchesProviderModelRoute({
			provider,
			api: entry.api,
			baseUrl: entry.baseUrl,
			route
		})
	};
}
/** Projects a selected route onto transient config used only for model materialization. */
function projectProviderModelRouteConfig(params) {
	const provider = normalizeProviderId(params.provider);
	const providers = params.config?.models?.providers ?? {};
	const providerEntry = resolveMergedModelProviderEntry(params.config, provider);
	const providerKey = providerEntry?.providerKey ?? provider;
	const providerConfig = providerEntry?.providerConfig ?? { models: [] };
	const routeProviders = Object.fromEntries(Object.entries(providers).filter(([candidate]) => normalizeProviderId(candidate) !== provider || candidate === providerKey));
	return {
		...params.config,
		models: {
			...params.config?.models,
			providers: {
				...routeProviders,
				[providerKey]: {
					...providerConfig,
					auth: params.route.authRequirement === "subscription" ? "oauth" : "api-key",
					api: params.route.api,
					baseUrl: params.route.baseUrl
				}
			}
		}
	};
}
//#endregion
export { projectProviderModelRouteConfig as i, createProviderModelCatalogRoutePolicy as n, modelMatchesProviderModelRoute as r, canonicalizeProviderModelId as t };