Skip to main content

qualia_client_core/api/
model.rs

1//! Active model + lifecycle
2
3#![allow(non_snake_case)]
4
5use super::*;
6
7use crate::state::*;
8use futures_util::StreamExt;
9use std::io::Write;
10use std::path::{Path, PathBuf};
11use std::sync::atomic::{AtomicBool, Ordering};
12use std::sync::{Arc, Mutex};
13
14/// Active model path.
15pub fn active_model_path() -> PathBuf {
16    app_meta_dir().join("active_model.json")
17}
18
19fn legacy_active_model_path() -> PathBuf {
20    app_meta_dir().join("active_model.txt")
21}
22
23/// Loads active-model-record-from-disk.
24pub fn load_active_model_record_from_disk() -> Option<crate::model_lifecycle::ActiveModelRecord> {
25    let json_path = active_model_path();
26    if let Ok(text) = std::fs::read_to_string(&json_path) {
27        if let Ok(record) = serde_json::from_str(&text) {
28            return Some(record);
29        }
30    }
31
32    // Migrate legacy bare filename.
33    let legacy = std::fs::read_to_string(legacy_active_model_path())
34        .ok()
35        .map(|s| s.trim().to_string())
36        .filter(|s| !s.is_empty())?;
37
38    let state = crate::state::APP_STATE.get()?;
39    let storage = state.config.lock().unwrap().storage_path.clone();
40    let model_id = legacy
41        .trim_end_matches(".gguf")
42        .rsplit(['/', '\\'])
43        .next()
44        .unwrap_or(&legacy)
45        .to_string();
46
47    if let Some(manifest) =
48        crate::model_lifecycle::load_install_manifest(Path::new(&storage), &model_id)
49    {
50        let record = crate::model_lifecycle::ActiveModelRecord {
51            model_id: manifest.model_id,
52            gguf_path: manifest.gguf_path,
53            profile_id: manifest.profile_id,
54            quantization: manifest.quantization,
55            lifecycle_state: crate::model_lifecycle::lifecycle_label(
56                crate::model_lifecycle::get_model_lifecycle_state(),
57            )
58            .to_string(),
59            modality: manifest.modality,
60            architecture: manifest.architecture,
61            mmproj_path: manifest.mmproj_path,
62            context_window: manifest.context_window,
63        };
64        let _ = persist_active_model_record(&record);
65        let _ = std::fs::remove_file(legacy_active_model_path());
66        return Some(record);
67    }
68
69    None
70}
71
72/// Loads active-model-from-disk.
73pub fn load_active_model_from_disk() -> Option<String> {
74    load_active_model_record_from_disk().map(|r| r.gguf_path)
75}
76
77fn persist_active_model_record(
78    record: &crate::model_lifecycle::ActiveModelRecord,
79) -> Result<(), String> {
80    let meta = app_meta_dir();
81    std::fs::create_dir_all(&meta).map_err(|e| e.to_string())?;
82    let json = serde_json::to_string_pretty(record).map_err(|e| e.to_string())?;
83    std::fs::write(active_model_path(), json).map_err(|e| e.to_string())
84}
85
86/// Clears the active-model record.
87pub fn clear_active_model_record() {
88    let _ = std::fs::remove_file(active_model_path());
89    let _ = std::fs::remove_file(legacy_active_model_path());
90}
91
92/// Restores the active model on startup.
93pub fn restore_active_model_on_startup() {
94    let state = crate::state::APP_STATE.get().unwrap();
95    let storage = state.config.lock().unwrap().storage_path.clone();
96    let storage_path = Path::new(&storage);
97
98    if let Some(record) = load_active_model_record_from_disk() {
99        if Path::new(&record.gguf_path).is_file() {
100            log::info!(
101                "LLM_LOAD|startup|0.00|Restoring active model {}",
102                record.model_id
103            );
104            match crate::model_lifecycle::activate_model_for_id(&record.model_id, storage_path) {
105                Ok(active) => {
106                    *state.active_model.lock().unwrap() = Some(active.gguf_path.clone());
107                    return;
108                }
109                Err(err) => {
110                    log::error!(
111                        "LLM_LOAD|failed|1.00|Startup restore failed for {}: {}",
112                        record.model_id,
113                        err
114                    );
115                    *state.active_model.lock().unwrap() = None;
116                    clear_active_model_record();
117                }
118            }
119        }
120    }
121
122    let catalog = load_workspace_catalog();
123    let prefs = crate::model_preferences::ensure_preferences(storage_path, &catalog);
124    if prefs.auto_select {
125        let _ = try_apply_model_preference("chat");
126    }
127}
128
129/// Gets active-model.
130pub fn get_active_model() -> Option<String> {
131    let state = crate::state::APP_STATE.get().unwrap();
132    state.active_model.lock().unwrap().clone()
133}
134
135/// Gets model-lifecycle-status.
136pub fn get_model_lifecycle_status() -> Result<serde_json::Value, String> {
137    let state = crate::state::APP_STATE.get().unwrap();
138    let path = state.active_model.lock().unwrap().clone();
139    let active = load_active_model_record_from_disk().or_else(|| {
140        path.as_ref()
141            .map(|gguf| crate::model_lifecycle::ActiveModelRecord {
142                model_id: gguf
143                    .rsplit(['/', '\\'])
144                    .next()
145                    .unwrap_or(gguf)
146                    .trim_end_matches(".gguf")
147                    .to_string(),
148                gguf_path: gguf.clone(),
149                profile_id: 0,
150                quantization: String::new(),
151                lifecycle_state: crate::model_lifecycle::lifecycle_label(
152                    crate::model_lifecycle::get_model_lifecycle_state(),
153                )
154                .to_string(),
155                modality: "text".to_string(),
156                architecture: None,
157                mmproj_path: None,
158                context_window: 4096,
159            })
160    });
161    let status = crate::model_lifecycle::get_model_status(active);
162    serde_json::to_value(status).map_err(|e| e.to_string())
163}
164
165/// Sets active-model.
166pub fn set_active_model(model_name: String) -> Result<(), String> {
167    let state = crate::state::APP_STATE.get().unwrap();
168    let storage = state.config.lock().unwrap().storage_path.clone();
169    let storage_path = Path::new(&storage);
170
171    let result = if Path::new(&model_name).is_file() {
172        crate::model_lifecycle::finalize_local_gguf(Path::new(&model_name), storage_path)
173            .map_err(|e| e.to_string())
174    } else {
175        let model_id = model_name
176            .trim_end_matches(".gguf")
177            .rsplit(['/', '\\'])
178            .next()
179            .unwrap_or(model_name.as_str())
180            .to_string();
181        crate::model_lifecycle::activate_model_for_id(&model_id, storage_path)
182            .map_err(|e| e.to_string())
183    };
184    let record = match result {
185        Ok(record) => record,
186        Err(err) => {
187            *state.active_model.lock().unwrap() = None;
188            clear_active_model_record();
189            return Err(err);
190        }
191    };
192
193    persist_active_model_record(&record)?;
194    *state.active_model.lock().unwrap() = Some(record.gguf_path.clone());
195    Ok(())
196}
197
198/// Evict the resident model from memory without deleting on-disk GGUF files.
199pub fn unload_active_model() -> Result<(), String> {
200    let state = crate::state::APP_STATE.get().unwrap();
201    if let Some(record) = load_active_model_record_from_disk() {
202        crate::model_lifecycle::unload_active_model(Some(record.profile_id));
203    } else {
204        crate::model_lifecycle::unload_active_model(None);
205    }
206    *state.active_model.lock().unwrap() = None;
207    clear_active_model_record();
208    Ok(())
209}
210
211static MODEL_ACTIVATION_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
212static MODEL_ACTIVATION_ERROR: Mutex<Option<String>> = Mutex::new(None);
213
214/// Activate a model on a background thread so the Flutter FRB caller is not blocked.
215pub fn set_active_model_async(model_name: String) -> Result<(), String> {
216    spawn_model_activation(move || set_active_model(model_name))
217}
218
219/// Applies a model preference (async).
220pub fn try_apply_model_preference_async(task: &str) -> Result<(), String> {
221    let task = task.to_string();
222    spawn_model_activation(move || try_apply_model_preference(&task))
223}
224
225fn spawn_model_activation(
226    work: impl FnOnce() -> Result<(), String> + Send + 'static,
227) -> Result<(), String> {
228    if MODEL_ACTIVATION_IN_PROGRESS.load(Ordering::Acquire) {
229        return Err("Model activation already in progress".to_string());
230    }
231    MODEL_ACTIVATION_IN_PROGRESS.store(true, Ordering::Release);
232    if let Ok(mut slot) = MODEL_ACTIVATION_ERROR.lock() {
233        *slot = None;
234    }
235    crate::system_telemetry::start_activation_telemetry("Loading model");
236    std::thread::Builder::new()
237        .name("qualia-model-activate".into())
238        .spawn(move || {
239            let result = work();
240            if let Err(err) = result {
241                if let Ok(mut slot) = MODEL_ACTIVATION_ERROR.lock() {
242                    *slot = Some(err);
243                }
244            }
245            crate::system_telemetry::stop_activation_telemetry();
246            MODEL_ACTIVATION_IN_PROGRESS.store(false, Ordering::Release);
247        })
248        .map_err(|e| format!("Failed to spawn model activation thread: {e}"))?;
249    Ok(())
250}
251
252/// `true` when model-activation-in-progress.
253pub fn is_model_activation_in_progress() -> bool {
254    MODEL_ACTIVATION_IN_PROGRESS.load(Ordering::Acquire)
255}
256
257/// Takes the model-activation error.
258pub fn take_model_activation_error() -> Option<String> {
259    MODEL_ACTIVATION_ERROR.lock().ok()?.take()
260}
261
262/// Gets inference-backend-settings.
263pub fn get_inference_backend_settings() -> crate::inference_backend::InferenceBackendSettings {
264    crate::inference_backend::load_inference_backend_settings()
265}
266
267/// Saves inference-backend-settings.
268pub fn save_inference_backend_settings(
269    settings: crate::inference_backend::InferenceBackendSettings,
270) -> Result<(), String> {
271    crate::inference_backend::save_inference_backend_settings(&settings)
272}
273
274/// Probe the configured Ollama endpoint (tags + reachability).
275pub fn probe_ollama_status() -> crate::ollama_harness::OllamaStatus {
276    crate::ollama_harness::probe_configured_ollama()
277}
278
279/// Probes Ollama status (async).
280pub async fn probe_ollama_status_async() -> crate::ollama_harness::OllamaStatus {
281    crate::ollama_harness::probe_configured_ollama_async().await
282}
283
284/// List models on the configured Ollama host (empty vec if unreachable).
285pub fn list_ollama_models() -> Vec<crate::ollama_harness::OllamaModelInfo> {
286    crate::ollama_harness::probe_configured_ollama().models
287}
288
289/// One-shot Ollama generate using persisted settings (for smoke / ETL hooks).
290pub fn ollama_generate(
291    system: String,
292    prompt: String,
293) -> Result<crate::ollama_harness::OllamaGenerateResult, String> {
294    crate::ollama_harness::OllamaHarness::from_loaded_settings().generate(&system, &prompt)
295}
296
297/// Ollama generate (async).
298pub async fn ollama_generate_async(
299    system: String,
300    prompt: String,
301) -> Result<crate::ollama_harness::OllamaGenerateResult, String> {
302    crate::ollama_harness::OllamaHarness::from_loaded_settings()
303        .generate_async(&system, &prompt)
304        .await
305}
306
307/// Gets model-preferences.
308pub fn get_model_preferences() -> crate::model_preferences::ModelPreferences {
309    let state = crate::state::APP_STATE.get().unwrap();
310    let storage = state.config.lock().unwrap().storage_path.clone();
311    let catalog = load_workspace_catalog();
312    crate::model_preferences::ensure_preferences(Path::new(&storage), &catalog)
313}
314
315/// Saves model-preferences.
316pub fn save_model_preferences(
317    prefs: crate::model_preferences::ModelPreferences,
318) -> Result<(), String> {
319    let state = crate::state::APP_STATE.get().unwrap();
320    let storage = state.config.lock().unwrap().storage_path.clone();
321    crate::model_preferences::save_preferences(Path::new(&storage), &prefs)
322}
323
324/// Lists installed LLM IDs.
325pub fn list_installed_llm_ids() -> Vec<String> {
326    let state = crate::state::APP_STATE.get().unwrap();
327    let storage = state.config.lock().unwrap().storage_path.clone();
328    crate::model_preferences::list_installed_model_ids(Path::new(&storage))
329}
330
331/// Resolves a model preference.
332pub fn resolve_model_preference(
333    task: &str,
334) -> Option<crate::model_preferences::ResolvedModelPreference> {
335    let state = crate::state::APP_STATE.get().unwrap();
336    let storage = state.config.lock().unwrap().storage_path.clone();
337    let catalog = load_workspace_catalog();
338    let prefs = get_model_preferences();
339    let task = crate::model_preferences::ModelTask::from_str_lossy(task);
340    crate::model_preferences::resolve_preference(Path::new(&storage), &catalog, &prefs, task)
341}
342
343/// Applies a model preference.
344pub fn try_apply_model_preference(task: &str) -> Result<(), String> {
345    let state = crate::state::APP_STATE.get().unwrap();
346    let storage = state.config.lock().unwrap().storage_path.clone();
347    let catalog = load_workspace_catalog();
348    let prefs = get_model_preferences();
349    let task = crate::model_preferences::ModelTask::from_str_lossy(task);
350    let record = match crate::model_preferences::apply_preference(
351        Path::new(&storage),
352        &catalog,
353        &prefs,
354        task,
355    ) {
356        Ok(record) => record,
357        Err(err) => {
358            *state.active_model.lock().unwrap() = None;
359            clear_active_model_record();
360            return Err(err);
361        }
362    };
363    persist_active_model_record(&record)?;
364    *state.active_model.lock().unwrap() = Some(record.gguf_path.clone());
365    Ok(())
366}
367
368/// Installs a catalog LLM.
369pub async fn install_catalog_llm(id: String) -> Result<serde_json::Value, String> {
370    let state = crate::state::APP_STATE.get().unwrap();
371    let storage_path = state.config.lock().unwrap().storage_path.clone();
372    let handles = state.download_handles.clone();
373    let active_dl = state.active_downloads.clone();
374    let catalog = load_workspace_catalog();
375
376    let model = catalog
377        .find_llm(&id)
378        .ok_or_else(|| format!("LLM not found in catalog: {id}"))?;
379    let url = model
380        .download
381        .resolved_url()
382        .ok_or_else(|| format!("No download URL for: {id}"))?;
383    let filename = model
384        .download
385        .local_filename()
386        .unwrap_or_else(|| format!("{id}.gguf"));
387
388    let models_dir = PathBuf::from(&storage_path).join("Models");
389    std::fs::create_dir_all(&models_dir).map_err(|e| e.to_string())?;
390    let dest_path = models_dir.join(&filename);
391
392    let cancelled = Arc::new(AtomicBool::new(false));
393    handles
394        .lock()
395        .unwrap()
396        .insert(id.clone(), cancelled.clone());
397
398    let client = reqwest::Client::new();
399    let response = client.get(&url).send().await.map_err(|e| {
400        handles.lock().unwrap().remove(&id);
401        active_dl.lock().unwrap().remove(&id);
402        e.to_string()
403    })?;
404    let total_bytes = response.content_length().unwrap_or(0);
405    let starting_payload = ProgressPayload {
406        id: id.clone(),
407        progress: 0.0,
408        downloaded_bytes: 0,
409        total_bytes,
410        speed_kbps: 0.0,
411        status: "downloading".to_string(),
412    };
413    let _ = state.download_events.send(starting_payload.clone());
414    active_dl
415        .lock()
416        .unwrap()
417        .insert(id.clone(), starting_payload);
418
419    let mut dest = std::fs::File::create(&dest_path).map_err(|e| e.to_string())?;
420    let mut stream = response.bytes_stream();
421    let mut downloaded: u64 = 0;
422    let mut last_report = std::time::Instant::now();
423    let mut last_downloaded: u64 = 0;
424
425    while let Some(chunk) = stream.next().await {
426        if cancelled.load(Ordering::Relaxed) {
427            let _ = std::fs::remove_file(&dest_path);
428            let payload = ProgressPayload {
429                id: id.clone(),
430                progress: 0.0,
431                downloaded_bytes: downloaded,
432                total_bytes,
433                speed_kbps: 0.0,
434                status: "cancelled".to_string(),
435            };
436            let _ = state.download_events.send(payload.clone());
437            handles.lock().unwrap().remove(&id);
438            active_dl.lock().unwrap().remove(&id);
439            return Err("Cancelled".to_string());
440        }
441        let chunk = chunk.map_err(|e| e.to_string())?;
442        dest.write_all(&chunk).map_err(|e| e.to_string())?;
443        downloaded += chunk.len() as u64;
444
445        let now = std::time::Instant::now();
446        if now.duration_since(last_report).as_millis() >= 200 {
447            let elapsed = now.duration_since(last_report).as_secs_f64().max(0.001);
448            let speed_kbps = ((downloaded - last_downloaded) as f64 / 1024.0) / elapsed;
449            let progress = if total_bytes > 0 {
450                (downloaded as f64 / total_bytes as f64) * 100.0
451            } else {
452                0.0
453            };
454            let payload = ProgressPayload {
455                id: id.clone(),
456                progress,
457                downloaded_bytes: downloaded,
458                total_bytes,
459                speed_kbps,
460                status: "downloading".to_string(),
461            };
462            let _ = state.download_events.send(payload.clone());
463            active_dl.lock().unwrap().insert(id.clone(), payload);
464            last_report = now;
465            last_downloaded = downloaded;
466        }
467    }
468
469    let processing_payload = ProgressPayload {
470        id: id.clone(),
471        progress: 100.0,
472        downloaded_bytes: downloaded,
473        total_bytes,
474        speed_kbps: 0.0,
475        status: "processing".to_string(),
476    };
477    let _ = state.download_events.send(processing_payload.clone());
478    active_dl
479        .lock()
480        .unwrap()
481        .insert(id.clone(), processing_payload);
482
483    let mut mmproj_path: Option<PathBuf> = None;
484    if model.is_multimodal() {
485        let vp = model.vision_projector.as_ref().ok_or_else(|| {
486            "Multimodal catalog entry missing vision_projector download".to_string()
487        })?;
488        let vp_url = vp
489            .resolved_url()
490            .ok_or_else(|| "No download URL for vision projector".to_string())?;
491        let vp_name = vp
492            .local_filename()
493            .unwrap_or_else(|| format!("{id}-mmproj.gguf"));
494        let vp_dest = models_dir.join(&vp_name);
495        crate::resource_import::stream_download(&vp_url, &vp_dest)
496            .await
497            .map_err(|e| e.to_string())?;
498        mmproj_path = Some(vp_dest);
499    }
500
501    let result = crate::model_lifecycle::finalize_llm_install(
502        model,
503        &dest_path,
504        mmproj_path.as_deref(),
505        Path::new(&storage_path),
506    )
507    .map_err(|e| e.to_string())?;
508
509    // New installs should be immediately usable in chat (not left at MappedToDisk).
510    if let Ok(record) = crate::model_lifecycle::activate_model_for_id(&id, Path::new(&storage_path))
511    {
512        let _ = persist_active_model_record(&record);
513        *state.active_model.lock().unwrap() = Some(record.gguf_path.clone());
514    }
515
516    let done_payload = ProgressPayload {
517        id: id.clone(),
518        progress: 100.0,
519        downloaded_bytes: downloaded,
520        total_bytes,
521        speed_kbps: 0.0,
522        status: "complete".to_string(),
523    };
524    let _ = state.download_events.send(done_payload.clone());
525    handles.lock().unwrap().remove(&id);
526    active_dl.lock().unwrap().remove(&id);
527
528    serde_json::to_value(result).map_err(|e| e.to_string())
529}