A free, open source, and extensible speech-to-text application that works completely offline.
import { create } from "zustand";
import { subscribeWithSelector } from "zustand/middleware";
import { produce } from "immer";
import { listen } from "@tauri-apps/api/event";
import { commands, type ModelInfo } from "@/bindings";
import i18n from "@/i18n";
import { notify, useNoticeStore } from "@/stores/noticeStore";
const downloadNoticeKey = (modelId: string) => `model-download:${modelId}`;
export interface DownloadProgress {
model_id: string;
downloaded: number;
total: number;
percentage: number;
/** Measured by the backend over this transfer only; null until known. */
bytes_per_sec: number | null;
}
// Using Record instead of Set/Map for Immer compatibility
interface ModelsStore {
models: ModelInfo[];
currentModel: string;
downloadingModels: Record<string, true>;
verifyingModels: Record<string, true>;
downloadProgress: Record<string, DownloadProgress>;
loading: boolean;
error: string | null;
initialized: boolean;
isRescanning: boolean;
// Actions
initialize: () => Promise<void>;
loadModels: () => Promise<void>;
loadCurrentModel: () => Promise<void>;
rescanLocalModels: () => Promise<void>;
selectModel: (modelId: string) => Promise<boolean>;
downloadModel: (modelId: string) => Promise<boolean>;
cancelDownload: (modelId: string) => Promise<boolean>;
deleteModel: (modelId: string) => Promise<boolean>;
getModelInfo: (modelId: string) => ModelInfo | undefined;
isModelDownloading: (modelId: string) => boolean;
isModelVerifying: (modelId: string) => boolean;
getDownloadProgress: (modelId: string) => DownloadProgress | undefined;
// Internal setters
setModels: (models: ModelInfo[]) => void;
setCurrentModel: (modelId: string) => void;
setError: (error: string | null) => void;
setLoading: (loading: boolean) => void;
}
export const useModelStore = create<ModelsStore>()(
subscribeWithSelector((set, get) => ({
models: [],
currentModel: "",
downloadingModels: {},
verifyingModels: {},
downloadProgress: {},
loading: true,
error: null,
initialized: false,
isRescanning: false,
// Internal setters
setModels: (models) => set({ models }),
setCurrentModel: (currentModel) => set({ currentModel }),
setError: (error) => set({ error }),
setLoading: (loading) => set({ loading }),
loadModels: async () => {
try {
const result = await commands.getAvailableModels();
if (result.status === "ok") {
set({ models: result.data, error: null });
// Sync downloading state from backend
set(
produce((state) => {
const backendDownloading: Record<string, true> = {};
result.data
.filter((m) => m.is_downloading)
.forEach((m) => {
backendDownloading[m.id] = true;
});
// Merge: keep frontend state if downloading, add backend state
Object.keys(backendDownloading).forEach((id) => {
state.downloadingModels[id] = true;
});
// Remove models that backend says are NOT downloading AND
// frontend doesn't have progress for (completed/cancelled)
Object.keys(state.downloadingModels).forEach((id) => {
if (!backendDownloading[id] && !state.downloadProgress[id]) {
delete state.downloadingModels[id];
}
});
}),
);
} else {
set({ error: `Failed to load models: ${result.error}` });
}
} catch (err) {
set({ error: `Failed to load models: ${err}` });
} finally {
set({ loading: false });
}
},
loadCurrentModel: async () => {
try {
const result = await commands.getCurrentModel();
if (result.status === "ok") {
set({ currentModel: result.data });
}
} catch (err) {
console.error("Failed to load current model:", err);
}
},
rescanLocalModels: async () => {
set({ isRescanning: true });
try {
const result = await commands.rescanLocalModels();
if (result.status !== "ok") {
set({ error: `Failed to rescan models: ${result.error}` });
}
// On success the backend emits `models-updated`, which reloads the list
// via the listener registered in initialize().
} catch (err) {
set({ error: `Failed to rescan models: ${err}` });
} finally {
set({ isRescanning: false });
}
},
selectModel: async (modelId: string) => {
try {
set({ error: null });
const result = await commands.setActiveModel(modelId);
if (result.status === "ok") {
set({ currentModel: modelId });
return true;
} else {
set({ error: `Failed to switch to model: ${result.error}` });
return false;
}
} catch (err) {
set({ error: `Failed to switch to model: ${err}` });
return false;
}
},
downloadModel: async (modelId: string) => {
try {
useNoticeStore.getState().clearLocal(downloadNoticeKey(modelId));
set({ error: null });
set(
produce((state) => {
state.downloadingModels[modelId] = true;
state.downloadProgress[modelId] = {
model_id: modelId,
downloaded: 0,
total: 0,
percentage: 0,
};
}),
);
const result = await commands.downloadModel(modelId);
if (result.status !== "ok") {
// Fallback cleanup in case the model-download-failed event was not received
// (e.g. listener not yet registered). The event handler is a no-op if it
// arrives after this cleanup since deleting missing keys is safe.
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.downloadProgress[modelId];
}),
);
}
return result.status === "ok";
} catch {
// model-download-failed event won't fire for JS exceptions (e.g. IPC error),
// so clean up state here to avoid a stuck progress spinner.
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.downloadProgress[modelId];
}),
);
return false;
}
},
cancelDownload: async (modelId: string) => {
try {
set({ error: null });
const result = await commands.cancelDownload(modelId);
if (result.status === "ok") {
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.downloadProgress[modelId];
}),
);
// Reload models to sync with backend state
await get().loadModels();
return true;
} else {
set({ error: `Failed to cancel download: ${result.error}` });
return false;
}
} catch (err) {
set({ error: `Failed to cancel download: ${err}` });
return false;
}
},
deleteModel: async (modelId: string) => {
try {
set({ error: null });
const result = await commands.deleteModel(modelId);
if (result.status === "ok") {
await get().loadModels();
await get().loadCurrentModel();
return true;
} else {
set({ error: `Failed to delete model: ${result.error}` });
return false;
}
} catch (err) {
set({ error: `Failed to delete model: ${err}` });
return false;
}
},
getModelInfo: (modelId: string) => {
return get().models.find((model) => model.id === modelId);
},
isModelDownloading: (modelId: string) => {
return modelId in get().downloadingModels;
},
isModelVerifying: (modelId: string) => {
return modelId in get().verifyingModels;
},
getDownloadProgress: (modelId: string) => {
return get().downloadProgress[modelId];
},
initialize: async () => {
if (get().initialized) return;
const { loadModels, loadCurrentModel } = get();
// Load initial data
await Promise.all([loadModels(), loadCurrentModel()]);
// Set up event listeners
listen<DownloadProgress>("model-download-progress", (event) => {
const progress = event.payload;
set(
produce((state) => {
state.downloadProgress[progress.model_id] = progress;
}),
);
});
listen<string>("model-download-complete", (event) => {
const modelId = event.payload;
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.verifyingModels[modelId];
delete state.downloadProgress[modelId];
}),
);
get().loadModels();
});
listen<{ model_id: string; error: string }>(
"model-download-failed",
(event) => {
const { model_id: modelId, error } = event.payload;
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.verifyingModels[modelId];
delete state.downloadProgress[modelId];
state.error = error;
}),
);
notify({
title: i18n.t("errors.modelDownloadFailed"),
detail: error,
key: downloadNoticeKey(modelId),
});
},
);
listen<string>("model-verification-started", (event) => {
const modelId = event.payload;
set(
produce((state) => {
state.verifyingModels[modelId] = true;
}),
);
});
listen<string>("model-verification-completed", (event) => {
const modelId = event.payload;
set(
produce((state) => {
delete state.verifyingModels[modelId];
}),
);
});
listen<string>("model-download-cancelled", (event) => {
const modelId = event.payload;
set(
produce((state) => {
delete state.downloadingModels[modelId];
delete state.verifyingModels[modelId];
delete state.downloadProgress[modelId];
}),
);
});
listen<string>("model-deleted", () => {
get().loadModels();
get().loadCurrentModel();
});
listen("model-state-changed", () => {
get().loadModels();
get().loadCurrentModel();
});
listen("models-updated", () => {
get().loadModels();
get().loadCurrentModel();
});
set({ initialized: true });
},
})),
);