1#![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
14pub 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
23pub 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 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
72pub 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
86pub 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
92pub 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
129pub fn get_active_model() -> Option<String> {
131 let state = crate::state::APP_STATE.get().unwrap();
132 state.active_model.lock().unwrap().clone()
133}
134
135pub 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
165pub 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
198pub 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
214pub fn set_active_model_async(model_name: String) -> Result<(), String> {
216 spawn_model_activation(move || set_active_model(model_name))
217}
218
219pub 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
252pub fn is_model_activation_in_progress() -> bool {
254 MODEL_ACTIVATION_IN_PROGRESS.load(Ordering::Acquire)
255}
256
257pub fn take_model_activation_error() -> Option<String> {
259 MODEL_ACTIVATION_ERROR.lock().ok()?.take()
260}
261
262pub fn get_inference_backend_settings() -> crate::inference_backend::InferenceBackendSettings {
264 crate::inference_backend::load_inference_backend_settings()
265}
266
267pub 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
274pub fn probe_ollama_status() -> crate::ollama_harness::OllamaStatus {
276 crate::ollama_harness::probe_configured_ollama()
277}
278
279pub async fn probe_ollama_status_async() -> crate::ollama_harness::OllamaStatus {
281 crate::ollama_harness::probe_configured_ollama_async().await
282}
283
284pub fn list_ollama_models() -> Vec<crate::ollama_harness::OllamaModelInfo> {
286 crate::ollama_harness::probe_configured_ollama().models
287}
288
289pub 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
297pub 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
307pub 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
315pub 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
324pub 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
331pub 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
343pub 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
368pub 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 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}