Spaces:
Paused
Paused
| "use client"; | |
| import { useEffect, useMemo, useState } from "react"; | |
| import { apiFetch } from "@/lib/api"; | |
| export type InferenceEngineStatus = { | |
| id: string; | |
| label: string; | |
| base_url: string; | |
| live: boolean; | |
| detail: string; | |
| available_models: string[]; | |
| }; | |
| export type TranscriptionModelOption = { | |
| id: string; | |
| name: string; | |
| repo_id: string; | |
| description: string; | |
| languages: string; | |
| available: boolean; | |
| local_path?: string | null; | |
| }; | |
| export type TranscriptionBackend = { | |
| id: string; | |
| label: string; | |
| supported: boolean; | |
| live: boolean; | |
| detail: string; | |
| models: TranscriptionModelOption[]; | |
| default_model?: string | null; | |
| }; | |
| export type TranscriptionSettings = { | |
| default_backend: string; | |
| backends: TranscriptionBackend[]; | |
| text_inference_engines: InferenceEngineStatus[]; | |
| }; | |
| const LEGACY_AUDIO_MODEL_STORAGE_KEY = "preferred_transcription_model"; | |
| const AUDIO_BACKEND_STORAGE_KEY = "preferred_transcription_backend"; | |
| const AUDIO_MODELS_STORAGE_KEY = "preferred_transcription_models"; | |
| const TEXT_ENGINE_STORAGE_KEY = "preferred_text_inference_engine"; | |
| const TEXT_URL_STORAGE_KEY = "preferred_text_inference_urls"; | |
| const getStoredValue = (key: string) => { | |
| if (typeof window === "undefined") return null; | |
| return window.localStorage.getItem(key); | |
| }; | |
| const setStoredValue = (key: string, value: string) => { | |
| if (typeof window === "undefined") return; | |
| window.localStorage.setItem(key, value); | |
| }; | |
| const getStoredUrls = () => { | |
| const raw = getStoredValue(TEXT_URL_STORAGE_KEY); | |
| if (!raw) return {} as Record<string, string>; | |
| try { | |
| return JSON.parse(raw) as Record<string, string>; | |
| } catch { | |
| return {}; | |
| } | |
| }; | |
| const setStoredUrls = (urls: Record<string, string>) => { | |
| setStoredValue(TEXT_URL_STORAGE_KEY, JSON.stringify(urls)); | |
| }; | |
| const getStoredAudioModels = () => { | |
| const raw = getStoredValue(AUDIO_MODELS_STORAGE_KEY); | |
| if (!raw) return {} as Record<string, string>; | |
| try { | |
| return JSON.parse(raw) as Record<string, string>; | |
| } catch { | |
| return {}; | |
| } | |
| }; | |
| export const migrateLegacyAudioModelSelections = ( | |
| currentSelections: Record<string, string>, | |
| legacyValue: string | null | |
| ) => { | |
| if (!legacyValue || currentSelections.server) return currentSelections; | |
| return { ...currentSelections, server: legacyValue }; | |
| }; | |
| const setStoredAudioModels = (models: Record<string, string>) => { | |
| setStoredValue(AUDIO_MODELS_STORAGE_KEY, JSON.stringify(models)); | |
| }; | |
| const persistAudioModels = (models: Record<string, string>) => { | |
| setStoredAudioModels(models); | |
| if (typeof window !== "undefined") { | |
| window.localStorage.removeItem(LEGACY_AUDIO_MODEL_STORAGE_KEY); | |
| } | |
| }; | |
| const normalizeAudioModelSelections = () => { | |
| const currentSelections = getStoredAudioModels(); | |
| const legacyValue = getStoredValue(LEGACY_AUDIO_MODEL_STORAGE_KEY); | |
| const migratedSelections = migrateLegacyAudioModelSelections(currentSelections, legacyValue); | |
| if (legacyValue && migratedSelections !== currentSelections) { | |
| persistAudioModels(migratedSelections); | |
| } | |
| return migratedSelections; | |
| }; | |
| const findAudioModel = (backend: TranscriptionBackend | undefined, modelId?: string | null) => { | |
| if (!backend || !modelId) return undefined; | |
| return backend.models.find((model) => model.id === modelId || model.repo_id === modelId); | |
| }; | |
| export const resolvePreferredAudioBackend = (settings: TranscriptionSettings, storedBackend: string | null) => { | |
| if (storedBackend && settings.backends.some((backend) => backend.id === storedBackend && backend.supported)) { | |
| return storedBackend; | |
| } | |
| if (settings.backends.some((backend) => backend.id === settings.default_backend && backend.supported)) { | |
| return settings.default_backend; | |
| } | |
| return settings.backends.find((backend) => backend.supported)?.id || settings.backends[0]?.id || "server"; | |
| }; | |
| export const resolvePreferredAudioModel = ( | |
| backend: TranscriptionBackend | undefined, | |
| storedSelections: Record<string, string> | |
| ) => { | |
| if (!backend) return ""; | |
| const storedModel = findAudioModel(backend, storedSelections[backend.id]); | |
| if (storedModel) { | |
| return storedModel.id; | |
| } | |
| const defaultModel = findAudioModel(backend, backend.default_model); | |
| if (defaultModel?.available) { | |
| return defaultModel.id; | |
| } | |
| const firstAvailableModel = backend.models.find((model) => model.available); | |
| if (firstAvailableModel) { | |
| return firstAvailableModel.id; | |
| } | |
| if (defaultModel) { | |
| return defaultModel.id; | |
| } | |
| return backend.models[0]?.id || ""; | |
| }; | |
| const resolvePreferredTextEngine = (settings: TranscriptionSettings) => { | |
| const storedEngine = getStoredValue(TEXT_ENGINE_STORAGE_KEY); | |
| if (storedEngine && settings.text_inference_engines.some((engine) => engine.id === storedEngine)) { | |
| return storedEngine; | |
| } | |
| return settings.text_inference_engines[0]?.id || ""; | |
| }; | |
| export const useTranscriptionModel = () => { | |
| const [settings, setSettings] = useState<TranscriptionSettings | null>(null); | |
| const [selectedAudioBackend, setSelectedAudioBackendState] = useState(""); | |
| const [selectedAudioModel, setSelectedAudioModelState] = useState(""); | |
| const [audioModelSelections, setAudioModelSelections] = useState<Record<string, string>>({}); | |
| const [selectedTextEngine, setSelectedTextEngineState] = useState(""); | |
| const [textEngineUrls, setTextEngineUrls] = useState<Record<string, string>>({}); | |
| const [textEngineStatuses, setTextEngineStatuses] = useState<Record<string, InferenceEngineStatus>>({}); | |
| const [loadingTextEngineId, setLoadingTextEngineId] = useState<string | null>(null); | |
| const [loadingAudioModelId, setLoadingAudioModelId] = useState<string | null>(null); | |
| const [error, setError] = useState<string | null>(null); | |
| useEffect(() => { | |
| let active = true; | |
| const load = async () => { | |
| try { | |
| const data = await apiFetch<TranscriptionSettings>("/settings/transcription"); | |
| if (!active) return; | |
| const preferredAudioBackend = resolvePreferredAudioBackend(data, getStoredValue(AUDIO_BACKEND_STORAGE_KEY)); | |
| const storedAudioSelections = normalizeAudioModelSelections(); | |
| const selectedBackend = data.backends.find((backend) => backend.id === preferredAudioBackend); | |
| const preferredAudioModel = resolvePreferredAudioModel(selectedBackend, storedAudioSelections); | |
| const nextAudioSelections = preferredAudioModel | |
| ? { ...storedAudioSelections, [preferredAudioBackend]: preferredAudioModel } | |
| : storedAudioSelections; | |
| const preferredTextEngine = resolvePreferredTextEngine(data); | |
| const storedUrls = getStoredUrls(); | |
| const nextStatuses = data.text_inference_engines.reduce<Record<string, InferenceEngineStatus>>((acc, engine) => { | |
| acc[engine.id] = engine; | |
| return acc; | |
| }, {}); | |
| const nextUrls = data.text_inference_engines.reduce<Record<string, string>>((acc, engine) => { | |
| acc[engine.id] = storedUrls[engine.id] || engine.base_url; | |
| return acc; | |
| }, {}); | |
| setSettings(data); | |
| setSelectedAudioBackendState(preferredAudioBackend); | |
| setSelectedAudioModelState(preferredAudioModel); | |
| setAudioModelSelections(nextAudioSelections); | |
| setSelectedTextEngineState(preferredTextEngine); | |
| setTextEngineStatuses(nextStatuses); | |
| setTextEngineUrls(nextUrls); | |
| setStoredValue(AUDIO_BACKEND_STORAGE_KEY, preferredAudioBackend); | |
| persistAudioModels(nextAudioSelections); | |
| setStoredValue(TEXT_ENGINE_STORAGE_KEY, preferredTextEngine); | |
| setStoredUrls(nextUrls); | |
| setError(null); | |
| } catch (loadError) { | |
| if (!active) return; | |
| setError(loadError instanceof Error ? loadError.message : "Unable to load transcription settings."); | |
| } | |
| }; | |
| load(); | |
| return () => { | |
| active = false; | |
| }; | |
| }, []); | |
| const setSelectedAudioBackend = (backendId: string) => { | |
| setSelectedAudioBackendState(backendId); | |
| setStoredValue(AUDIO_BACKEND_STORAGE_KEY, backendId); | |
| const backend = settings?.backends.find((entry) => entry.id === backendId); | |
| const nextModel = resolvePreferredAudioModel(backend, audioModelSelections); | |
| setSelectedAudioModelState(nextModel); | |
| if (backend && nextModel) { | |
| const nextSelections = { ...audioModelSelections, [backend.id]: nextModel }; | |
| setAudioModelSelections(nextSelections); | |
| persistAudioModels(nextSelections); | |
| } | |
| }; | |
| const setSelectedAudioModel = (modelId: string) => { | |
| setSelectedAudioModelState(modelId); | |
| if (!selectedAudioBackend) return; | |
| const nextSelections = { ...audioModelSelections, [selectedAudioBackend]: modelId }; | |
| setAudioModelSelections(nextSelections); | |
| persistAudioModels(nextSelections); | |
| }; | |
| const setSelectedTextEngine = (engineId: string) => { | |
| setSelectedTextEngineState(engineId); | |
| setStoredValue(TEXT_ENGINE_STORAGE_KEY, engineId); | |
| }; | |
| const setTextEngineUrl = (engineId: string, baseUrl: string) => { | |
| setTextEngineUrls((current) => { | |
| const next = { ...current, [engineId]: baseUrl }; | |
| setStoredUrls(next); | |
| return next; | |
| }); | |
| }; | |
| const updateDownloadedAudioModel = (backendId: string, downloadedModel: TranscriptionModelOption) => { | |
| setSettings((current) => { | |
| if (!current) return current; | |
| return { | |
| ...current, | |
| backends: current.backends.map((backend) => { | |
| if (backend.id !== backendId) return backend; | |
| const alreadyListed = backend.models.some((model) => model.id === downloadedModel.id); | |
| return { | |
| ...backend, | |
| models: alreadyListed | |
| ? backend.models.map((model) => (model.id === downloadedModel.id ? downloadedModel : model)) | |
| : [...backend.models, downloadedModel], | |
| }; | |
| }), | |
| }; | |
| }); | |
| }; | |
| const connectTextEngine = async (engineId: string, baseUrl?: string) => { | |
| const currentBaseUrl = baseUrl || textEngineUrls[engineId] || ""; | |
| setLoadingTextEngineId(engineId); | |
| setError(null); | |
| try { | |
| const status = await apiFetch<InferenceEngineStatus>("/settings/local-inference/check", { | |
| method: "POST", | |
| body: JSON.stringify({ | |
| engine_id: engineId, | |
| base_url: currentBaseUrl, | |
| }), | |
| }); | |
| setTextEngineStatuses((current) => ({ ...current, [engineId]: status })); | |
| setTextEngineUrl(engineId, status.base_url); | |
| } catch (connectError) { | |
| setError(connectError instanceof Error ? connectError.message : "Unable to connect to the text engine."); | |
| } finally { | |
| setLoadingTextEngineId(null); | |
| } | |
| }; | |
| const downloadAudioModel = async (modelId: string) => { | |
| if (!selectedAudioBackend) return; | |
| setLoadingAudioModelId(modelId); | |
| setError(null); | |
| try { | |
| const downloadedModel = await apiFetch<TranscriptionModelOption>("/settings/transcription/models/download", { | |
| method: "POST", | |
| body: JSON.stringify({ | |
| backend: selectedAudioBackend, | |
| model: modelId, | |
| }), | |
| }); | |
| updateDownloadedAudioModel(selectedAudioBackend, downloadedModel); | |
| setSelectedAudioModelState(downloadedModel.id); | |
| const nextSelections = { ...audioModelSelections, [selectedAudioBackend]: downloadedModel.id }; | |
| setAudioModelSelections(nextSelections); | |
| persistAudioModels(nextSelections); | |
| } catch (downloadError) { | |
| setError(downloadError instanceof Error ? downloadError.message : "Unable to download the selected model."); | |
| } finally { | |
| setLoadingAudioModelId(null); | |
| } | |
| }; | |
| const selectedAudioBackendStatus = useMemo( | |
| () => settings?.backends.find((backend) => backend.id === selectedAudioBackend), | |
| [selectedAudioBackend, settings] | |
| ); | |
| const selectedAudioModelOption = useMemo( | |
| () => selectedAudioBackendStatus?.models.find((model) => model.id === selectedAudioModel), | |
| [selectedAudioBackendStatus, selectedAudioModel] | |
| ); | |
| const selectedTextEngineStatus = selectedTextEngine ? textEngineStatuses[selectedTextEngine] : undefined; | |
| useEffect(() => { | |
| if (!selectedAudioBackendStatus) return; | |
| const nextModel = resolvePreferredAudioModel(selectedAudioBackendStatus, audioModelSelections); | |
| if (nextModel && nextModel !== selectedAudioModel) { | |
| setSelectedAudioModelState(nextModel); | |
| } | |
| if (nextModel && audioModelSelections[selectedAudioBackendStatus.id] !== nextModel) { | |
| const nextSelections = { ...audioModelSelections, [selectedAudioBackendStatus.id]: nextModel }; | |
| setAudioModelSelections(nextSelections); | |
| persistAudioModels(nextSelections); | |
| } | |
| }, [audioModelSelections, selectedAudioBackendStatus, selectedAudioModel]); | |
| return { | |
| audioBackends: settings?.backends || [], | |
| defaultAudioBackend: settings?.default_backend || "", | |
| selectedAudioBackend, | |
| setSelectedAudioBackend, | |
| selectedAudioBackendStatus, | |
| audioModelOptions: selectedAudioBackendStatus?.models || [], | |
| selectedAudioModel, | |
| selectedAudioModelOption, | |
| setSelectedAudioModel, | |
| downloadAudioModel, | |
| loadingAudioModelId, | |
| effectiveSelection: | |
| selectedAudioBackend && selectedAudioModel | |
| ? { backend: selectedAudioBackend, model: selectedAudioModel } | |
| : undefined, | |
| textInferenceEngines: settings?.text_inference_engines || [], | |
| textEngineStatuses, | |
| selectedTextEngine, | |
| setSelectedTextEngine, | |
| textEngineUrls, | |
| setTextEngineUrl, | |
| connectTextEngine, | |
| loadingTextEngineId, | |
| selectedTextEngineStatus, | |
| error, | |
| }; | |
| }; | |
| export type UseTranscriptionModelResult = ReturnType<typeof useTranscriptionModel>; | |