Skip to content

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

8.1 KB
Raw Blame
import { useState, useEffect, useCallback, useMemo, useRef } from "react";
import { useTranslation } from "react-i18next";
import { ProviderTabs } from "./ui/ProviderTabs";
import { DownloadProgressBar } from "./ui/DownloadProgressBar";
import { ConfirmDialog } from "./ui/dialog";
import ModelCardList, { type ModelCardOption } from "./ui/ModelCardList";
import { useDialogs } from "../hooks/useDialogs";
import { useModelDownload, type ModelType } from "../hooks/useModelDownload";
import { MODEL_PICKER_COLORS, type ColorScheme } from "../utils/modelPickerStyles";
import { getProviderIcon, isMonochromeProvider } from "../utils/providerIcons";

export interface LocalModel {
  id: string;
  name: string;
  size: string;
  sizeBytes?: number;
  description: string;
  descriptionKey?: string;
  specUrl?: string;
  isDownloaded?: boolean;
  downloaded?: boolean;
  recommended?: boolean;
}

export interface LocalProvider {
  id: string;
  name: string;
  models: LocalModel[];
}

interface LocalModelPickerProps {
  providers: LocalProvider[];
  selectedModel: string;
  selectedProvider: string;
  onModelSelect: (modelId: string) => void;
  onProviderSelect: (providerId: string) => void;
  modelType: ModelType;
  colorScheme?: Exclude<ColorScheme, "blue">;
  className?: string;
  onDownloadComplete?: () => void;
}

