Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

17.3 KB
Raw Blame
import modelDataRaw from "./modelRegistryData.json";
import { isCloudCleanupMode, getSettings } from "../stores/settingsStore";
import { readCachedTinfoilModels } from "./tinfoilModelCache";
import { filterMeetingStreamingProviders } from "../helpers/meetingTranscriptionRouting";
import type { InferenceMode } from "../types/electron";

export interface ModelDefinition {
  id: string;
  name: string;
  size: string;
  sizeBytes: number;
  description: string;
  descriptionKey?: string;
  fileName: string;
  quantization: string;
  contextLength: number;
  hfRepo: string;
  recommended?: boolean;
  supportsThinking?: boolean;
  // Optional MTP speculative-decoding drafter downloaded alongside the main GGUF.
  draftHfRepo?: string;
  draftFileName?: string;
  draftSizeBytes?: number;
}

export interface LocalProviderData {
  id: string;
  name: string;
  baseUrl: string;
  models: ModelDefinition[];
}

export interface ModelProvider {
  id: string;
  name: string;
  baseUrl: string;
  models: ModelDefinition[];
  getDownloadUrl(model: ModelDefinition): string;
}

export interface CloudModelDefinition {
  id: string;
  name: string;
  description: string;
  descriptionKey?: string;
  disableThinking?: boolean;
  supportsThinking?: boolean;
  supportsVision?: boolean;
  tokenParam?: "max_tokens" | "max_completion_tokens";
  supportsTemperature?: boolean;
  reasoningEffort?: ReasoningEffortCapability;
}

export interface ReasoningEffortCapability {
  options: string[];
  defaultValue?: string;
}

export interface CloudProviderData {
  id: string;
  name: string;
  /** Named default for providers whose list order isn't ours — see pickProviderDefaultModel. */
  defaultModel?: string;
  models: CloudModelDefinition[];
}

export interface EnterpriseProviderData extends CloudProviderData {
  allowCustomModelId: boolean;
}

export interface TranscriptionModelDefinition {
  id: string;
  name: string;
  description: string;
  descriptionKey?: string;
  streaming?: boolean;
}

export interface TranscriptionProviderData {
  id: string;
  name: string;
  baseUrl: string;
  models: TranscriptionModelDefinition[];
  /** Allows for a stream/batch split */
  batchModel?: string;
}

export interface WhisperModelInfo {
  name: string;
  description: string;
  descriptionKey?: string;
  size: string;
  sizeMb: number;
  fileName: string;
  downloadUrl: string;
  recommended?: boolean;
}

export interface WhisperModelConfig {
  url: string;
  size: number;
  fileName: string;
}

export type WhisperModelsMap = Record<string, WhisperModelInfo>;

export interface ParakeetModelInfo {
  name: string;
  description: string;
  descriptionKey?: string;
  size: string;
  sizeMb: number;
  expectedSizeBytes?: number;
  manifestUrl?: string;
  language: string;
  supportedLanguages: string[];
  runtime?: "offline" | "online";
  modelType?: "transducer" | "cohere-transcribe";
  /** Verified sherpa decoder type; skips redundant encoder loading during detection. */
  sherpaModelType?: "nemo_transducer";
  organization?: { id: string; name: string };
  license?: string;
  modelCardUrl?: string;
  recommended?: boolean;
  downloadUrl: string;
  extractDir: string;
}

export type ParakeetModelsMap = Record<string, ParakeetModelInfo>;

interface ModelRegistryData {
  parakeetModels: ParakeetModelsMap;
  whisperModels: WhisperModelsMap;
  transcriptionProviders: TranscriptionProviderData[];
  cloudProviders: CloudProviderData[];
  enterpriseProviders: EnterpriseProviderData[];
  localProviders: LocalProviderData[];
}

const modelData: ModelRegistryData = modelDataRaw as ModelRegistryData;

function getTinfoilCloudProvider(): CloudProviderData | undefined {
  return modelData.cloudProviders.find((provider) => provider.id === "tinfoil");
}

const cachedTinfoilModels = readCachedTinfoilModels().models;
if (cachedTinfoilModels.length > 0) {
  const tinfoilProvider = getTinfoilCloudProvider();
  if (tinfoilProvider) {
    tinfoilProvider.models = cachedTinfoilModels;
  }
}

class ModelRegistry {
  private static instance: ModelRegistry;
  private providers = new Map<string, ModelProvider>();

  private constructor() {
    this.registerProvidersFromData();
  }

  static getInstance(): ModelRegistry {
    if (!ModelRegistry.instance) {
      ModelRegistry.instance = new ModelRegistry();
    }
    return ModelRegistry.instance;
  }

