Skip to content

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

4.8 KB
Raw Blame
import registry from '@/config/languageRegistry.json';
import {
  PARAKEET_V3_LANGUAGES,
  preferredEngineForLanguages,
  type LocalEngineAvailability,
} from '@/services/transcription/localEngine';

export type LocalModelKey = 'whisper-base' | 'parakeet-v2' | 'parakeet-v3';

export const LOCAL_MODEL_TITLES: Record<LocalModelKey, string> = {
  'parakeet-v2': 'Parakeet v2',
  'parakeet-v3': 'Parakeet v3',
  'whisper-base': 'Whisper base',
};

export interface ModelLanguage {
  code: string;
  label: string;
  flag: string;
}

// The languages the app offers in Transcription Language that a model can transcribe.
export function localModelLanguages(model: LocalModelKey): ModelLanguage[] {
  return (registry.languages as (ModelLanguage & { whisper?: boolean })[])
    .filter(({ code, whisper }) => {
      if (code === 'auto') return false;
      if (model === 'whisper-base') return !!whisper;
      const base = code.split('-')[0];
      return model === 'parakeet-v2' ? base === 'en' : PARAKEET_V3_LANGUAGES.has(base);
    })
    .map(({ code, label, flag }) => ({ code, label, flag }))
    .sort((a, b) => a.label.localeCompare(b.label));
}

// A registry entry for a base language code; English exists only as regional variants.
export function languageByCode(code: string): ModelLanguage {
  const languages = registry.languages as ModelLanguage[];
  const entry =
    languages.find((language) => language.code === code) ??
    languages.find((language) => language.code.startsWith(`${code}-`));
  if (!entry) return { code, label: code, flag: '🌐' };
  return { code, label: entry.label.replace(/ \(.*\)$/, ''), flag: entry.flag };
}

export function isLocalModelKey(value: unknown): value is LocalModelKey {
  return typeof value === 'string' && Object.keys(LOCAL_MODEL_TITLES).includes(value);
}

/**
 * Nominal on-disk sizes shown before download (whisper from its published ggml size; Parakeet
 * measured on-device by the benchmark spike). Used for display and the pre-download
 * free-space check — close enough is fine.
 */
export const LOCAL_MODEL_SIZE_BYTES: Record<LocalModelKey, number> = {
  'whisper-base': 142 * 1024 * 1024,
  'parakeet-v2': 443 * 1024 * 1024,
  'parakeet-v3': 461 * 1024 * 1024,
};

export interface LocalModelCatalogEntry {
  key: LocalModelKey;
  engineName: 'Parakeet' | 'Whisper';
  title: string;
  description: string;
  languagesNote: string;
  sizeBytes: number;
  recommended: boolean;
  downloaded: boolean;
}

/** The model the user's language selection should download (drives onboarding + recommendations). */
export function recommendedModelKey(languages: readonly string[]): LocalModelKey {
  const preferred = preferredEngineForLanguages(languages);
  if (preferred.engine === 'whisper') return 'whisper-base';
  return preferred.version === 'v2' ? 'parakeet-v2' : 'parakeet-v3';
}

/**
 * Display rows for the transcription-models screen: all installable engines with the one the
 * user's language selection routes to marked recommended (and listed first). Parakeet rows are
 * omitted where the native module isn't linked (Android, Expo Go).
 */
export function getLocalModelCatalog(
  languages: readonly string[],
  availability: LocalEngineAvailability,
): LocalModelCatalogEntry[] {
  const recommended = recommendedModelKey(languages);

  const entries: LocalModelCatalogEntry[] = [
    {
      key: 'parakeet-v2',
      engineName: 'Parakeet',
      title: LOCAL_MODEL_TITLES['parakeet-v2'],
      description: 'Fastest and most accurate for English dictation.',
      languagesNote: 'English only',
      sizeBytes: LOCAL_MODEL_SIZE_BYTES['parakeet-v2'],
      recommended: recommended === 'parakeet-v2',
      downloaded: availability.parakeetV2Downloaded,
    },
    {
      key: 'parakeet-v3',
      engineName: 'Parakeet',
      title: LOCAL_MODEL_TITLES['parakeet-v3'],
      description: 'Fast transcription with automatic language detection.',
      languagesNote: '25 European languages',
      sizeBytes: LOCAL_MODEL_SIZE_BYTES['parakeet-v3'],
      recommended: recommended === 'parakeet-v3',
      downloaded: availability.parakeetV3Downloaded,
    },
    {
      key: 'whisper-base',
      engineName: 'Whisper',
      title: LOCAL_MODEL_TITLES['whisper-base'],
      description: 'Broad language coverage — the fallback for everything Parakeet doesn’t cover.',
      languagesNote: '~99 languages incl. auto-detect',
      sizeBytes: LOCAL_MODEL_SIZE_BYTES['whisper-base'],
      recommended: recommended === 'whisper-base',
      downloaded: availability.whisperDownloaded,
    },
  ];

  const visible = availability.parakeetSupported
    ? entries
    : entries.filter((entry) => entry.engineName !== 'Parakeet');

  // Recommended first; otherwise keep the declaration order (stable sort).
  return visible.sort((a, b) => Number(b.recommended) - Number(a.recommended));
}