export default function LocalModelPicker({
  providers,
  selectedModel,
  selectedProvider,
  onModelSelect,
  onProviderSelect,
  modelType,
  colorScheme = "purple",
  className = "",
  onDownloadComplete,
}: LocalModelPickerProps) {
  const { t } = useTranslation();
  const [downloadedModels, setDownloadedModels] = useState<Set<string>>(new Set());
  const loadDownloadedModelsRequestRef = useRef(0);

  const knownModelIds = useMemo(
    () => new Set(providers.flatMap((provider) => provider.models.map((model) => model.id))),
    [providers]
  );

  const { confirmDialog, showConfirmDialog, hideConfirmDialog } = useDialogs();
  const styles = useMemo(() => MODEL_PICKER_COLORS[colorScheme], [colorScheme]);

  const loadDownloadedModels = useCallback(async () => {
    const requestId = ++loadDownloadedModelsRequestRef.current;

    try {
      let downloaded = new Set<string>();
      if (modelType === "whisper") {
        const result = await window.electronAPI?.listWhisperModels();
        if (result?.success) {
          downloaded = new Set(
            result.models
              .filter((m: { downloaded?: boolean }) => m.downloaded)
              .map((m: { model: string }) => m.model)
          );
        }
      } else if (modelType === "parakeet") {
        const result = await window.electronAPI?.listParakeetModels();
        if (result?.success) {
          downloaded = new Set(
            result.models
              .filter((m: { downloaded?: boolean }) => m.downloaded)
              .map((m: { model: string }) => m.model)
          );
        }
      } else {
        const result = await window.electronAPI?.modelGetAll?.();
        if (result && Array.isArray(result)) {
          downloaded = new Set(
            result
              .filter((m: { isDownloaded?: boolean }) => m.isDownloaded)
              .map((m: { id: string }) => m.id)
          );
        }
      }
      if (requestId === loadDownloadedModelsRequestRef.current) {
        setDownloadedModels(downloaded);
        return downloaded;
      }
      return null;
    } catch (error) {
      console.error("Failed to load downloaded models:", error);
      return null;
    }
  }, [modelType]);

  useEffect(() => {
    const initAndValidate = async () => {
      const downloaded = await loadDownloadedModels();
      // Only clear ids this picker owns — a foreign id (e.g. a cloud model)
      // must survive untouched.
      if (
        downloaded &&
        selectedModel &&
        knownModelIds.has(selectedModel) &&
        !downloaded.has(selectedModel)
      ) {
        onModelSelect("");
      }
    };
    initAndValidate();
  }, [loadDownloadedModels, selectedModel, onModelSelect, knownModelIds]);

  const handleDownloadComplete = useCallback(async () => {
    await loadDownloadedModels();
    await onDownloadComplete?.();
  }, [loadDownloadedModels, onDownloadComplete]);

  const {
    downloads,
    downloadModel,
    deleteModel,
    isDownloadingModel,
    cancelDownload,
    isCancellingModel,
  } = useModelDownload({
    modelType,
    onDownloadComplete: handleDownloadComplete,
    onModelsCleared: loadDownloadedModels,
  });

  const allModels = useMemo(() => providers.flatMap((provider) => provider.models), [providers]);
  const selectionStateRef = useRef({ selectedModel, downloadedModels, knownModelIds });

  useEffect(() => {
    selectionStateRef.current = { selectedModel, downloadedModels, knownModelIds };
  }, [selectedModel, downloadedModels, knownModelIds]);

  const handleDownload = useCallback(
    (modelId: string) => {
      const selectedWhenStarted = selectionStateRef.current.selectedModel;

      downloadModel(modelId, (downloadedId) => {
        const {
          selectedModel: current,
          downloadedModels: downloaded,
          knownModelIds: known,
        } = selectionStateRef.current;
        if (current !== selectedWhenStarted) return;

        const selectionGone = known.has(current) && !downloaded.has(current);
        if (!current || selectionGone) {
          onModelSelect(downloadedId);
        }
      });
    },
    [downloadModel, onModelSelect]
  );

  const handleDelete = useCallback(
    (modelId: string) => {
      showConfirmDialog({
        title: t("transcription.deleteModel.title"),
        description: t("transcription.deleteModel.description"),
        onConfirm: () => deleteModel(modelId, loadDownloadedModels),
        variant: "destructive",
      });
    },
    [showConfirmDialog, deleteModel, loadDownloadedModels, t]
  );

  const currentProvider = providers.find((p) => p.id === selectedProvider);
  const models = useMemo(() => currentProvider?.models || [], [currentProvider?.models]);
  const activeModels = allModels.filter((model) => downloads[model.id]);

  return (
    <div className={className}>
      <ProviderTabs
        providers={providers}
        selectedId={selectedProvider}
        onSelect={onProviderSelect}
        colorScheme={colorScheme}
        wrap
      />

      {activeModels.length > 0 && (
        <div className="space-y-2">
          {activeModels.map((model) => {
            const status = downloads[model.id];
            return (
              <DownloadProgressBar
                key={model.id}
                modelName={model.name}
                progress={{
                  percentage: status.progress,
                  downloadedBytes: status.downloadedBytes,
                  totalBytes: status.totalBytes,
                }}
                isInstalling={status.phase === "installing"}
              />
            );
          })}
        </div>
      )}

      <div className="mt-2">
        <h5 className={`${styles.header} mb-2`}>{t("common.availableModels")}</h5>

        <ModelCardList
          models={models.map((model): ModelCardOption => ({
            value: model.id,
            label: model.name,
            description: model.size,
            specUrl: model.specUrl,
            icon: getProviderIcon(selectedProvider),
            invertInDark: isMonochromeProvider(selectedProvider),
            recommended: model.recommended,
            isDownloaded: downloadedModels.has(model.id) || model.isDownloaded || model.downloaded,
            isDownloading: isDownloadingModel(model.id),
            isCancelling: isCancellingModel(model.id),
          }))}
          selectedModel={selectedModel}
          onModelSelect={onModelSelect}
          onDownload={handleDownload}
          onDelete={handleDelete}
          onCancelDownload={cancelDownload}
          colorScheme={colorScheme}
        />
      </div>

      <ConfirmDialog
        open={confirmDialog.open}
        onOpenChange={(open) => !open && hideConfirmDialog()}
        title={confirmDialog.title}
        description={confirmDialog.description}
        confirmText={confirmDialog.confirmText}
        cancelText={confirmDialog.cancelText}
        onConfirm={confirmDialog.onConfirm}
        variant={confirmDialog.variant}
      />
    </div>
  );
}