  registerProvider(provider: ModelProvider) {
    this.providers.set(provider.id, provider);
  }

  getProvider(providerId: string): ModelProvider | undefined {
    return this.providers.get(providerId);
  }

  getAllProviders(): ModelProvider[] {
    return Array.from(this.providers.values());
  }

  getModel(modelId: string): { model: ModelDefinition; provider: ModelProvider } | undefined {
    for (const provider of this.providers.values()) {
      const model = provider.models.find((m) => m.id === modelId);
      if (model) {
        return { model, provider };
      }
    }
    return undefined;
  }

  getAllModels(): Array<ModelDefinition & { providerId: string }> {
    const models: Array<ModelDefinition & { providerId: string }> = [];
    for (const provider of this.providers.values()) {
      for (const model of provider.models) {
        models.push({ ...model, providerId: provider.id });
      }
    }
    return models;
  }

  getCloudProviders(): CloudProviderData[] {
    return modelData.cloudProviders;
  }

  getEnterpriseProviders(): EnterpriseProviderData[] {
    return modelData.enterpriseProviders;
  }

  getTranscriptionProviders(): TranscriptionProviderData[] {
    return modelData.transcriptionProviders;
  }

  private registerProvidersFromData() {
    const localProviders = modelData.localProviders;

    for (const providerData of localProviders) {
      this.registerProvider({
        id: providerData.id,
        name: providerData.name,
        baseUrl: providerData.baseUrl,
        models: providerData.models,
        getDownloadUrl(model: ModelDefinition): string {
          return `${providerData.baseUrl}/${model.hfRepo}/resolve/main/${model.fileName}`;
        },
      });
    }
  }
}

export const modelRegistry = ModelRegistry.getInstance();

export interface ReasoningModel {
  value: string;
  label: string;
  description: string;
  descriptionKey?: string;
}

export interface ReasoningProvider {
  name: string;
  models: ReasoningModel[];
}

export type ReasoningProviders = Record<string, ReasoningProvider>;

export type EnterpriseProvider = "bedrock" | "azure" | "vertex";
export const ENTERPRISE_PROVIDERS: readonly EnterpriseProvider[] = ["bedrock", "azure", "vertex"];
export function isEnterpriseProvider(value: unknown): value is EnterpriseProvider {
  return typeof value === "string" && (ENTERPRISE_PROVIDERS as readonly string[]).includes(value);
}

export function enterpriseProviderName(provider: EnterpriseProvider): string {
  return modelRegistry.getEnterpriseProviders().find((p) => p.id === provider)?.name ?? provider;
}

export function toReasoningModel(m: CloudModelDefinition): ReasoningModel {
  return {
    value: m.id,
    label: m.name,
    description: m.description,
    descriptionKey: m.descriptionKey,
  };
}

export function isProviderValidForMode(provider: string, mode: InferenceMode): boolean {
  switch (mode) {
    case "providers":
      return (
        provider === "custom" ||
        provider === "openrouter" ||
        modelRegistry.getCloudProviders().some((p) => p.id === provider)
      );
    case "local":
      return modelRegistry.getAllProviders().some((p) => p.id === provider);
    case "enterprise":
      return isEnterpriseProvider(provider);
    default:
      return true;
  }
}

function buildReasoningProviders(): ReasoningProviders {
  const providers: ReasoningProviders = {};

  for (const cloudProvider of modelRegistry.getCloudProviders()) {
    providers[cloudProvider.id] = {
      name: cloudProvider.name,
      models: cloudProvider.models.map(toReasoningModel),
    };
  }

  for (const ep of modelRegistry.getEnterpriseProviders()) {
    providers[ep.id] = {
      name: ep.name,
      models: ep.models.map((m) => ({
        value: m.id,
        label: m.name,
        description: m.description,
        descriptionKey: m.descriptionKey,
      })),
    };
  }

  providers.local = {
    name: "Local AI",
    models: modelRegistry.getAllModels().map((model) => ({
      value: model.id,
      label: model.name,
      description: `${model.description} (${model.size})`,
      descriptionKey: model.descriptionKey,
    })),
  };

  return providers;
}

export const REASONING_PROVIDERS = buildReasoningProviders();

export function getTinfoilModels(): CloudModelDefinition[] {
  return getTinfoilCloudProvider()?.models ?? [];
}

export function getCloudProviderDefaultModelId(providerId: string): string | undefined {
  return modelData.cloudProviders.find((provider) => provider.id === providerId)?.defaultModel;
}

