import type { Provider } from "../llm/types"; import { getFeatureEntry, getInferenceManifest, getModelEntry, } from "./config"; import { ProviderModelMismatchError } from "./errors"; import type { InferenceFeatureId, InferenceProviderId } from "./types"; export function normalizeRequestProvider( raw?: string | null, ): InferenceProviderId | null { if (raw == null) return null; const trimmed = raw.trim(); if (!trimmed) return null; const value = trimmed.toLowerCase(); if (value === "openai-api" || value === "openai") return "proxy-openai"; if (value === "gemini_sdk" || value === "gemini") return "google-genai"; if (value === "proxy-openai" || value === "google-genai" || value === "vertex-ai") { return value; } return null; } export function getAllowedProvidersForModel(model: string): InferenceProviderId[] { return getModelEntry(model)?.providers ?? []; } export function getModelDefaultProvider(model: string): InferenceProviderId { const allowed = getAllowedProvidersForModel(model); if (allowed.length > 0) return allowed[0]; return getInferenceManifest().defaults.provider ?? "proxy-openai"; } export function resolveInferenceProvider(input: { explicitRequestProvider?: string | null; featureId?: InferenceFeatureId | string; model: string; }): InferenceProviderId { const allowedProviders = getAllowedProvidersForModel(input.model); const hasExplicit = input.explicitRequestProvider != null && input.explicitRequestProvider.trim() !== ""; const explicit = normalizeRequestProvider(input.explicitRequestProvider); if (hasExplicit) { if (!explicit) { throw new ProviderModelMismatchError(); } if ( allowedProviders.length > 0 && !allowedProviders.includes(explicit) ) { throw new ProviderModelMismatchError(); } return explicit; } const featureProvider = getFeatureEntry(input.featureId)?.provider; if (featureProvider) { if ( allowedProviders.length > 0 && !allowedProviders.includes(featureProvider) ) { throw new ProviderModelMismatchError(); } return featureProvider; } if (allowedProviders.length > 0) { return allowedProviders[0]; } return getInferenceManifest().defaults.provider ?? "proxy-openai"; } export function inferenceProviderToLegacy(provider: InferenceProviderId): Provider { if (provider === "proxy-openai") return "openai"; if (provider === "google-genai") return "gemini"; throw new Error("Vertex AI provider not configured"); } export function validateProviderModelPair(input: { model: string; inferenceProvider?: string | null; explicitRequestProvider?: string | null; featureId?: InferenceFeatureId | string; }): | { ok: true; provider: InferenceProviderId } | { ok: false; error: "provider_model_mismatch" } { try { return { ok: true, provider: resolveInferenceProvider({ model: input.model, featureId: input.featureId, explicitRequestProvider: input.explicitRequestProvider ?? input.inferenceProvider, }), }; } catch (error) { if (error instanceof ProviderModelMismatchError) { return { ok: false, error: "provider_model_mismatch" }; } throw error; } } export function toFrontendInferenceProvider( provider: InferenceProviderId, ): "openai-api" | "gemini_sdk" { return provider === "proxy-openai" ? "openai-api" : "gemini_sdk"; }