mike-backend / backend /src /lib /inference /resolveProvider.ts
bardd's picture
Deploy Mike backend-only Space
06671aa verified
Raw History Blame Contribute Delete
3.71 kB
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";
}