export function applyTinfoilModels(models: CloudModelDefinition[]): void {
  const provider = getTinfoilCloudProvider();
  if (provider) {
    provider.models = models;
  }
  const reasoningProvider = REASONING_PROVIDERS.tinfoil;
  if (reasoningProvider) {
    reasoningProvider.models = models.map(toReasoningModel);
  }
}

export interface ReasoningModelWithProvider extends ReasoningModel {
  provider: string;
  fullLabel: string;
}

export function getAllReasoningModels(): ReasoningModelWithProvider[] {
  return Object.entries(REASONING_PROVIDERS).flatMap(([providerId, provider]) =>
    provider.models.map((model) => ({
      ...model,
      provider: providerId,
      fullLabel: `${provider.name} ${model.label}`,
    }))
  );
}

export function getReasoningModelLabel(modelId: string): string {
  const model = getAllReasoningModels().find((m) => m.value === modelId);
  return model?.fullLabel || modelId;
}

const NON_REGISTRY_PROVIDER_NAMES: Record<string, string> = {
  openrouter: "OpenRouter",
  custom: "Custom",
};

export function getProviderDisplayName(provider: string): string {
  return (
    REASONING_PROVIDERS[provider as keyof typeof REASONING_PROVIDERS]?.name ??
    NON_REGISTRY_PROVIDER_NAMES[provider] ??
    provider
  );
}

export function getModelProvider(modelId: string): string {
  if (isCloudCleanupMode()) {
    return "openwhispr";
  }

  const storedProvider = getSettings().cleanupProvider;

  if (storedProvider === "custom") {
    return "custom";
  }

  if (storedProvider === "openrouter") {
    return "openrouter";
  }

  if (isEnterpriseProvider(storedProvider)) {
    return storedProvider;
  }

  const model = getAllReasoningModels().find((m) => m.value === modelId);

  if (!model) {
    // An unknown model here is one Tinfoil retired or added since our last
    // sync — don't let the id heuristics misroute it.
    if (storedProvider === "tinfoil") return "tinfoil";
    if (modelId.includes("claude")) return "anthropic";
    if (modelId.includes("gemini") && !modelId.includes("gemma")) return "gemini";
    if ((modelId.includes("gpt-4") || modelId.includes("gpt-5")) && !modelId.includes("gpt-oss"))
      return "openai";
    if (
      modelId.includes("qwen/") ||
      modelId.includes("openai/") ||
      modelId.includes("llama-3.1-8b-instant") ||
      modelId.includes("llama-3.3-") ||
      modelId.includes("meta-llama/llama-4-") ||
      modelId.includes("groq/compound") ||
      modelId.includes("moonshotai/kimi-k2-")
    )
      return "groq";
    if (
      modelId.includes("qwen") ||
      modelId.includes("llama") ||
      modelId.includes("mistral") ||
      modelId.includes("lfm2") ||
      modelId.includes("gemma") ||
      modelId.includes("gpt-oss-20b-mxfp4")
    )
      return "local";
  }

  // No default: an unrecognized model must fail closed at dispatch instead of
  // being routed to OpenAI with whatever key that attaches.
  return model?.provider || "";
}

// Local catalog IDs group models for selection and downloads, but all execute
// through the single local llama.cpp inference provider.
export function resolveInferenceProvider(
  configuredProvider: string | undefined,
  modelId: string
): string {
  const provider = configuredProvider?.trim();
  if (provider && modelRegistry.getProvider(provider)) return "local";
  return provider || getModelProvider(modelId);
}

export function getTranscriptionProviders(): TranscriptionProviderData[] {
  return modelRegistry.getTranscriptionProviders();
}

export function getStreamingTranscriptionProviders(): TranscriptionProviderData[] {
  return modelRegistry
    .getTranscriptionProviders()
    .map((p) => ({ ...p, models: p.models.filter((m) => m.streaming) }))
    .filter((p) => p.models.length > 0);
}

// Streaming providers note recording can actually run (see
// meetingTranscriptionRouting.MEETING_STREAMING_PROVIDER_IDS).
export function getMeetingStreamingTranscriptionProviders(): TranscriptionProviderData[] {
  return filterMeetingStreamingProviders(getStreamingTranscriptionProviders());
}

export function getTranscriptionProvider(
  providerId: string
): TranscriptionProviderData | undefined {
  return getTranscriptionProviders().find((p) => p.id === providerId);
}

export function getTranscriptionModels(providerId: string): TranscriptionModelDefinition[] {
  const provider = getTranscriptionProvider(providerId);
  return provider?.models || [];
}

export function getBatchTranscriptionModel(providerId: string): string | undefined {
  return getTranscriptionProvider(providerId)?.batchModel;
}

export function getDefaultTranscriptionModel(providerId: string): string {
  const models = getTranscriptionModels(providerId);
  return models[0]?.id || "gpt-transcribe";
}

export function getWhisperModels(): WhisperModelsMap {
  return modelData.whisperModels;
}

export function getWhisperModelInfo(modelId: string): WhisperModelInfo | undefined {
  return modelData.whisperModels[modelId];
}

export const WHISPER_MODEL_INFO = modelData.whisperModels;

export function getCloudModel(
  modelId: string,
  providerId?: string
): CloudModelDefinition | undefined {
  for (const provider of modelData.cloudProviders) {
    const model = provider.models.find((m) => m.id === modelId);
    if (model) return model;
  }
  for (const provider of modelData.enterpriseProviders) {
    const model = provider.models.find((m) => m.id === modelId);
    if (model) return model;
  }
  // OpenRouter ids carry a vendor prefix (google/gemini-3.5-flash-lite) that the
  // registry stores without, so retry on the upstream id.
  if (providerId === "openrouter" && modelId.includes("/")) {
    return getCloudModel(modelId.slice(modelId.lastIndexOf("/") + 1));
  }
  return undefined;
}

export function getLocalModel(modelId: string): ModelDefinition | undefined {
  return modelRegistry.getModel(modelId)?.model;
}

export interface OpenAiApiConfig {
  tokenParam: "max_tokens" | "max_completion_tokens";
  supportsTemperature: boolean;
}

export function getOpenAiApiConfig(modelId: string, provider?: string): OpenAiApiConfig {
  const model = getCloudModel(modelId);
  if (model?.tokenParam) {
    return {
      tokenParam: model.tokenParam,
      supportsTemperature: model.supportsTemperature ?? true,
    };
  }

  // OpenRouter's vendor-prefixed ids (openai/gpt-4o, anthropic/claude-…) speak
  // standard Chat Completions. Scoped to the provider so vendor-prefixed ids on
  // custom endpoints keep the request shape they had before OpenRouter landed.
  // Sampling params pass through to the upstream vendor, so a model the
  // registry knows rejects temperature (Claude Opus 4.7+, #1417) must keep it
  // omitted here too — OpenRouter forwards the 400 rather than stripping it.
  if (provider === "openrouter" && modelId.includes("/")) {
    const upstream = getCloudModel(modelId, provider);
    return { tokenParam: "max_tokens", supportsTemperature: upstream?.supportsTemperature ?? true };
  }

  // Fallback for models not in the registry (custom model IDs, etc.)
  const isLegacy =
    modelId.startsWith("gpt-3") ||
    modelId.startsWith("gpt-4o") ||
    modelId.startsWith("gpt-4-") ||
    modelId === "gpt-4";

  if (isLegacy) {
    return { tokenParam: "max_tokens", supportsTemperature: true };
  }

  // gpt-4.1* supports temperature but uses max_completion_tokens
  if (modelId.startsWith("gpt-4.1")) {
    return { tokenParam: "max_completion_tokens", supportsTemperature: true };
  }

  // gpt-5* reasoning models: no temperature
  return { tokenParam: "max_completion_tokens", supportsTemperature: false };
}

export function getParakeetModels(): ParakeetModelsMap {
  return modelData.parakeetModels;
}

export function getParakeetModelInfo(modelId: string): ParakeetModelInfo | undefined {
  return modelData.parakeetModels[modelId];
}

export function isOnlineParakeetModel(modelId: string): boolean {
  return modelData.parakeetModels[modelId]?.runtime === "online";
}

export function isCohereTranscribeModel(modelId: string): boolean {
  return modelData.parakeetModels[modelId]?.modelType === "cohere-transcribe";
}

// Both providers run on the parakeet/sherpa-onnx stack; only whisper differs.
export function isSherpaLocalProvider(provider: string): boolean {
  return provider === "nvidia" || provider === "cohere";
}

export const PARAKEET_MODEL_INFO = modelData.parakeetModels;

export function getWhisperModelConfig(modelId: string): WhisperModelConfig | null {
  const modelInfo = modelData.whisperModels[modelId];
  if (!modelInfo) return null;
  return {
    url: modelInfo.downloadUrl,
    size: modelInfo.sizeMb * 1_000_000,
    fileName: modelInfo.fileName,
  };
}

export function getValidWhisperModelNames(): string[] {
  return Object.keys(modelData.whisperModels);
}