π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Add Ensu Packs to desktop
setalp5fbeb9736e04
diff --git a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs b/rust/apps/ensu/src-tauri/src/commands/chat_db.rsindex 7c27f94734..f680a29989 100644--- a/rust/apps/ensu/src-tauri/src/commands/chat_db.rs+++ b/rust/apps/ensu/src-tauri/src/commands/chat_db.rs@@ -12,6 +12,7 @@ use uuid::Uuid;use crate::commands::chat_db_migration;use crate::commands::common::{ApiError, app_data_dir};+use crate::commands::knowledge::SourceCitationDto;use crate::logging;#[derive(Default)]@@ -92,14 +93,23 @@ pub struct ChatSessionPreviewDto {last_message_preview: Option<String>,}-impl From<db::SessionWithPreview> for ChatSessionPreviewDto {- fn from(session: db::SessionWithPreview) -> Self {+impl ChatSessionPreviewDto {+ fn from_session_and_last_message(+ session: db::Session,+ last_message: Option<db::Message>,+ ) -> Self {Self {session_uuid: session.uuid.to_string(),title: session.title,created_at: session.created_at,updated_at: session.updated_at,- last_message_preview: session.last_message_preview,+ last_message_preview: last_message.map(|message| {+ if message.sender == db::Sender::Other {+ ente_ensu::retrieval::clean_assistant_text(&message.text)+ } else {+ message.text+ }+ }),}}}@@ -170,6 +180,8 @@ pub struct ChatMessageDto {text: String,created_at: i64,attachments: Vec<ChatAttachmentDto>,+ citations: Vec<SourceCitationDto>,+ source_label: Option<String>,}impl From<db::Message> for ChatMessageDto {@@ -178,18 +190,29 @@ impl From<db::Message> for ChatMessageDto {db::Sender::SelfUser => "self",db::Sender::Other => "assistant",};+ let parsed = if message.sender == db::Sender::Other {+ ente_ensu::retrieval::parse_assistant_text(&message.text)+ } else {+ ente_ensu::retrieval::ParsedAssistantText {+ text: message.text,+ citations: Vec::new(),+ }+ };+ let source_label = ente_ensu::retrieval::knowledge_source_chip_label(&parsed.citations);Self {message_uuid: message.uuid.to_string(),session_uuid: message.session_uuid.to_string(),parent_message_uuid: message.parent_message_uuid.map(|value| value.to_string()),sender: sender.to_string(),- text: message.text,+ text: parsed.text,created_at: message.created_at,attachments: message.attachments.into_iter().map(ChatAttachmentDto::from).collect(),+ citations: parsed.citations.into_iter().map(Into::into).collect(),+ source_label,}}}@@ -202,6 +225,7 @@ pub struct ChatMessageInsertInput {text: String,parent_message_uuid: Option<String>,attachments: Option<Vec<ChatAttachmentInput>>,+ citations: Option<Vec<SourceCitationDto>>,}#[derive(Deserialize)]@@ -251,11 +275,16 @@ pub async fn chat_db_list_sessions_with_preview(state: State<'_, ChatDbState>,) -> Result<Vec<ChatSessionPreviewDto>, ApiError> {with_chat_db_async(&state, |db| {- Ok(db- .list_sessions_with_preview()?+ db.list_sessions()?.into_iter()- .map(ChatSessionPreviewDto::from)- .collect())+ .map(|session| {+ let last_message = db.get_messages(session.uuid)?.pop();+ Ok(ChatSessionPreviewDto::from_session_and_last_message(+ session,+ last_message,+ ))+ })+ .collect()}).await}@@ -327,11 +356,16 @@ pub async fn chat_db_insert_message(let parent = optional_uuid(&input.parent_message_uuid)?;let sender = normalize_sender(&input.sender)?;let attachments = convert_attachments(input.attachments)?;+ let text = if sender == "other" {+ finalize_assistant_text(&input.text, input.citations.unwrap_or_default())?+ } else {+ input.text+ };with_chat_db_async(&state, move |db| {Ok(ChatMessageDto::from(db.insert_message(session_uuid,sender,- &input.text,+ &text,parent,attachments,)?))@@ -493,6 +527,15 @@ fn normalize_sender(sender: &str) -> Result<&'static str, ApiError> {}}+fn finalize_assistant_text(+ text: &str,+ citations: Vec<SourceCitationDto>,+) -> Result<String, ApiError> {+ let citations = citations.into_iter().map(Into::into).collect::<Vec<_>>();+ ente_ensu::retrieval::finalize_assistant_text(text, &citations)+ .map_err(crate::commands::knowledge::retrieval_error)+}+fn parse_uuid(value: &str) -> Result<Uuid, ApiError> {Uuid::parse_str(value).map_err(|error| ApiError::new("uuid", error.to_string()))}diff --git a/rust/apps/ensu/src-tauri/src/commands/knowledge.rs b/rust/apps/ensu/src-tauri/src/commands/knowledge.rsnew file mode 100644index 0000000000..e12f72d01b--- /dev/null+++ b/rust/apps/ensu/src-tauri/src/commands/knowledge.rs@@ -0,0 +1,535 @@+use std::collections::{HashMap, HashSet};+use std::sync::atomic::Ordering;+use std::sync::{Arc, Mutex, PoisonError};++use ente_assets::{AssetStore, download};+use ente_ensu::config::{AttributionConfig, KnowledgeDatasetConfig};+use ente_ensu::{llm, retrieval};+use serde::{Deserialize, Serialize};+use tauri::async_runtime;+use tauri::{AppHandle, Emitter, Manager, State as TauriState, WebviewWindow};++use crate::commands::common::ApiError;+use crate::commands::llm::ModelDownloadState;+use crate::logging;++struct OpenIndex {+ directory: String,+ index: retrieval::RetrievalIndex,+}++#[derive(Default)]+pub struct State {+ indexes: Arc<Mutex<HashMap<String, OpenIndex>>>,+ active_downloads: Mutex<HashMap<String, download::CancellationToken>>,+ pack_lifecycles: Mutex<HashMap<String, Arc<async_runtime::Mutex<()>>>>,+}++impl State {+ fn pack_lifecycle(&self, stable_id: &str) -> Arc<async_runtime::Mutex<()>> {+ Arc::clone(+ self.pack_lifecycles+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .entry(stable_id.to_owned())+ .or_default(),+ )+ }+}++#[derive(Debug, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct AttributionDto {+ credit: String,+ license_label: String,+ license_url: String,+ public_pack_url: String,+ modification_notice: String,+}++impl From<AttributionConfig> for AttributionDto {+ fn from(value: AttributionConfig) -> Self {+ Self {+ credit: value.credit,+ license_label: value.license_label,+ license_url: value.license_url,+ public_pack_url: value.public_pack_url,+ modification_notice: value.modification_notice,+ }+ }+}++#[derive(Debug, Serialize)]+#[serde(rename_all = "camelCase")]+pub enum KnowledgePackStatusDto {+ Download,+ Ready,+ UpdateAvailable,+}++impl From<retrieval::KnowledgeReconciliationStatus> for KnowledgePackStatusDto {+ fn from(value: retrieval::KnowledgeReconciliationStatus) -> Self {+ match value {+ retrieval::KnowledgeReconciliationStatus::Download => Self::Download,+ retrieval::KnowledgeReconciliationStatus::Ready => Self::Ready,+ retrieval::KnowledgeReconciliationStatus::UpdateAvailable => Self::UpdateAvailable,+ }+ }+}++#[derive(Debug, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct KnowledgePackDto {+ stable_id: String,+ label: String,+ download_size_bytes: i64,+ status: KnowledgePackStatusDto,+ attribution: AttributionDto,+}++#[derive(Debug, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct SourceCitationDto {+ pub dataset_id: String,+ pub dataset_label: String,+ pub credit: String,+ pub title: String,+ pub source_url: String,+ pub license_label: String,+ pub license_url: String,+}++impl From<retrieval::SourceCitation> for SourceCitationDto {+ fn from(value: retrieval::SourceCitation) -> Self {+ Self {+ dataset_id: value.dataset_id,+ dataset_label: value.dataset_label,+ credit: value.credit,+ title: value.title,+ source_url: value.source_url,+ license_label: value.license_label,+ license_url: value.license_url,+ }+ }+}++impl From<SourceCitationDto> for retrieval::SourceCitation {+ fn from(value: SourceCitationDto) -> Self {+ Self {+ dataset_id: value.dataset_id,+ dataset_label: value.dataset_label,+ credit: value.credit,+ title: value.title,+ source_url: value.source_url,+ license_label: value.license_label,+ license_url: value.license_url,+ }+ }+}++#[derive(Debug, Serialize)]+#[serde(rename_all = "camelCase")]+pub struct KnowledgePromptContextDto {+ text: String,+ citations: Vec<SourceCitationDto>,+}++impl From<retrieval::KnowledgePromptContext> for KnowledgePromptContextDto {+ fn from(value: retrieval::KnowledgePromptContext) -> Self {+ Self {+ text: value.text,+ citations: value.citations.into_iter().map(Into::into).collect(),+ }+ }+}++#[derive(Debug, Serialize, Clone)]+#[serde(rename_all = "camelCase")]+struct KnowledgeDownloadProgressDto {+ stable_id: String,+ percent: i32,+}++fn knowledge_dataset(stable_id: &str) -> Result<KnowledgeDatasetConfig, ApiError> {+ ente_ensu::config::knowledge_dataset(stable_id).ok_or_else(|| {+ ApiError::new(+ "invalid_target",+ format!("Unknown knowledge pack: {stable_id}"),+ )+ })+}++pub(crate) fn retrieval_error(error: retrieval::RetrievalError) -> ApiError {+ let code = match &error {+ retrieval::RetrievalError::InvalidInput(_) => "invalid_input",+ retrieval::RetrievalError::InvalidPack(_) => "invalid_pack",+ retrieval::RetrievalError::Io(_) => "io",+ retrieval::RetrievalError::Json(_) => "json",+ retrieval::RetrievalError::Zstd(_) => "zstd",+ };+ ApiError::new(code, error.to_string())+}++fn reconcile_and_open(+ store: &AssetStore,+ indexes: &Mutex<HashMap<String, OpenIndex>>,+ dataset: &KnowledgeDatasetConfig,+) -> Result<retrieval::KnowledgeReconciliation, ApiError> {+ let pack_root = retrieval::knowledge_pack_root(store, dataset)+ .map_err(|error| ApiError::new("invalid_target", error.to_string()))?;+ let result =+ retrieval::reconcile_knowledge_pack(&pack_root, dataset).map_err(retrieval_error)?;++ let mut indexes = indexes.lock().unwrap_or_else(PoisonError::into_inner);+ match result.active_directory.as_deref() {+ None => {+ indexes.remove(&dataset.stable_id);+ }+ Some(directory) => {+ let needs_replacement = indexes+ .get(&dataset.stable_id)+ .is_none_or(|open| open.directory != directory);+ if needs_replacement {+ let index =+ retrieval::RetrievalIndex::open(directory, dataset).map_err(retrieval_error)?;+ indexes.insert(+ dataset.stable_id.clone(),+ OpenIndex {+ directory: directory.to_string(),+ index,+ },+ );+ }+ }+ }+ drop(indexes);++ if let Some(active_identity) = result.active_identity.as_deref()+ && let Err(error) = retrieval::cleanup_obsolete_knowledge_pack_revisions(+ &pack_root,+ dataset,+ active_identity,+ )+ {+ logging::log(+ "Knowledge",+ format!(+ "obsolete revision cleanup skipped pack={} error={error}",+ dataset.stable_id+ ),+ );+ }++ Ok(result)+}++fn pack_dto(+ dataset: KnowledgeDatasetConfig,+ reconciliation: retrieval::KnowledgeReconciliation,+) -> KnowledgePackDto {+ KnowledgePackDto {+ stable_id: dataset.stable_id,+ label: dataset.label,+ download_size_bytes: dataset.download_size_bytes,+ status: reconciliation.status.into(),+ attribution: dataset.attribution.into(),+ }+}++#[tauri::command]+pub async fn knowledge_catalog(+ model_state: TauriState<'_, ModelDownloadState>,+ knowledge_state: TauriState<'_, State>,+) -> Result<Vec<KnowledgePackDto>, ApiError> {+ let store = model_state.store();+ let mut packs = Vec::new();+ for dataset in ente_ensu::config::defaults().knowledge_datasets {+ let lifecycle = knowledge_state.pack_lifecycle(&dataset.stable_id);+ let _lifecycle = lifecycle.lock().await;+ let indexes = Arc::clone(&knowledge_state.indexes);+ let reconcile_store = Arc::clone(&store);+ let reconcile_dataset = dataset.clone();+ let reconciliation = async_runtime::spawn_blocking(move || {+ reconcile_and_open(&reconcile_store, &indexes, &reconcile_dataset)+ })+ .await;+ let reconciliation = match reconciliation {+ Ok(Ok(result)) => result,+ result => {+ let error = match result {+ Ok(Err(error)) => error.message,+ Err(error) => error.to_string(),+ Ok(Ok(_)) => unreachable!(),+ };+ logging::log(+ "Knowledge",+ format!(+ "pack reconciliation failed pack={} error={error}",+ dataset.stable_id+ ),+ );+ retrieval::KnowledgeReconciliation {+ status: retrieval::KnowledgeReconciliationStatus::Download,+ active_identity: None,+ active_directory: None,+ }+ }+ };+ packs.push(pack_dto(dataset, reconciliation));+ }+ Ok(packs)+}++#[tauri::command]+pub async fn knowledge_download_pack(+ window: WebviewWindow,+ model_state: TauriState<'_, ModelDownloadState>,+ knowledge_state: TauriState<'_, State>,+ stable_id: String,+) -> Result<KnowledgePackDto, ApiError> {+ let dataset = knowledge_dataset(&stable_id)?;+ let asset = retrieval::knowledge_asset(&dataset)+ .map_err(|error| ApiError::new("invalid_target", error.to_string()))?;+ let store = model_state.store();+ let token = {+ let mut active = knowledge_state+ .active_downloads+ .lock()+ .unwrap_or_else(PoisonError::into_inner);+ if active.contains_key(&stable_id) {+ return Err(ApiError::new(+ "download_active",+ "This knowledge pack is already downloading",+ ));+ }+ let token = download::CancellationToken::new();+ active.insert(stable_id.clone(), token.clone());+ token+ };+ let lifecycle = knowledge_state.pack_lifecycle(&stable_id);+ let _lifecycle = lifecycle.lock().await;++ let progress_id = stable_id.clone();+ let download_result = store+ .download(+ std::slice::from_ref(&asset),+ move |progress| {+ let _ = window.emit(+ "knowledge-download-progress",+ KnowledgeDownloadProgressDto {+ stable_id: progress_id.clone(),+ percent: (progress.batch_percentage as i32).clamp(0, 99),+ },+ );+ },+ token.clone(),+ )+ .await;++ let indexes = Arc::clone(&knowledge_state.indexes);+ let reconcile_store = Arc::clone(&store);+ let reconcile_dataset = dataset.clone();+ let reconciliation_result = async_runtime::spawn_blocking(move || {+ reconcile_and_open(&reconcile_store, &indexes, &reconcile_dataset)+ })+ .await;++ let was_cancelled = {+ let mut active = knowledge_state+ .active_downloads+ .lock()+ .unwrap_or_else(PoisonError::into_inner);+ let was_cancelled = token.is_cancelled();+ active.remove(&stable_id);+ was_cancelled+ };++ if let Err(error) = download_result {+ match &reconciliation_result {+ Ok(Err(reconcile_error)) => logging::log(+ "Knowledge",+ format!(+ "post-download reconciliation failed pack={} error={}",+ dataset.stable_id, reconcile_error.message+ ),+ ),+ Err(error) => logging::log(+ "Knowledge",+ format!(+ "post-download reconciliation task failed pack={} error={error}",+ dataset.stable_id+ ),+ ),+ Ok(Ok(_)) => {}+ }+ return Err(ApiError::new(+ crate::commands::llm::download_code(&error),+ error.to_string(),+ ));+ }+ if was_cancelled {+ return Err(ApiError::new(+ "cancelled",+ "Knowledge pack download cancelled",+ ));+ }+ let reconciliation = reconciliation_result+ .map_err(|_| ApiError::new("io_thread", "Knowledge reconciliation task failed"))??;++ if reconciliation.active_identity.as_deref() != Some(dataset.current_download_identity.as_str())+ {+ return Err(ApiError::new(+ "validation",+ "Downloaded knowledge pack failed current revision validation",+ ));+ }++ Ok(pack_dto(dataset, reconciliation))+}++#[tauri::command]+pub fn knowledge_cancel_pack_download(knowledge_state: TauriState<'_, State>, stable_id: String) {+ if let Some(token) = knowledge_state+ .active_downloads+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .get(&stable_id)+ {+ token.cancel();+ }+}++#[tauri::command]+pub async fn knowledge_retrieve(+ model_state: TauriState<'_, ModelDownloadState>,+ llm_state: TauriState<'_, crate::commands::llm::State>,+ knowledge_state: TauriState<'_, State>,+ query: String,+ enabled_stable_ids: Vec<String>,+ max_context_utf8_bytes: u32,+ retrieval_epoch: u64,+) -> Result<Option<KnowledgePromptContextDto>, ApiError> {+ if query.trim().is_empty() || enabled_stable_ids.is_empty() || max_context_utf8_bytes == 0 {+ return Ok(None);+ }++ let defaults = ente_ensu::config::defaults();+ let enabled = enabled_stable_ids.into_iter().collect::<HashSet<_>>();+ let datasets = defaults+ .knowledge_datasets+ .into_iter()+ .filter(|dataset| enabled.contains(&dataset.stable_id))+ .collect::<Vec<_>>();++ let embedding = defaults.knowledge_embedding;+ let store = model_state.store();+ let embedding_asset = ente_ensu::model::knowledge_embedding_model_asset();+ if !store.is_downloaded(&embedding_asset) {+ return Err(ApiError::new(+ "embedding_missing",+ "The knowledge embedding model is not downloaded",+ ));+ }+ let embedding_path = ente_ensu::model::llm_model_path(&store, &embedding_asset)+ .ok_or_else(|| ApiError::new("embedding_missing", "Embedding model path is missing"))?;+ let indexes = Arc::clone(&knowledge_state.indexes);+ let cancellation_epoch = llm_state.retrieval_epoch();+ if cancellation_epoch.load(Ordering::Relaxed) != retrieval_epoch {+ return Err(ApiError::new("cancelled", "Knowledge retrieval cancelled"));+ }+ let _lifecycle = llm_state.lifecycle().lock().await;+ if cancellation_epoch.load(Ordering::Relaxed) != retrieval_epoch {+ return Err(ApiError::new("cancelled", "Knowledge retrieval cancelled"));+ }+ crate::commands::llm::replace_state(&llm_state, None, None)?;++ async_runtime::spawn_blocking(move || {+ let check_cancelled = || {+ if cancellation_epoch.load(Ordering::Relaxed) == retrieval_epoch {+ Ok(())+ } else {+ Err(ApiError::new("cancelled", "Knowledge retrieval cancelled"))+ }+ };+ check_cancelled()?;+ let model = llm::Model::load(llm::ModelLoadParams {+ model_path: embedding_path.display().to_string(),+ n_gpu_layers: Some(0),+ use_mmap: Some(true),+ use_mlock: Some(false),+ })+ .map_err(crate::commands::llm::llm_api_error)?;+ check_cancelled()?;+ let threads = std::thread::available_parallelism()+ .map(|count| count.get().saturating_sub(1).max(1))+ .unwrap_or(1);+ let threads = i32::try_from(threads).unwrap_or(1);+ let context = llm::Context::new_knowledge_embedding(&model, Some(threads))+ .map_err(crate::commands::llm::llm_api_error)?;+ check_cancelled()?;+ let query_embedding = context+ .embed(query.trim())+ .map_err(crate::commands::llm::llm_api_error)?;+ check_cancelled()?;++ let indexes = indexes.lock().unwrap_or_else(PoisonError::into_inner);+ let mut hits = Vec::<retrieval::KnowledgePromptHit>::new();+ for dataset in &datasets {+ check_cancelled()?;+ let Some(open) = indexes.get(&dataset.stable_id) else {+ continue;+ };+ match open.index.search(+ &query_embedding,+ embedding.max_hits,+ dataset.relevance_threshold,+ ) {+ Ok(dataset_hits) => {+ hits.extend(dataset_hits.into_iter().map(|hit| {+ retrieval::KnowledgePromptHit {+ dataset_id: dataset.stable_id.clone(),+ hit,+ }+ }));+ }+ Err(error) => logging::log(+ "Knowledge",+ format!(+ "pack search skipped pack={} error={error}",+ dataset.stable_id+ ),+ ),+ }+ }+ drop(indexes);+ check_cancelled()?;++ hits.sort_by(|left, right| right.hit.score.total_cmp(&left.hit.score));+ hits.truncate(embedding.max_hits as usize);+ let budget = max_context_utf8_bytes.min(embedding.max_context_utf8_bytes) as usize;+ retrieval::build_knowledge_prompt_context(&hits, budget)+ .map(|context| context.map(Into::into))+ .map_err(retrieval_error)+ })+ .await+ .map_err(|_| ApiError::new("llm_thread", "Knowledge retrieval task failed"))?+}++pub(crate) fn clear_for_exit(app: &AppHandle) {+ let Some(state) = app.try_state::<State>() else {+ return;+ };+ for token in state+ .active_downloads+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .values()+ {+ token.cancel();+ }+ state+ .indexes+ .lock()+ .unwrap_or_else(PoisonError::into_inner)+ .clear();+}diff --git a/rust/apps/ensu/src-tauri/src/commands/llm.rs b/rust/apps/ensu/src-tauri/src/commands/llm.rsindex 55a90fb3ea..ea1fc3c30e 100644--- a/rust/apps/ensu/src-tauri/src/commands/llm.rs+++ b/rust/apps/ensu/src-tauri/src/commands/llm.rs@@ -1,5 +1,6 @@use std::panic::{AssertUnwindSafe, catch_unwind};use std::path::PathBuf;+use std::sync::atomic::{AtomicU64, Ordering};use std::sync::{Arc, Mutex, PoisonError};use std::time::{Duration, Instant};@@ -16,6 +17,27 @@ use crate::logging;pub struct State {model: Mutex<Option<llm::ModelRef>>,context: Mutex<Option<llm::ContextRef>>,+ lifecycle: async_runtime::Mutex<()>,+ retrieval_epoch: Arc<AtomicU64>,+}++impl State {+ pub(crate) fn lifecycle(&self) -> &async_runtime::Mutex<()> {+ &self.lifecycle+ }++ pub(crate) fn retrieval_epoch(&self) -> Arc<AtomicU64> {+ Arc::clone(&self.retrieval_epoch)+ }++ fn cancel_retrieval(&self) {+ self.retrieval_epoch.fetch_add(1, Ordering::Relaxed);+ }+}++#[tauri::command]+pub fn llm_retrieval_epoch(state: TauriState<'_, State>) -> u64 {+ state.retrieval_epoch.load(Ordering::Relaxed)}pub struct ModelDownloadState {@@ -35,6 +57,10 @@ impl ModelDownloadState {active_token: Mutex::new(None),}}++ pub(crate) fn store(&self) -> Arc<AssetStore> {+ Arc::clone(&self.store)+ }}#[derive(Debug, Serialize, Clone)]@@ -58,7 +84,7 @@ fn llm_error(message: impl Into<String>) -> ApiError {ApiError::new("llm", message)}-fn llm_api_error(err: llm::Error) -> ApiError {+pub(crate) fn llm_api_error(err: llm::Error) -> ApiError {let code = match &err {llm::Error::Cancelled => "cancelled",llm::Error::Panicked => "panicked",@@ -71,7 +97,7 @@ fn llm_api_error(err: llm::Error) -> ApiError {ApiError::new(code, err.to_string())}-fn download_code(err: &download::Error) -> &'static str {+pub(crate) fn download_code(err: &download::Error) -> &'static str {match err {download::Error::Cancelled => "cancelled",download::Error::Target { source, .. } => download_code(source),@@ -248,16 +274,31 @@ pub fn llm_model_status(model_id: String,) -> Result<ModelStatus, ApiError> {let asset = desktop_asset(&model_id)?;+ let embedding_asset = ente_ensu::model::knowledge_embedding_model_asset();Ok(ModelStatus {model_path: ente_ensu::model::llm_model_path(&state.store, &asset).map(|path| path.display().to_string()).unwrap_or_default(),mmproj_path: ente_ensu::model::llm_mmproj_path(&state.store, &asset).map(|path| path.display().to_string()),- downloaded: state.store.is_downloaded(&asset),+ downloaded: state.store.is_downloaded(&asset)+ && state.store.is_downloaded(&embedding_asset),})}+#[tauri::command]+pub async fn llm_model_download_size(+ state: TauriState<'_, ModelDownloadState>,+ model_id: String,+) -> Result<Option<u64>, ApiError> {+ let asset = desktop_asset(&model_id)?;+ let embedding_asset = ente_ensu::model::knowledge_embedding_model_asset();+ Ok(state+ .store+ .estimated_download_size(&[asset, embedding_asset])+ .await)+}+#[tauri::command]pub async fn llm_migrate_models(state: TauriState<'_, ModelDownloadState>,@@ -290,6 +331,7 @@ pub async fn llm_download_model() -> Result<(), ApiError> {let store = Arc::clone(&state.store);let asset = desktop_asset(&model_id)?;+ let embedding_asset = ente_ensu::model::knowledge_embedding_model_asset();let token = {let mut slot = state.active_token@@ -307,7 +349,7 @@ pub async fn llm_download_model(};let result = store.download(- std::slice::from_ref(&asset),+ &[asset, embedding_asset],|progress| {let display = ente_ensu::model::display_progress(&progress);if let Some(line) = &display.log_line {@@ -374,6 +416,7 @@ pub async fn llm_load_model(state: TauriState<'_, State>,params: llm::ModelLoadParams,) -> Result<(), ApiError> {+ let _lifecycle = state.lifecycle.lock().await;logging::log("LLM",format!("load model requested model_path={}", params.model_path),@@ -413,6 +456,7 @@ pub async fn llm_create_context(state: TauriState<'_, State>,params: llm::ContextParams,) -> Result<(), ApiError> {+ let _lifecycle = state.lifecycle.lock().await;let model = state.model.lock()@@ -462,7 +506,8 @@ pub async fn llm_create_context(}#[tauri::command]-pub fn llm_free_context(state: TauriState<State>) -> Result<(), ApiError> {+pub async fn llm_free_context(state: TauriState<'_, State>) -> Result<(), ApiError> {+ let _lifecycle = state.lifecycle.lock().await;let mut context_guard = state.context.lock()@@ -472,7 +517,8 @@ pub fn llm_free_context(state: TauriState<State>) -> Result<(), ApiError> {}#[tauri::command]-pub fn llm_free_model(state: TauriState<State>) -> Result<(), ApiError> {+pub async fn llm_free_model(state: TauriState<'_, State>) -> Result<(), ApiError> {+ let _lifecycle = state.lifecycle.lock().await;replace_state(&state, None, None)}@@ -482,6 +528,7 @@ pub async fn llm_prewarm_multimodal_context(mmproj_path: String,media_marker: Option<String>,) -> Result<(), ApiError> {+ let _lifecycle = state.lifecycle.lock().await;let context = state.context.lock()@@ -523,6 +570,7 @@ pub async fn llm_generate_chat_stream(window: WebviewWindow,request: llm::ChatRequest,) -> Result<llm::GenerationSummary, ApiError> {+ let _lifecycle = state.lifecycle.lock().await;let context = state.context.lock()@@ -549,12 +597,18 @@ pub async fn llm_generate_chat_stream(}#[tauri::command]-pub fn llm_cancel(job_id: i64) {+pub async fn llm_cancel(state: TauriState<'_, State>, job_id: i64) -> Result<(), ApiError> {+ if job_id <= 0 {+ state.cancel_retrieval();+ }llm::cancel(job_id);+ let _lifecycle = state.lifecycle.lock().await;+ Ok(())}pub(crate) fn clear_for_exit(app: &AppHandle) {if let Some(state) = app.try_state::<State>() {+ state.cancel_retrieval();match replace_state(&state, None, None) {Ok(()) => {logging::log("App", "cleared LLM model");diff --git a/rust/apps/ensu/src-tauri/src/commands/mod.rs b/rust/apps/ensu/src-tauri/src/commands/mod.rsindex 84740e7464..4fcf29b85a 100644--- a/rust/apps/ensu/src-tauri/src/commands/mod.rs+++ b/rust/apps/ensu/src-tauri/src/commands/mod.rs@@ -3,6 +3,7 @@ mod chat_db_migration;mod common;pub(crate) mod config;pub(crate) mod crypto;+pub(crate) mod knowledge;pub(crate) mod llm;pub(crate) mod secure_storage;pub(crate) mod system;@@ -14,6 +15,7 @@ use crate::logging;pub fn cleanup_for_exit(app: &AppHandle) {logging::log("App", "cleanup_for_exit start");llm::clear_for_exit(app);+ knowledge::clear_for_exit(app);chat_db::clear_for_exit(app);logging::log("App", "cleanup_for_exit complete");}diff --git a/rust/apps/ensu/src-tauri/src/main.rs b/rust/apps/ensu/src-tauri/src/main.rsindex ac037e0e85..f83ac2aa53 100644--- a/rust/apps/ensu/src-tauri/src/main.rs+++ b/rust/apps/ensu/src-tauri/src/main.rs@@ -17,6 +17,7 @@ fn main() {.plugin(tauri_plugin_updater::Builder::new().build()).manage(commands::llm::State::default()).manage(commands::chat_db::ChatDbState::default())+ .manage(commands::knowledge::State::default()).setup(|app| {logging::init_logging(app.handle());logging::log("App", "setup started");@@ -67,12 +68,18 @@ fn main() {commands::llm::llm_prewarm_multimodal_context,commands::llm::llm_generate_chat_stream,commands::llm::llm_cancel,+ commands::llm::llm_retrieval_epoch,commands::system::system_info,commands::config::desktop_model_policy,commands::llm::llm_model_status,+ commands::llm::llm_model_download_size,commands::llm::llm_migrate_models,commands::llm::llm_download_model,commands::llm::llm_cancel_model_download,+ commands::knowledge::knowledge_catalog,+ commands::knowledge::knowledge_download_pack,+ commands::knowledge::knowledge_cancel_pack_download,+ commands::knowledge::knowledge_retrieve,]).build(tauri::generate_context!()).unwrap_or_else(|err| {diff --git a/web/apps/ensu/src/components/chat/ChatComposer.tsx b/web/apps/ensu/src/components/chat/ChatComposer.tsxindex 5629e76ebb..a307776b6e 100644--- a/web/apps/ensu/src/components/chat/ChatComposer.tsx+++ b/web/apps/ensu/src/components/chat/ChatComposer.tsx@@ -334,18 +334,23 @@ export const ChatComposer = memo(variant="contained"color="accent"disabled={- modelGateStatus ===- "downloading" ||- isDownloading+ modelGateStatus !== "missing" &&+ modelGateStatus !== "error"}onClick={() =>void handleDownloadModel()}>- {modelGateStatus ===- "downloading" || isDownloading- ? "Downloading..."- : "Download"}+ {modelGateStatus === "checking"+ ? "Checking..."+ : modelGateStatus ===+ "preloading" ||+ modelGateStatus ===+ "downloading"+ ? "Loading..."+ : modelGateStatus === "error"+ ? "Retry"+ : "Download"}</Button></Stack></Stack>diff --git a/web/apps/ensu/src/components/chat/ChatDialogs.tsx b/web/apps/ensu/src/components/chat/ChatDialogs.tsxindex 8145105571..93407d2110 100644--- a/web/apps/ensu/src/components/chat/ChatDialogs.tsx+++ b/web/apps/ensu/src/components/chat/ChatDialogs.tsx@@ -1,10 +1,13 @@+import type { KnowledgePack } from "@/services/knowledge";import { isTauriRuntime as detectTauriAppRuntime } from "@/services/tauri-runtime";import {+ ArrowLeft01Icon,ArrowRight01Icon,Bug01Icon,Cancel01Icon,File01Icon,InformationCircleIcon,+ PackageIcon,Settings01Icon,SlidersHorizontalIcon,Upload01Icon,@@ -18,10 +21,14 @@ import {DialogActions,DialogContent,DialogTitle,+ Divider,IconButton,+ LinearProgress,+ Link,ListItemButton,MenuItem,Stack,+ Switch,TextField,Typography,} from "@mui/material";@@ -52,6 +59,29 @@ type ModelGateStatus =type SxEntry = Exclude<SxProps<Theme>, readonly unknown[]>;+const formatBytes = (bytes: number) => {+ const units = ["B", "KB", "MB", "GB"];+ let value = Math.max(0, bytes);+ let unit = 0;+ while (value >= 1024 && unit < units.length - 1) {+ value /= 1024;+ unit += 1;+ }+ return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;+};++const compactInlineLinkSx = {+ border: 0,+ p: 0,+ bgcolor: "transparent",+ fontFamily: "inherit",+ fontSize: "12px",+ lineHeight: "15px",+ fontWeight: 500,+ color: "accent.main",+ cursor: "pointer",+} as const;+export interface ModelSettingsDraft {modelId: string;contextLength: string;@@ -60,13 +90,16 @@ export interface ModelSettingsDraft {export interface ChatDialogsProps {showSettingsModal: boolean;+ openSettingsModal: () => void;closeSettingsModal: () => void;dialogPaperSx: SxEntry;dialogTitleSx: SxEntry;actionButtonSx: SxEntry;+ drawerIconButtonSx: SxEntry;settingsItemSx: SxEntry;smallIconProps: IconProps;compactIconProps: IconProps;+ tinyIconProps: IconProps;saveLogs: () => void | Promise<void>;handleCheckForUpdates: () => void | Promise<void>;advancedUnlocked: boolean;@@ -101,6 +134,16 @@ export interface ChatDialogsProps {systemPrompt: string;handleSaveSystemPrompt: (promptText: string) => void;handleUseDefaultSystemPrompt: () => void;+ knowledgePacks: KnowledgePack[];+ knowledgeCatalogLoading: boolean;+ knowledgeCatalogError: string | null;+ retryKnowledgeCatalog: () => void;+ enabledKnowledgePackIds: Set<string>;+ knowledgeDownloadProgress: Record<string, number | undefined>;+ knowledgeErrors: Record<string, string | undefined>;+ handleDownloadKnowledgePack: (stableId: string) => void;+ handleCancelKnowledgePackDownload: (stableId: string) => void;+ handleSetKnowledgePackEnabled: (stableId: string, enabled: boolean) => void;chatNotificationOpen: boolean;setChatNotificationOpen: React.Dispatch<React.SetStateAction<boolean>>;chatNotification?: NotificationAttributes;@@ -112,13 +155,16 @@ export interface ChatDialogsProps {export const ChatDialogs = memo(({showSettingsModal,+ openSettingsModal,closeSettingsModal,dialogPaperSx,dialogTitleSx,actionButtonSx,+ drawerIconButtonSx,settingsItemSx,smallIconProps,compactIconProps,+ tinyIconProps,saveLogs,handleCheckForUpdates,advancedUnlocked,@@ -153,6 +199,16 @@ export const ChatDialogs = memo(systemPrompt,handleSaveSystemPrompt,handleUseDefaultSystemPrompt,+ knowledgePacks,+ knowledgeCatalogLoading,+ knowledgeCatalogError,+ retryKnowledgeCatalog,+ enabledKnowledgePackIds,+ knowledgeDownloadProgress,+ knowledgeErrors,+ handleDownloadKnowledgePack,+ handleCancelKnowledgePackDownload,+ handleSetKnowledgePackEnabled,chatNotificationOpen,setChatNotificationOpen,chatNotification,@@ -182,6 +238,10 @@ export const ChatDialogs = memo(const [draftContextLength, setDraftContextLength] = React.useState("");const [draftMaxTokens, setDraftMaxTokens] = React.useState("");+ const isModelPreparationActive =+ modelGateStatus === "checking" ||+ modelGateStatus === "preloading" ||+ modelGateStatus === "downloading";const [draftContextError, setDraftContextError] = React.useState<string | null>(null);@@ -193,6 +253,15 @@ export const ChatDialogs = memo(const [draftModelId, setDraftModelId] = React.useState("default");const [showBackupComingSoon, setShowBackupComingSoon] =React.useState(false);+ const [showKnowledgeSettings, setShowKnowledgeSettings] =+ React.useState(false);+ const [attributionPack, setAttributionPack] =+ React.useState<KnowledgePack | null>(null);++ const returnToSettings = () => {+ setShowKnowledgeSettings(false);+ openSettingsModal();+ };const [draftSystemPrompt, setDraftSystemPrompt] = React.useState("");const wasSystemPromptSettingsOpen = React.useRef(false);@@ -320,20 +389,23 @@ export const ChatDialogs = memo(<IconButtonaria-label="Close image preview"onClick={closeImagePreview}- sx={{- position: "absolute",- top: { xs: 12, sm: 16 },- right: { xs: 12, sm: 16 },- width: 36,- height: 36,- color: "common.white",- bgcolor: "rgba(0, 0, 0, 0.38)",- "&:hover": { bgcolor: "rgba(0, 0, 0, 0.54)" },- }}+ sx={[+ drawerIconButtonSx,+ {+ position: "absolute",+ top: { xs: 12, sm: 16 },+ right: { xs: 12, sm: 16 },+ color: "common.white",+ bgcolor: "rgba(0, 0, 0, 0.38)",+ "&:hover": {+ bgcolor: "rgba(0, 0, 0, 0.54)",+ },+ },+ ]}><HugeiconsIconicon={Cancel01Icon}- {...smallIconProps}+ {...tinyIconProps}/></IconButton></DialogContent>@@ -366,7 +438,9 @@ export const ChatDialogs = memo(alignItems: "center",justifyContent: "space-between",gap: 1,- pr: 1,+ px: 3,+ py: 1.5,+ pr: 1.5,},]}>@@ -374,11 +448,11 @@ export const ChatDialogs = memo(<IconButtonaria-label="Close settings"onClick={closeSettingsModal}- sx={actionButtonSx}+ sx={drawerIconButtonSx}><HugeiconsIconicon={Cancel01Icon}- {...smallIconProps}+ {...tinyIconProps}/></IconButton></DialogTitle>@@ -410,6 +484,31 @@ export const ChatDialogs = memo(/></ListItemButton>+ {isTauriRuntime && (+ <ListItemButton+ onClick={() => {+ closeSettingsModal();+ setShowKnowledgeSettings(true);+ }}+ sx={settingsItemSx}+ >+ <HugeiconsIcon+ icon={PackageIcon}+ {...compactIconProps}+ />+ <Typography+ variant="small"+ sx={{ flex: 1 }}+ >+ Ensu Packs+ </Typography>+ <HugeiconsIcon+ icon={ArrowRight01Icon}+ {...smallIconProps}+ />+ </ListItemButton>+ )}+{isTauriRuntime && (<ListItemButtononClick={() => {@@ -613,6 +712,343 @@ export const ChatDialogs = memo(</DialogContent></Dialog>+ <Dialog+ open={showKnowledgeSettings}+ onClose={returnToSettings}+ fullScreen={isSmall}+ maxWidth="sm"+ fullWidth+ slotProps={{ paper: { sx: dialogPaperSx } }}+ >+ <DialogTitle+ sx={[+ dialogTitleSx,+ {+ display: "flex",+ alignItems: "center",+ gap: 1,+ pl: 1,+ },+ ]}+ >+ <IconButton+ aria-label="Back to settings"+ onClick={returnToSettings}+ sx={drawerIconButtonSx}+ >+ <HugeiconsIcon+ icon={ArrowLeft01Icon}+ {...tinyIconProps}+ />+ </IconButton>+ <Box component="span">Ensu Packs</Box>+ </DialogTitle>+ <DialogContent>+ <Stack sx={{ gap: 2 }}>+ {knowledgeCatalogError && (+ <Stack+ direction="row"+ sx={{ alignItems: "center", gap: 1 }}+ >+ <Typography+ variant="small"+ sx={{ flex: 1, color: "critical.main" }}+ >+ {knowledgeCatalogError}+ </Typography>+ <Button+ size="small"+ onClick={retryKnowledgeCatalog}+ >+ Retry+ </Button>+ </Stack>+ )}+ {knowledgeCatalogLoading &&+ knowledgePacks.length === 0 && (+ <LinearProgress />+ )}+ {knowledgePacks.map((pack) => {+ const progress =+ knowledgeDownloadProgress[pack.stableId];+ const installed = pack.status !== "download";+ const isMutating = progress !== undefined;+ const enabled =+ enabledKnowledgePackIds.has(+ pack.stableId,+ ) && installed;+ return (+ <Stack+ key={pack.stableId}+ sx={{+ gap: 1.5,+ p: 2,+ borderRadius: 2,+ bgcolor: "fill.faint",+ }}+ >+ <Stack+ direction="row"+ sx={{+ alignItems: "center",+ gap: 1.5,+ }}+ >+ <Stack sx={{ flex: 1, gap: 0.5 }}>+ <Typography variant="h6">+ {pack.label}+ </Typography>+ <Stack+ direction="row"+ sx={{+ alignItems: "center",+ gap: 0.75,+ }}+ >+ <Typography+ variant="mini"+ sx={{+ color: "text.muted",+ }}+ >+ {formatBytes(+ pack.downloadSizeBytes,+ )}+ </Typography>+ <Typography+ variant="mini"+ sx={{+ color: "text.muted",+ }}+ >+ Β·+ </Typography>+ <Link+ component="button"+ type="button"+ underline="hover"+ onClick={() =>+ setAttributionPack(+ pack,+ )+ }+ sx={compactInlineLinkSx}+ >+ {+ pack.attribution+ .licenseLabel+ }+ </Link>+ </Stack>+ </Stack>+ {installed && !isMutating ? (+ <Switch+ checked={enabled}+ disabled={+ knowledgeCatalogLoading+ }+ onChange={(_, checked) =>+ handleSetKnowledgePackEnabled(+ pack.stableId,+ checked,+ )+ }+ slotProps={{+ input: {+ "aria-label": `Enable ${pack.label}`,+ },+ }}+ />+ ) : pack.status === "download" &&+ !isMutating ? (+ <Button+ variant="contained"+ color="accent"+ size="small"+ disabled={+ knowledgeCatalogLoading+ }+ onClick={() =>+ handleDownloadKnowledgePack(+ pack.stableId,+ )+ }+ >+ Download+ </Button>+ ) : null}+ </Stack>++ {isMutating && (+ <Stack+ direction="row"+ sx={{+ alignItems: "center",+ gap: 1,+ }}+ >+ <LinearProgress+ variant="determinate"+ value={Math.max(+ 0,+ Math.min(100, progress),+ )}+ sx={{ flex: 1 }}+ />+ <IconButton+ aria-label={`Cancel ${pack.label} download`}+ onClick={() =>+ handleCancelKnowledgePackDownload(+ pack.stableId,+ )+ }+ sx={actionButtonSx}+ >+ <HugeiconsIcon+ icon={Cancel01Icon}+ {...compactIconProps}+ />+ </IconButton>+ </Stack>+ )}++ {!isMutating &&+ pack.status ===+ "updateAvailable" && (+ <Button+ variant="contained"+ color="accent"+ size="small"+ disabled={+ knowledgeCatalogLoading+ }+ sx={{+ alignSelf: "flex-start",+ }}+ onClick={() =>+ handleDownloadKnowledgePack(+ pack.stableId,+ )+ }+ >+ Update+ </Button>+ )}++ {knowledgeErrors[pack.stableId] && (+ <Typography+ variant="small"+ sx={{ color: "critical.main" }}+ >+ {knowledgeErrors[pack.stableId]}+ </Typography>+ )}+ </Stack>+ );+ })}+ </Stack>+ </DialogContent>+ </Dialog>++ <Dialog+ open={Boolean(attributionPack)}+ onClose={() => setAttributionPack(null)}+ maxWidth="xs"+ fullWidth+ slotProps={{ paper: { sx: dialogPaperSx } }}+ >+ <DialogTitle+ sx={[+ dialogTitleSx,+ {+ display: "flex",+ alignItems: "center",+ justifyContent: "space-between",+ gap: 1,+ px: 3,+ py: 1.5,+ pr: 1.5,+ },+ ]}+ >+ <Box component="span">{attributionPack?.label}</Box>+ <IconButton+ aria-label="Close pack details"+ onClick={() => setAttributionPack(null)}+ sx={drawerIconButtonSx}+ >+ <HugeiconsIcon+ icon={Cancel01Icon}+ {...tinyIconProps}+ />+ </IconButton>+ </DialogTitle>+ <DialogContent sx={{ px: 3, pt: 1, pb: 3 }}>+ {attributionPack && (+ <Stack+ sx={{+ gap: 1.25,+ p: 2,+ borderRadius: 1.5,+ bgcolor: "fill.faint",+ }}+ >+ <Typography variant="small">+ From {attributionPack.attribution.credit}+ </Typography>+ <Typography variant="small">+ {+ attributionPack.attribution+ .modificationNotice+ }+ </Typography>+ <Stack+ direction="row"+ sx={{ gap: 2, flexWrap: "wrap" }}+ >+ <Link+ component="button"+ type="button"+ underline="hover"+ onClick={() =>+ void openExternalUrl(+ attributionPack.attribution+ .publicPackUrl,+ )+ }+ sx={compactInlineLinkSx}+ >+ Source β+ </Link>+ <Link+ component="button"+ type="button"+ underline="hover"+ onClick={() =>+ void openExternalUrl(+ attributionPack.attribution+ .licenseUrl,+ )+ }+ sx={compactInlineLinkSx}+ >+ License β+ </Link>+ </Stack>+ <Divider sx={{ my: 0.25 }} />+ <Typography+ variant="small"+ sx={{ color: "text.muted" }}+ >+ Wikimedia and Ensu are not affiliated.+ Wikimedia project names identify the source+ material only.+ </Typography>+ </Stack>+ )}+ </DialogContent>+ </Dialog>+<Dialogopen={showBackupComingSoon}onClose={() => setShowBackupComingSoon(false)}@@ -837,7 +1273,7 @@ export const ChatDialogs = memo(color="accent"disabled={isSavingModel ||- modelGateStatus === "downloading"+ isModelPreparationActive}onClick={() => {if (!validateModelSettings()) return;@@ -856,6 +1292,7 @@ export const ChatDialogs = memo(<ButtononClick={handleUseDefaultModel}color="secondary"+ disabled={isModelPreparationActive}>Reset to defaults</Button>diff --git a/web/apps/ensu/src/components/chat/ChatMessageList.tsx b/web/apps/ensu/src/components/chat/ChatMessageList.tsxindex 2927db10d9..d13dc20422 100644--- a/web/apps/ensu/src/components/chat/ChatMessageList.tsx+++ b/web/apps/ensu/src/components/chat/ChatMessageList.tsx@@ -5,16 +5,29 @@ import {type BranchSwitcher,} from "@/services/chat/branching";import type { ChatAttachment, ChatMessage } from "@/services/chat/store";+import { isTauriRuntime } from "@/services/tauri-runtime";import {ArrowLeft01Icon,ArrowRight01Icon,Attachment01Icon,+ Cancel01Icon,Copy01Icon,Edit01Icon,RepeatIcon,} from "@hugeicons/core-free-icons";import { HugeiconsIcon } from "@hugeicons/react";-import { Box, IconButton, Stack, Typography } from "@mui/material";+import {+ Box,+ Chip,+ Dialog,+ DialogContent,+ DialogTitle,+ Divider,+ IconButton,+ Link,+ Stack,+ Typography,+} from "@mui/material";import type { SxProps, Theme } from "@mui/material/styles";import type { SystemStyleObject } from "@mui/system";import React, { memo, useCallback, useEffect, useMemo, useState } from "react";@@ -31,6 +44,35 @@ interface IconProps {strokeWidth: number;}+const openExternalUrl = async (url: string) => {+ if (isTauriRuntime()) {+ const opened = await import("@tauri-apps/plugin-opener")+ .then(async ({ openUrl }) => {+ await openUrl(url);+ return true;+ })+ .catch(() => false);+ if (opened) return;+ }++ if (typeof window !== "undefined") {+ const popup = window.open(url, "_blank", "noopener,noreferrer");+ if (!popup) window.location.href = url;+ }+};++const sourceLinkSx = {+ border: 0,+ p: 0,+ bgcolor: "transparent",+ fontFamily: "inherit",+ fontSize: "12px",+ lineHeight: "15px",+ fontWeight: 500,+ color: "accent.main",+ cursor: "pointer",+} as const;+export interface ParsedDocuments {text: string;documents: DocumentAttachment[];@@ -69,6 +111,9 @@ export interface ChatMessageListProps {assistantMarkdownSx: SxProps<Theme>;streamingMessageSx: SystemStyleObject<Theme>;actionButtonSx: SxProps<Theme>;+ dialogTitleSx: SystemStyleObject<Theme>;+ dialogCloseButtonSx: SystemStyleObject<Theme>;+ dialogCloseIconProps: IconProps;smallIconProps: IconProps;actionIconProps: IconProps;}@@ -171,6 +216,116 @@ const AiSafetyFooter = memo(() => {);});+const KnowledgeSourcesDialog = memo(+ ({+ citations,+ onClose,+ dialogTitleSx,+ closeButtonSx,+ closeIconProps,+ }: {+ citations: NonNullable<ChatMessage["citations"]>;+ onClose: () => void;+ dialogTitleSx: SystemStyleObject<Theme>;+ closeButtonSx: SystemStyleObject<Theme>;+ closeIconProps: IconProps;+ }) => (+ <Dialog+ open+ onClose={onClose}+ fullWidth+ maxWidth="sm"+ slotProps={{ paper: { sx: { borderRadius: 3 } } }}+ >+ <DialogTitle+ sx={[+ dialogTitleSx,+ {+ display: "flex",+ alignItems: "center",+ justifyContent: "space-between",+ gap: 1,+ px: 3,+ py: 1.5,+ pr: 1.5,+ },+ ]}+ >+ <Box component="span">Sources</Box>+ <IconButton+ aria-label="Close sources"+ onClick={onClose}+ sx={closeButtonSx}+ >+ <HugeiconsIcon icon={Cancel01Icon} {...closeIconProps} />+ </IconButton>+ </DialogTitle>+ <DialogContent sx={{ px: 3, pt: 1, pb: 3 }}>+ <Stack sx={{ gap: 1.5 }}>+ {citations.map((citation, index) => (+ <Stack+ key={`${citation.datasetId}:${citation.sourceUrl}:${index}`}+ sx={{+ gap: 1.25,+ p: 2,+ borderRadius: 1.5,+ bgcolor: "fill.faint",+ }}+ >+ <Typography+ variant="mini"+ sx={{ color: "text.muted" }}+ >+ SOURCE {index + 1} Β·{" "}+ {citation.datasetLabel.toUpperCase()}+ </Typography>+ <Typography variant="h6">+ {citation.title}+ </Typography>+ <Divider sx={{ my: 0.25 }} />+ <Typography+ variant="small"+ sx={{ color: "text.muted" }}+ >+ {citation.credit}+ </Typography>+ <Stack+ direction="row"+ sx={{ gap: 2, flexWrap: "wrap" }}+ >+ <Link+ component="button"+ type="button"+ underline="hover"+ onClick={() =>+ void openExternalUrl(citation.sourceUrl)+ }+ sx={sourceLinkSx}+ >+ Open source β+ </Link>+ <Link+ component="button"+ type="button"+ underline="hover"+ onClick={() =>+ void openExternalUrl(+ citation.licenseUrl,+ )+ }+ sx={sourceLinkSx}+ >+ {citation.licenseLabel} β+ </Link>+ </Stack>+ </Stack>+ ))}+ </Stack>+ </DialogContent>+ </Dialog>+ ),+);+interface MessageRowProps {message: ChatMessage;isLastMessage: boolean;@@ -198,6 +353,9 @@ interface MessageRowProps {assistantMarkdownSx: SxProps<Theme>;streamingMessageSx: SystemStyleObject<Theme>;actionButtonSx: SxProps<Theme>;+ dialogTitleSx: SystemStyleObject<Theme>;+ dialogCloseButtonSx: SystemStyleObject<Theme>;+ dialogCloseIconProps: IconProps;smallIconProps: IconProps;actionIconProps: IconProps;}@@ -227,12 +385,17 @@ const MessageRow = memo(assistantMarkdownSx,streamingMessageSx,actionButtonSx,+ dialogTitleSx,+ dialogCloseButtonSx,+ dialogCloseIconProps,smallIconProps,actionIconProps,}: MessageRowProps) => {const isSelf = message.sender === "self";const isStreaming = message.messageUuid === STREAMING_SELECTION_KEY;const isSynthetic = !!message.isSynthetic;+ const citations = message.citations ?? [];+ const [showSources, setShowSources] = useState(false);const switcher = branchSwitchers[message.messageUuid];const showSwitcher = !isSynthetic && !!switcher && switcher.total > 1;const timestamp = formatTime(message.createdAt);@@ -390,12 +553,52 @@ const MessageRow = memo(/></Stack>) : (- <Box sx={assistantMarkdownSx}>- <MarkdownRenderer- content={displayText}- className="markdown-content"- />- </Box>+ <Stack+ sx={{ gap: 1, alignItems: "flex-start" }}+ >+ <Box sx={assistantMarkdownSx}>+ <MarkdownRenderer+ content={displayText}+ className="markdown-content"+ />+ </Box>+ {message.sourceLabel && (+ <Chip+ size="small"+ label={message.sourceLabel}+ onClick={() => setShowSources(true)}+ sx={{+ height: 25,+ borderRadius: 1,+ bgcolor: "fill.faintHover",+ color: "text.base",+ fontSize: "12px",+ lineHeight: "15px",+ fontWeight: 500,+ cursor: "pointer",+ "& .MuiChip-label": {+ px: 1.25,+ },+ "&:hover": {+ bgcolor: "fill.muted",+ },+ }}+ />+ )}+ {showSources && (+ <KnowledgeSourcesDialog+ citations={citations}+ onClose={() =>+ setShowSources(false)+ }+ dialogTitleSx={dialogTitleSx}+ closeButtonSx={dialogCloseButtonSx}+ closeIconProps={+ dialogCloseIconProps+ }+ />+ )}+ </Stack>)}</Box>)}@@ -640,6 +843,9 @@ export const ChatMessageList = memo(assistantMarkdownSx,streamingMessageSx,actionButtonSx,+ dialogTitleSx,+ dialogCloseButtonSx,+ dialogCloseIconProps,smallIconProps,actionIconProps,}: ChatMessageListProps) => {@@ -700,6 +906,9 @@ export const ChatMessageList = memo(assistantMarkdownSx={assistantMarkdownSx}streamingMessageSx={streamingMessageSx}actionButtonSx={actionButtonSx}+ dialogTitleSx={dialogTitleSx}+ dialogCloseButtonSx={dialogCloseButtonSx}+ dialogCloseIconProps={dialogCloseIconProps}smallIconProps={smallIconProps}actionIconProps={actionIconProps}/>@@ -711,6 +920,9 @@ export const ChatMessageList = memo(assistantMarkdownSx,attachmentPreviews,branchSwitchers,+ dialogCloseButtonSx,+ dialogCloseIconProps,+ dialogTitleSx,formatTime,isGenerating,isStreamingOutro,diff --git a/web/apps/ensu/src/pages/chat.tsx b/web/apps/ensu/src/pages/chat.tsxindex 956d8036a2..c930c1a51d 100644--- a/web/apps/ensu/src/pages/chat.tsx+++ b/web/apps/ensu/src/pages/chat.tsx@@ -33,6 +33,17 @@ import {type ChatMessage,type ChatSession,} from "@/services/chat/store";+import {+ cancelKnowledgePackDownload,+ downloadKnowledgePack,+ knowledgeErrorMessage,+ loadEnabledKnowledgePacks,+ loadKnowledgeCatalog,+ retrieveKnowledge,+ saveEnabledKnowledgePacks,+ type KnowledgePack,+ type SourceCitation,+} from "@/services/knowledge";import {DEFAULT_MODEL,FALLBACK_DESKTOP_MODEL_PRESETS,@@ -594,6 +605,21 @@ const Page: React.FC = () => {const [showModelSettings, setShowModelSettings] = useState(false);const [showSystemPromptSettings, setShowSystemPromptSettings] =useState(false);+ const [knowledgePacks, setKnowledgePacks] = useState<KnowledgePack[]>([]);+ const [knowledgeCatalogLoading, setKnowledgeCatalogLoading] =+ useState(false);+ const [knowledgeCatalogError, setKnowledgeCatalogError] = useState<+ string | null+ >(null);+ const [enabledKnowledgePackIds, setEnabledKnowledgePackIds] = useState(+ loadEnabledKnowledgePacks,+ );+ const [knowledgeDownloadProgress, setKnowledgeDownloadProgress] = useState<+ Record<string, number | undefined>+ >({});+ const [knowledgeErrors, setKnowledgeErrors] = useState<+ Record<string, string | undefined>+ >({});const [modelSettingsLoaded, setModelSettingsLoaded] = useState(false);const [resolvedDefaultModel, setResolvedDefaultModel] =@@ -642,6 +668,9 @@ const Page: React.FC = () => {} | null>(null);const [downloadStatus, setDownloadStatus] =useState<DownloadProgress | null>(null);+ const [modelDownloadSizeBytes, setModelDownloadSizeBytes] = useState<+ number | null+ >(null);const [loadedModelName, setLoadedModelName] = useState<string | null>(null);const [modelGateStatus, setModelGateStatus] = useState<| "checking"@@ -657,19 +686,41 @@ const Page: React.FC = () => {const [renameSessionTitle, setRenameSessionTitle] = useState("");const [deleteSessionId, setDeleteSessionId] = useState<string | null>(null);- const allowMmproj = isTauriRuntime;-const providerRef = useRef<LlmProvider | null>(null);const currentJobIdRef = useRef<number | null>(null);+ const activeKnowledgeCitationsRef = useRef<SourceCitation[]>([]);+ const knowledgeCatalogPromiseRef = useRef<Promise<KnowledgePack[]> | null>(+ null,+ );+ const generationStartingRef = useRef(false);+ const generationStoppingRef = useRef(false);+ const pendingGenerationStopsRef = useRef(0);+ const modelGateRequestRef = useRef(0);const generationTokenRef = useRef(0);const lastGenerationRef = useRef<{parentMessageUuid: string;previousSelection?: string | null;} | null>(null);- const sessionSummaryInFlightRef = useRef(false);+ const sessionSummaryPromiseRef = useRef<Promise<void> | null>(null);+ const sessionSummaryEpochRef = useRef(0);const manuallyRenamedSessionIdsRef = useRef(new Set<string>());const pendingSessionRenamesRef = useRef(new Set<string>());const sessionTitleUpdatesRef = useRef(new Map<string, Promise<void>>());++ const beginGenerationStop = useCallback(() => {+ pendingGenerationStopsRef.current += 1;+ generationStoppingRef.current = true;+ }, []);++ const endGenerationStop = useCallback(() => {+ pendingGenerationStopsRef.current = Math.max(+ 0,+ pendingGenerationStopsRef.current - 1,+ );+ if (pendingGenerationStopsRef.current === 0) {+ generationStoppingRef.current = false;+ }+ }, []);const inputRef = useRef<HTMLTextAreaElement | null>(null);const attachmentPreviewUrlsRef = useRef<Record<string, string>>({});const pendingPreviewUrlsRef = useRef<Record<string, string>>({});@@ -718,6 +769,31 @@ const Page: React.FC = () => {[],);+ const loadKnowledgeCatalogOnce = useCallback(() => {+ if (!knowledgeCatalogPromiseRef.current) {+ knowledgeCatalogPromiseRef.current = loadKnowledgeCatalog().finally(+ () => {+ knowledgeCatalogPromiseRef.current = null;+ },+ );+ }+ return knowledgeCatalogPromiseRef.current;+ }, []);++ const refreshKnowledgeCatalog = useCallback(async () => {+ if (!isTauriRuntime) return;+ setKnowledgeCatalogLoading(true);+ setKnowledgeCatalogError(null);+ try {+ setKnowledgePacks(await loadKnowledgeCatalogOnce());+ } catch (error) {+ setKnowledgeCatalogError(knowledgeErrorMessage(error));+ log.error("Failed to refresh Ensu Packs", error);+ } finally {+ setKnowledgeCatalogLoading(false);+ }+ }, [isTauriRuntime, loadKnowledgeCatalogOnce]);+const sessionFromQuery = useMemo(() => {if (!router.isReady) return undefined;const value = router.query.session;@@ -904,6 +980,11 @@ const Page: React.FC = () => {setIsTauriRuntime(detectTauriRuntime());}, []);+ useEffect(() => {+ if (!isTauriRuntime) return;+ void refreshKnowledgeCatalog();+ }, [isTauriRuntime, refreshKnowledgeCatalog]);+useEffect(() => {if (typeof window === "undefined") return;let raf1 = 0;@@ -1349,6 +1430,43 @@ const Page: React.FC = () => {void refreshSessions();}, [chatKey, isChatStoreBridgeReady, refreshSessions]);+ const cancelActiveGenerationForNavigation = useCallback(() => {+ if (!isGenerating && !generationStartingRef.current) return;++ generationTokenRef.current += 1;+ beginGenerationStop();+ const jobId = currentJobIdRef.current;+ currentJobIdRef.current = null;+ activeKnowledgeCitationsRef.current = [];+ setIsGenerating(false);+ setIsStreamingOutro(false);+ setIsDownloading(false);+ setDownloadStatus(null);+ setStreamingParentId(null);+ setStreamingText("");+ streamingBufferRef.current = "";+ streamingChunksRef.current = [];+ streamingCreatedAtRef.current = null;+ lastGenerationRef.current = null;++ const provider = providerRef.current;+ if (!provider) {+ endGenerationStop();+ return;+ }+ void provider+ .cancelGeneration(jobId ?? -1)+ .catch((error: unknown) => {+ log.error(+ "Failed to cancel generation during navigation",+ error,+ );+ })+ .finally(() => {+ endGenerationStop();+ });+ }, [beginGenerationStop, endGenerationStop, isGenerating]);+useEffect(() => {currentSessionIdRef.current = currentSessionId;void refreshMessages();@@ -1361,9 +1479,16 @@ const Page: React.FC = () => {sessionFromQuery !== currentSessionId &&sessions.some((session) => session.sessionUuid === sessionFromQuery)) {+ cancelActiveGenerationForNavigation();setCurrentSessionId(sessionFromQuery);}- }, [currentSessionId, isDraftSession, sessionFromQuery, sessions]);+ }, [+ cancelActiveGenerationForNavigation,+ currentSessionId,+ isDraftSession,+ sessionFromQuery,+ sessions,+ ]);useEffect(() => {setStreamingParentId(null);@@ -1616,25 +1741,34 @@ const Page: React.FC = () => {const showImageAttachment = isTauriRuntime;const showDownloadProgress =!!downloadStatus?.status && downloadStatus.status !== "Ready";- const showModelGate =- modelGateStatus === "missing" ||- modelGateStatus === "error" ||- modelGateStatus === "downloading";+ const showModelGate = isTauriRuntime+ ? modelGateStatus !== "ready"+ : modelGateStatus === "missing" ||+ modelGateStatus === "error" ||+ modelGateStatus === "downloading";+ const hideMessagesForModelGate = isTauriRuntime && showModelGate;const downloadSizeLabel = useMemo(() => {+ if (isTauriRuntime) {+ return modelDownloadSizeBytes+ ? `Approx. ${formatBytes(modelDownloadSizeBytes)}`+ : "Approx. size varies by model";+ }if (selectedModelId) {return "Approx. size varies by model";}if (resolvedDefaultModel.sizeBytes) {- const extraBytes = allowMmproj- ? (resolvedDefaultModel.mmprojSizeBytes ?? 0)- : 0;- return `Approx. ${formatBytes(resolvedDefaultModel.sizeBytes + extraBytes)}`;+ return `Approx. ${formatBytes(resolvedDefaultModel.sizeBytes)}`;}return resolvedDefaultModel.sizeHuman? `Approx. ${resolvedDefaultModel.sizeHuman}`: "Approx. size varies by model";- }, [allowMmproj, resolvedDefaultModel, selectedModelId]);+ }, [+ isTauriRuntime,+ modelDownloadSizeBytes,+ resolvedDefaultModel,+ selectedModelId,+ ]);const downloadStatusLabel = useMemo(() => {if (!downloadStatus?.status || downloadStatus.status === "Ready") {@@ -1882,11 +2016,11 @@ const Page: React.FC = () => {wasInterrupted: boolean;}) => {if (!chatKey || wasInterrupted) return;- if (sessionSummaryInFlightRef.current) return;- sessionSummaryInFlightRef.current = true;+ const summaryEpoch = sessionSummaryEpochRef.current;try {const messages = await listMessages(sessionUuid, chatKey);+ if (sessionSummaryEpochRef.current !== summaryEpoch) return;const assistantMessages = messages.filter((message) => message.sender === "assistant",);@@ -1930,6 +2064,7 @@ const Page: React.FC = () => {const summaryInput = `User: ${userText}\nAssistant: ${assistantText}`;const summary = await generateSessionSummary(summaryInput);+ if (sessionSummaryEpochRef.current !== summaryEpoch) return;const summarySeed = summary ? trimToWords(summary, 7) : "";const title = summarySeed? sessionTitleFromText(summarySeed, fallbackTitle)@@ -1941,8 +2076,6 @@ const Page: React.FC = () => {await persistSessionTitle(sessionUuid, title, chatKey);} catch (error) {log.error("Failed to generate session title", error);- } finally {- sessionSummaryInFlightRef.current = false;}},[@@ -1954,21 +2087,55 @@ const Page: React.FC = () => {],);+ const scheduleSessionTitle = useCallback(+ (input: Parameters<typeof maybeGenerateSessionTitle>[0]) => {+ if (sessionSummaryPromiseRef.current) return;+ const task = maybeGenerateSessionTitle(input);+ sessionSummaryPromiseRef.current = task;+ void task+ .finally(() => {+ if (sessionSummaryPromiseRef.current === task) {+ sessionSummaryPromiseRef.current = null;+ }+ })+ .catch(() => undefined);+ },+ [maybeGenerateSessionTitle],+ );+const preloadModelIfAvailable = useCallback(async () => {+ const requestId = modelGateRequestRef.current + 1;+ modelGateRequestRef.current = requestId;+ const isCurrentRequest = () =>+ modelGateRequestRef.current === requestId;setModelGateError(null);setModelGateStatus("checking");+ setModelDownloadSizeBytes(null);try {const provider = await ensureProvider();const settings = getModelSettings();const availability =await provider.checkModelAvailability(settings);+ if (!isCurrentRequest()) return;const mmprojReady =availability.mmprojAvailable === undefined ||availability.mmprojAvailable;if (!availability.modelAvailable || !mmprojReady) {setModelGateStatus("missing");+ const size = await provider+ .estimateMissingModelDownloadSize(settings)+ .catch((error: unknown) => {+ log.warn(+ "Failed to estimate model download size",+ error,+ );+ return undefined;+ });+ if (isCurrentRequest()) {+ setModelDownloadSizeBytes(size ?? null);+ }return;}@@ -1977,11 +2144,21 @@ const Page: React.FC = () => {setIsDownloading(true);await provider.ensureModelReady(settings);+ if (!isCurrentRequest()) return;setLoadedModelName(provider.getCurrentModel()?.name ?? null);setIsDownloading(false);setDownloadStatus({ percent: 100, status: "Ready" });setModelGateStatus("ready");} catch (error) {+ if (!isCurrentRequest()) return;+ const { code } = tauriCommandError(error);+ if (code === "model_missing" || code === "not_found") {+ setModelGateError(null);+ setIsDownloading(false);+ setDownloadStatus(null);+ setModelGateStatus("missing");+ return;+ }const message = formatErrorMessage(error);log.error("Failed to preload model", error);setModelGateError(message);@@ -1992,6 +2169,10 @@ const Page: React.FC = () => {}, [ensureProvider, formatErrorMessage, getModelSettings]);const handleDownloadModel = useCallback(async () => {+ const requestId = modelGateRequestRef.current + 1;+ modelGateRequestRef.current = requestId;+ const isCurrentRequest = () =>+ modelGateRequestRef.current === requestId;setModelGateError(null);setModelGateStatus("downloading");setDownloadStatus({ percent: 0, status: "Preparing download..." });@@ -2000,12 +2181,16 @@ const Page: React.FC = () => {try {const provider = await ensureProvider();const settings = getModelSettings();- await provider.ensureModelReady(settings);+ await provider.ensureModelReady(settings, {+ downloadIfMissing: true,+ });+ if (!isCurrentRequest()) return;setLoadedModelName(provider.getCurrentModel()?.name ?? null);setIsDownloading(false);setDownloadStatus({ percent: 100, status: "Ready" });setModelGateStatus("ready");} catch (error) {+ if (!isCurrentRequest()) return;const message = formatErrorMessage(error);log.error("Failed to prepare model", error);setModelGateError(message);@@ -2032,6 +2217,11 @@ const Page: React.FC = () => {useEffect(() => {if (!firstPaintDone || !modelSettingsLoaded) return;+ modelGateRequestRef.current += 1;+ setModelGateError(null);+ setModelGateStatus("checking");+ setIsDownloading(false);+ setDownloadStatus(null);const cancelIdle = scheduleIdleTask(() => {void preloadModelIfAvailable();}, 2000);@@ -2239,6 +2429,7 @@ const Page: React.FC = () => {);const handleNewChat = useCallback(() => {+ cancelActiveGenerationForNavigation();setCurrentSessionId(undefined);currentSessionIdRef.current = undefined;setAllMessages([]);@@ -2257,10 +2448,16 @@ const Page: React.FC = () => {updateRouteSession(undefined, true);if (isSmall) setDrawerOpen(false);focusInput();- }, [focusInput, isSmall, updateRouteSession]);+ }, [+ cancelActiveGenerationForNavigation,+ focusInput,+ isSmall,+ updateRouteSession,+ ]);const handleSelectSession = useCallback((sessionId: string) => {+ cancelActiveGenerationForNavigation();setCurrentSessionId(sessionId);currentSessionIdRef.current = sessionId;setIsDraftSession(false);@@ -2269,7 +2466,12 @@ const Page: React.FC = () => {if (isSmall) setDrawerOpen(false);focusInput();},- [focusInput, isSmall, updateRouteSession],+ [+ cancelActiveGenerationForNavigation,+ focusInput,+ isSmall,+ updateRouteSession,+ ],);const removeSessionFromState = useCallback(@@ -2298,28 +2500,13 @@ const Page: React.FC = () => {if (!chatKey) return;if (currentSessionIdRef.current === sessionId) {- generationTokenRef.current += 1;-- const jobId = currentJobIdRef.current;- currentJobIdRef.current = null;- providerRef.current?.cancelGeneration(jobId ?? -1);-- setIsGenerating(false);- setIsStreamingOutro(false);- setIsDownloading(false);- setDownloadStatus(null);- setStreamingParentId(null);- setStreamingText("");- streamingBufferRef.current = "";- streamingChunksRef.current = [];- streamingCreatedAtRef.current = null;- lastGenerationRef.current = null;+ cancelActiveGenerationForNavigation();}await deleteSession(sessionId);removeSessionFromState(sessionId);},- [chatKey, removeSessionFromState],+ [chatKey, cancelActiveGenerationForNavigation, removeSessionFromState],);const requestDeleteSession = useCallback((sessionId: string) => {@@ -2593,14 +2780,18 @@ const Page: React.FC = () => {const handleStopGeneration = useCallback(() => {const jobId = currentJobIdRef.current;generationTokenRef.current += 1;+ beginGenerationStop();flushStreamingText();const finalText = streamingBufferRef.current.replaceAll("\0", "");const trimmedText = finalText.trim();const parentMessageUuid = streamingParentId;const activeSessionId = currentSessionIdRef.current ?? currentSessionId;+ const activeKnowledgeCitations = activeKnowledgeCitationsRef.current;+ activeKnowledgeCitationsRef.current = [];const last = lastGenerationRef.current;+ lastGenerationRef.current = null;setIsGenerating(false);setIsStreamingOutro(false);@@ -2615,8 +2806,13 @@ const Page: React.FC = () => {setStreamingText("");};- if (trimmedText && parentMessageUuid && activeSessionId && chatKey) {- void (async () => {+ const persistStoppedGeneration = async () => {+ if (+ trimmedText &&+ parentMessageUuid &&+ activeSessionId &&+ chatKey+ ) {try {const assistantMessage = await addMessage(activeSessionId,@@ -2624,15 +2820,17 @@ const Page: React.FC = () => {finalText,chatKey,parentMessageUuid,+ [],+ activeKnowledgeCitations,);- void updateBranchSelectionState(+ await updateBranchSelectionState(parentMessageUuid,assistantMessage.messageUuid,);appendMessageToState(assistantMessage);updateSessionAfterMessage(assistantMessage);- void maybeGenerateSessionTitle({+ scheduleSessionTitle({sessionUuid: activeSessionId,assistantMessageUuid: assistantMessage.messageUuid,wasInterrupted: false,@@ -2640,46 +2838,61 @@ const Page: React.FC = () => {} catch (error) {log.error("Failed to finalize stopped generation", error);if (last?.previousSelection) {- void updateBranchSelectionState(+ await updateBranchSelectionState(last.parentMessageUuid,last.previousSelection,);}- } finally {- resetStreamingState();}- })();- } else {+ return;+ }+if (last?.previousSelection) {- void updateBranchSelectionState(+ await updateBranchSelectionState(last.parentMessageUuid,last.previousSelection,);}- resetStreamingState();- }-- const provider = providerRef.current;- if (provider) {- provider.cancelGeneration(jobId ?? -1);- return;- }+ };- void (async () => {+ const cancelNativeGeneration = async () => {try {- const ensured = await ensureProvider();- ensured.cancelGeneration(jobId ?? -1);+ const provider =+ providerRef.current ?? (await ensureProvider());+ await provider.cancelGeneration(jobId ?? -1);} catch (error) {log.error("Failed to cancel generation", error);}+ };++ void (async () => {+ try {+ const results = await Promise.allSettled([+ cancelNativeGeneration(),+ persistStoppedGeneration(),+ ]);+ for (const result of results) {+ if (result.status === "rejected") {+ log.error(+ "Stopped generation cleanup failed",+ result.reason,+ );+ }+ }+ } finally {+ resetStreamingState();+ endGenerationStop();+ }})();}, [appendMessageToState,+ beginGenerationStop,chatKey,currentSessionId,+ endGenerationStop,ensureProvider,flushStreamingText,- maybeGenerateSessionTitle,+ scheduleSessionTitle,streamingParentId,updateBranchSelectionState,updateSessionAfterMessage,@@ -2708,6 +2921,16 @@ const Page: React.FC = () => {const activeSessionId =sessionUuid ?? currentSessionIdRef.current ?? currentSessionId;if (!chatKey || !activeSessionId) return;+ if (+ generationStartingRef.current ||+ generationStoppingRef.current+ ) {+ return;+ }+ generationStartingRef.current = true;+ setIsGenerating(true);+ currentJobIdRef.current = null;+ lastGenerationRef.current = null;const generationToken = generationTokenRef.current + 1;generationTokenRef.current = generationToken;@@ -2716,52 +2939,63 @@ const Page: React.FC = () => {generationTokenRef.current === generationToken &¤tSessionIdRef.current === activeSessionId;- const provider = await ensureProvider();- const settings = getModelSettings();- const { contextSize, maxTokens } =- provider.resolveRuntimeSettings(settings);+ let provider: LlmProvider;+ let settings: ModelSettings;+ let contextSize: number;+ let maxTokens: number;+ let previousSelection: string | null | undefined;+ let startupCompleted = false;+ try {+ provider = await ensureProvider();+ const priorSummary = sessionSummaryPromiseRef.current;+ if (priorSummary) {+ sessionSummaryEpochRef.current += 1;+ await provider.cancelGeneration(-1);+ await priorSummary.catch(() => undefined);+ if (!isActiveGeneration()) return;+ }+ settings = getModelSettings();+ ({ contextSize, maxTokens } =+ provider.resolveRuntimeSettings(settings));- if (!isActiveGeneration()) {- return;- }+ if (!isActiveGeneration()) return;- const previousSelection = branchSelections[parentMessageUuid];- lastGenerationRef.current = {- parentMessageUuid,- previousSelection,- };+ previousSelection = branchSelections[parentMessageUuid];+ lastGenerationRef.current = {+ parentMessageUuid,+ previousSelection,+ };- void updateBranchSelectionState(- parentMessageUuid,- STREAMING_SELECTION_KEY,- false,- );- setStreamingParentId(parentMessageUuid);- setStreamingText("");- streamingBufferRef.current = "";- streamingChunksRef.current = [];- streamingCreatedAtRef.current = Date.now() * 1000;- setIsStreamingOutro(false);- setIsGenerating(true);- currentJobIdRef.current = null;+ void updateBranchSelectionState(+ parentMessageUuid,+ STREAMING_SELECTION_KEY,+ false,+ );+ setStreamingParentId(parentMessageUuid);+ setStreamingText("");+ streamingBufferRef.current = "";+ streamingChunksRef.current = [];+ streamingCreatedAtRef.current = Date.now() * 1000;+ setIsStreamingOutro(false);+ startupCompleted = true;+ } catch (error) {+ if (isActiveGeneration()) {+ const message = formatErrorMessage(error);+ showMiniDialog({ title: "Model error", message });+ }+ return;+ } finally {+ generationStartingRef.current = false;+ if (!startupCompleted && isActiveGeneration()) {+ setIsGenerating(false);+ }+ }let errorMessage: string | null = null;+ activeKnowledgeCitationsRef.current = [];try {- await provider.ensureModelReady(settings);- setLoadedModelName(provider.getCurrentModel()?.name ?? null);- setIsDownloading(false);- setDownloadStatus({ percent: 100, status: "Ready" });-- if (!isActiveGeneration()) {- return;- }-- if (resetContext) {- await provider.resetContext(contextSize);- if (!isActiveGeneration()) return;- }-+ const normalSystemPrompt = buildChatSystemPrompt(systemPrompt);const history = buildHistory(historyPath,promptText,@@ -2769,27 +3003,129 @@ const Page: React.FC = () => {maxTokens,stopAtMessageUuid,);-- const messages: LlmMessage[] = [- {- role: "system",- content: buildChatSystemPrompt(systemPrompt),- },+ const normalMessages: LlmMessage[] = [+ { role: "system", content: normalSystemPrompt },...history,{ role: "user", content: promptText },];- const promptTokenEstimate = messages.reduce(+ const inputBudget =+ contextSize - maxTokens - OVERFLOW_SAFETY_TOKENS;+ const normalPromptTokenEstimate = normalMessages.reduce((total, message) => total + approxTokens(message.content),0,);- const inputBudget =- contextSize - maxTokens - OVERFLOW_SAFETY_TOKENS;- if (promptTokenEstimate > inputBudget) {+ if (normalPromptTokenEstimate > inputBudget) {throw new Error("Prompt exceeds the model context window. Reduce history, lower max tokens, or increase context length.",);}+ let knowledgeContext: Awaited<+ ReturnType<typeof retrieveKnowledge>+ > = null;+ let readyPacks = knowledgePacks;+ if (+ isTauriRuntime &&+ enabledKnowledgePackIds.size > 0 &&+ readyPacks.length === 0+ ) {+ try {+ readyPacks = await loadKnowledgeCatalogOnce();+ if (!isActiveGeneration()) return;+ setKnowledgePacks(readyPacks);+ } catch (error) {+ log.warn(+ "Ensu Pack bootstrap failed; continuing without pack context",+ error,+ );+ }+ }+ const enabledReadyPackIds = readyPacks+ .filter(+ (pack) =>+ pack.status !== "download" &&+ enabledKnowledgePackIds.has(pack.stableId),+ )+ .map((pack) => pack.stableId);+ const knowledgeQuery = parseDocumentBlocks(promptText)+ .text.replaceAll(MEDIA_MARKER, "")+ .replace(/\[\d+ image attachments? provided\]/gi, "")+ .trim();+ const remainingKnowledgeBytes = Math.max(+ 0,+ (inputBudget - normalPromptTokenEstimate) * 4 - 2,+ );+ if (+ knowledgeQuery &&+ enabledReadyPackIds.length > 0 &&+ remainingKnowledgeBytes > 0+ ) {+ try {+ knowledgeContext =+ await provider.withKnowledgeRetrieval(+ (retrievalEpoch) =>+ retrieveKnowledge(+ knowledgeQuery,+ enabledReadyPackIds,+ remainingKnowledgeBytes,+ retrievalEpoch,+ ),+ isActiveGeneration,+ );+ if (!isActiveGeneration()) return;+ } catch (error) {+ const { code } = tauriCommandError(error);+ if (!isActiveGeneration() || code === "cancelled") {+ return;+ }+ if (code === "embedding_missing") {+ throw error;+ }+ log.warn(+ "Ensu Pack retrieval failed; continuing without pack context",+ error,+ );+ }+ }+ if (!isActiveGeneration()) return;++ await provider.ensureModelReady(settings);+ setLoadedModelName(provider.getCurrentModel()?.name ?? null);+ setIsDownloading(false);+ setDownloadStatus({ percent: 100, status: "Ready" });++ if (!isActiveGeneration()) {+ return;+ }++ if (resetContext) {+ await provider.resetContext(contextSize);+ if (!isActiveGeneration()) return;+ }++ let messages = normalMessages;+ let activeCitations: SourceCitation[] = [];+ if (knowledgeContext) {+ const candidateMessages: LlmMessage[] = [+ {+ role: "system",+ content: `${normalSystemPrompt}\n\n${knowledgeContext.text}`,+ },+ ...history,+ { role: "user", content: promptText },+ ];+ if (+ candidateMessages.reduce(+ (total, message) =>+ total + approxTokens(message.content),+ 0,+ ) <= inputBudget+ ) {+ messages = candidateMessages;+ activeCitations = knowledgeContext.citations;+ }+ }+ activeKnowledgeCitationsRef.current = activeCitations;const nativeImagePaths =imagePaths?.length && provider.getBackendKind() === "tauri"? imagePaths@@ -2801,8 +3137,8 @@ const Page: React.FC = () => {throw new Error("MMProj model not available");}- try {- await provider.generateChatStream(+ const generate = () =>+ provider.generateChatStream({messages,imagePaths: nativeImagePaths,@@ -2821,7 +3157,7 @@ const Page: React.FC = () => {event.type === "text"? event.job_id: event.summary.job_id;- provider.cancelGeneration(jobId);+ void provider.cancelGeneration(jobId);return;}if (event.type === "text") {@@ -2835,9 +3171,33 @@ const Page: React.FC = () => {}},);+ try {+ await generate();} catch (error) {- errorMessage =- error instanceof Error ? error.message : String(error);+ const { code } = tauriCommandError(error);+ if (+ code === "prompt_too_long" &&+ !streamingBufferRef.current &&+ streamingChunksRef.current.length === 0 &&+ activeCitations.length > 0+ ) {+ activeCitations = [];+ activeKnowledgeCitationsRef.current = [];+ messages = normalMessages;+ try {+ await generate();+ } catch (retryError) {+ errorMessage =+ retryError instanceof Error+ ? retryError.message+ : String(retryError);+ }+ } else {+ errorMessage =+ error instanceof Error+ ? error.message+ : String(error);+ }}if (!isActiveGeneration()) {@@ -2863,7 +3223,7 @@ const Page: React.FC = () => {return;}- const assistantText = finalText.replaceAll("\0", "");+ const rawAssistantText = finalText.replaceAll("\0", "");setIsStreamingOutro(true);await new Promise<void>((resolve) => {@@ -2874,12 +3234,16 @@ const Page: React.FC = () => {return;}+ activeKnowledgeCitationsRef.current = [];+const assistantMessage = await addMessage(activeSessionId,"assistant",- assistantText,+ rawAssistantText,chatKey,parentMessageUuid,+ [],+ activeCitations,);void updateBranchSelectionState(@@ -2889,7 +3253,7 @@ const Page: React.FC = () => {appendMessageToState(assistantMessage);updateSessionAfterMessage(assistantMessage);- void maybeGenerateSessionTitle({+ scheduleSessionTitle({sessionUuid: activeSessionId,assistantMessageUuid: assistantMessage.messageUuid,wasInterrupted: !!errorMessage,@@ -2898,8 +3262,19 @@ const Page: React.FC = () => {if (!isActiveGeneration()) {return;}- const message = formatErrorMessage(error);- showMiniDialog({ title: "Model error", message });+ const { code } = tauriCommandError(error);+ if (+ code === "model_missing" ||+ code === "not_found" ||+ code === "embedding_missing"+ ) {+ setModelGateError(null);+ setDownloadStatus(null);+ setModelGateStatus("missing");+ } else {+ const message = formatErrorMessage(error);+ showMiniDialog({ title: "Model error", message });+ }if (previousSelection) {void updateBranchSelectionState(parentMessageUuid,@@ -2908,6 +3283,7 @@ const Page: React.FC = () => {}} finally {if (isActiveGeneration()) {+ activeKnowledgeCitationsRef.current = [];setIsGenerating(false);setIsStreamingOutro(false);setIsDownloading(false);@@ -2917,6 +3293,7 @@ const Page: React.FC = () => {setStreamingParentId(null);streamingCreatedAtRef.current = null;currentJobIdRef.current = null;+ lastGenerationRef.current = null;}}},@@ -2935,8 +3312,12 @@ const Page: React.FC = () => {formatErrorMessage,scheduleStreamingFlush,flushStreamingText,- maybeGenerateSessionTitle,+ scheduleSessionTitle,systemPrompt,+ isTauriRuntime,+ enabledKnowledgePackIds,+ knowledgePacks,+ loadKnowledgeCatalogOnce,],);@@ -3175,6 +3556,83 @@ const Page: React.FC = () => {() => setShowSystemPromptSettings(false),[],);+ const handleDownloadKnowledgePack = useCallback(+ (stableId: string) => {+ const previousPack = knowledgePacks.find(+ (pack) => pack.stableId === stableId,+ );+ const wasInstalled = Boolean(+ previousPack && previousPack.status !== "download",+ );+ setKnowledgeErrors((current) => ({+ ...current,+ [stableId]: undefined,+ }));+ setKnowledgeDownloadProgress((current) => ({+ ...current,+ [stableId]: 0,+ }));+ void downloadKnowledgePack(stableId, (percent) => {+ setKnowledgeDownloadProgress((current) => ({+ ...current,+ [stableId]: percent,+ }));+ })+ .then((pack) => {+ setKnowledgePacks((current) =>+ current.map((item) =>+ item.stableId === stableId ? pack : item,+ ),+ );+ if (!wasInstalled) {+ setEnabledKnowledgePackIds((current) => {+ const next = new Set(current).add(stableId);+ saveEnabledKnowledgePacks(next);+ return next;+ });+ }+ })+ .catch((error: unknown) => {+ const { code } = tauriCommandError(error);+ if (code !== "cancelled") {+ setKnowledgeErrors((current) => ({+ ...current,+ [stableId]: knowledgeErrorMessage(error),+ }));+ }+ void refreshKnowledgeCatalog();+ })+ .finally(() => {+ setKnowledgeDownloadProgress((current) => ({+ ...current,+ [stableId]: undefined,+ }));+ });+ },+ [knowledgePacks, refreshKnowledgeCatalog],+ );+ const handleCancelKnowledgePackDownload = useCallback(+ (stableId: string) => {+ void cancelKnowledgePackDownload(stableId).catch(+ (error: unknown) => {+ log.warn("Failed to cancel Ensu Pack download", error);+ },+ );+ },+ [],+ );+ const handleSetKnowledgePackEnabled = useCallback(+ (stableId: string, enabled: boolean) => {+ setEnabledKnowledgePackIds((current) => {+ const next = new Set(current);+ if (enabled) next.add(stableId);+ else next.delete(stableId);+ saveEnabledKnowledgePacks(next);+ return next;+ });+ },+ [],+ );const handleBuildVersionTap = useCallback(() => {if (advancedUnlocked || typeof window === "undefined") return;@@ -3202,6 +3660,10 @@ const Page: React.FC = () => {[isTauriRuntime],);const suggestedModels = resolvedModelPresets ?? fallbackSuggestedModels;+ const isModelPreparationActive =+ modelGateStatus === "checking" ||+ modelGateStatus === "preloading" ||+ modelGateStatus === "downloading";const handleSaveModel = useCallback((draft: {@@ -3209,6 +3671,7 @@ const Page: React.FC = () => {contextLength: string;maxTokens: string;}) => {+ if (isModelPreparationActive) return;setIsSavingModel(true);if (typeof window !== "undefined") {window.localStorage.setItem(@@ -3219,14 +3682,18 @@ const Page: React.FC = () => {setSelectedModelId(draft.modelId);setContextLength(draft.contextLength);setMaxTokens(draft.maxTokens);+ modelGateRequestRef.current += 1;setLoadedModelName(null);+ setModelDownloadSizeBytes(null);+ setModelGateStatus("checking");setIsSavingModel(false);setShowModelSettings(false);},- [],+ [isModelPreparationActive],);const handleUseDefaultModel = useCallback(() => {+ if (isModelPreparationActive) return;if (typeof window !== "undefined") {window.localStorage.setItem(MODEL_SETTINGS_STORAGE_KEY,@@ -3240,9 +3707,12 @@ const Page: React.FC = () => {setSelectedModelId("");setContextLength("");setMaxTokens("");+ modelGateRequestRef.current += 1;setLoadedModelName(null);+ setModelDownloadSizeBytes(null);+ setModelGateStatus("checking");setShowModelSettings(false);- }, []);+ }, [isModelPreparationActive]);const handleSaveSystemPrompt = useCallback((promptText: string) => {const normalizedPrompt = promptText.trim();@@ -3654,6 +4124,10 @@ const Page: React.FC = () => {if (!trimmed && !hasDocuments && !hasImages) {return;}+ if (showModelGate) return;+ if (generationStartingRef.current || generationStoppingRef.current) {+ return;+ }if (isDownloading) {showMiniDialog({title: "Model download in progress",@@ -3884,6 +4358,7 @@ const Page: React.FC = () => {messageState.path,pendingDocuments,pendingImages,+ showModelGate,showMiniDialog,onGenericError,slicePathUntil,@@ -4072,39 +4547,46 @@ const Page: React.FC = () => {</Stack></NavbarBase>- <ChatMessageList- messages={displayMessages}- attachmentPreviews={attachmentPreviews}- branchSwitchers={branchSwitchers}- loadingPhrase={loadingPhrase}- loadingDots={loadingDots}- isGenerating={isGenerating}- isStreamingOutro={isStreamingOutro}- stickToBottom={stickToBottom}- onStickToBottomChange={handleStickToBottomChange}- scrollContainerRef={scrollContainerRef}- onScroll={handleScroll}- onUserScrollIntent={markUserScrollIntent}- onOpenAttachment={handleOpenAttachment}- onEditMessage={handleEditMessage}- onCopyMessage={handleCopyMessage}- onRetryMessage={handleRetryMessage}- onPrevBranch={handlePrevBranch}- onNextBranch={handleNextBranch}- onRequestPreview={loadAttachmentPreview}- parseDocumentBlocks={parseDocumentBlocks}- stripHiddenParts={stripHiddenParts}- formatTime={formatTime}- isDesktopOverlay={isDesktopOverlay}- userBubbleBackground={userBubbleBackground}- userMessageTextSx={userMessageTextSx}- assistantTextSx={assistantTextSx}- assistantMarkdownSx={assistantMarkdownSx}- streamingMessageSx={streamingMessageSx}- actionButtonSx={actionButtonSx}- smallIconProps={smallIconProps}- actionIconProps={actionIconProps}- />+ {hideMessagesForModelGate ? (+ <Box sx={{ flex: 1 }} />+ ) : (+ <ChatMessageList+ messages={displayMessages}+ attachmentPreviews={attachmentPreviews}+ branchSwitchers={branchSwitchers}+ loadingPhrase={loadingPhrase}+ loadingDots={loadingDots}+ isGenerating={isGenerating}+ isStreamingOutro={isStreamingOutro}+ stickToBottom={stickToBottom}+ onStickToBottomChange={handleStickToBottomChange}+ scrollContainerRef={scrollContainerRef}+ onScroll={handleScroll}+ onUserScrollIntent={markUserScrollIntent}+ onOpenAttachment={handleOpenAttachment}+ onEditMessage={handleEditMessage}+ onCopyMessage={handleCopyMessage}+ onRetryMessage={handleRetryMessage}+ onPrevBranch={handlePrevBranch}+ onNextBranch={handleNextBranch}+ onRequestPreview={loadAttachmentPreview}+ parseDocumentBlocks={parseDocumentBlocks}+ stripHiddenParts={stripHiddenParts}+ formatTime={formatTime}+ isDesktopOverlay={isDesktopOverlay}+ userBubbleBackground={userBubbleBackground}+ userMessageTextSx={userMessageTextSx}+ assistantTextSx={assistantTextSx}+ assistantMarkdownSx={assistantMarkdownSx}+ streamingMessageSx={streamingMessageSx}+ actionButtonSx={actionButtonSx}+ dialogTitleSx={dialogTitleSx}+ dialogCloseButtonSx={drawerIconButtonSx}+ dialogCloseIconProps={tinyIconProps}+ smallIconProps={smallIconProps}+ actionIconProps={actionIconProps}+ />+ )}<ChatComposershowModelGate={showModelGate}@@ -4197,13 +4679,16 @@ const Page: React.FC = () => {<ChatDialogsshowSettingsModal={showSettingsModal}+ openSettingsModal={openSettingsModal}closeSettingsModal={closeSettingsModal}dialogPaperSx={dialogPaperSx}dialogTitleSx={dialogTitleSx}actionButtonSx={actionButtonSx}+ drawerIconButtonSx={drawerIconButtonSx}settingsItemSx={settingsItemSx}smallIconProps={smallIconProps}compactIconProps={compactIconProps}+ tinyIconProps={tinyIconProps}saveLogs={saveLogs}handleCheckForUpdates={handleCheckForUpdates}advancedUnlocked={advancedUnlocked}@@ -4238,6 +4723,18 @@ const Page: React.FC = () => {systemPrompt={systemPrompt}handleSaveSystemPrompt={handleSaveSystemPrompt}handleUseDefaultSystemPrompt={handleUseDefaultSystemPrompt}+ knowledgePacks={knowledgePacks}+ knowledgeCatalogLoading={knowledgeCatalogLoading}+ knowledgeCatalogError={knowledgeCatalogError}+ retryKnowledgeCatalog={refreshKnowledgeCatalog}+ enabledKnowledgePackIds={enabledKnowledgePackIds}+ knowledgeDownloadProgress={knowledgeDownloadProgress}+ knowledgeErrors={knowledgeErrors}+ handleDownloadKnowledgePack={handleDownloadKnowledgePack}+ handleCancelKnowledgePackDownload={+ handleCancelKnowledgePackDownload+ }+ handleSetKnowledgePackEnabled={handleSetKnowledgePackEnabled}chatNotificationOpen={chatNotificationOpen}setChatNotificationOpen={setChatNotificationOpen}chatNotification={chatNotification}diff --git a/web/apps/ensu/src/services/chat/store.ts b/web/apps/ensu/src/services/chat/store.tsindex f4d6094e48..7ee10b7328 100644--- a/web/apps/ensu/src/services/chat/store.ts+++ b/web/apps/ensu/src/services/chat/store.ts@@ -1,3 +1,4 @@+import type { SourceCitation } from "@/services/knowledge";import { isTauriRuntime } from "@/services/tauri-runtime";import { getKV, removeKV, setKV } from "ente-base/kv";import log from "ente-base/log";@@ -113,6 +114,8 @@ export interface ChatMessage {text: string;createdAt: number;attachments?: ChatAttachment[];+ citations?: SourceCitation[];+ sourceLabel?: string;isSynthetic?: boolean;}@@ -139,6 +142,8 @@ interface NativeMessage {text: string;createdAt: number;attachments?: NativeAttachment[];+ citations?: SourceCitation[];+ sourceLabel?: string | null;}const nowMicros = () => Date.now() * 1000;@@ -423,6 +428,8 @@ const listMessagesNative = async (name: attachment.name,size: attachment.size,})),+ citations: message.citations,+ sourceLabel: message.sourceLabel ?? undefined,}));};@@ -443,6 +450,7 @@ const addMessageNative = async (text: string,parentMessageUuid?: string,attachments: ChatAttachment[] = [],+ citations: SourceCitation[] = [],): Promise<ChatMessage> => {const message = await invokeChat<NativeMessage>("chat_db_insert_message", {input: {@@ -450,6 +458,7 @@ const addMessageNative = async (sender,text,parentMessageUuid,+ citations,attachments: attachments.map((attachment) => ({id: attachment.id,kind: attachment.kind,@@ -490,6 +499,8 @@ const addMessageNative = async (name: attachment.name,size: attachment.size,})),+ citations: message.citations,+ sourceLabel: message.sourceLabel ?? undefined,};};@@ -636,6 +647,7 @@ export const addMessage = async (chatKey: string,parentMessageUuid?: string,attachments: ChatAttachment[] = [],+ citations: SourceCitation[] = [],): Promise<ChatMessage> => {if (isTauriRuntime()) {return addMessageNative(@@ -644,6 +656,7 @@ export const addMessage = async (text,parentMessageUuid,attachments,+ citations,);}diff --git a/web/apps/ensu/src/services/knowledge.ts b/web/apps/ensu/src/services/knowledge.tsnew file mode 100644index 0000000000..0943690087--- /dev/null+++ b/web/apps/ensu/src/services/knowledge.ts@@ -0,0 +1,152 @@+import { isTauriRuntime } from "@/services/tauri-runtime";+import log from "ente-base/log";++const ENABLED_PACKS_STORAGE_KEY = "ensu.desktop.enabledKnowledgePacks";++export type KnowledgePackStatus = "download" | "ready" | "updateAvailable";++export interface KnowledgeAttribution {+ credit: string;+ licenseLabel: string;+ licenseUrl: string;+ publicPackUrl: string;+ modificationNotice: string;+}++export interface KnowledgePack {+ stableId: string;+ label: string;+ downloadSizeBytes: number;+ status: KnowledgePackStatus;+ attribution: KnowledgeAttribution;+}++export interface SourceCitation {+ datasetId: string;+ datasetLabel: string;+ credit: string;+ title: string;+ sourceUrl: string;+ licenseLabel: string;+ licenseUrl: string;+}++export interface KnowledgePromptContext {+ text: string;+ citations: SourceCitation[];+}++interface KnowledgeDownloadProgress {+ stableId: string;+ percent: number;+}++const invokeKnowledge = async <T>(+ command: string,+ args?: Record<string, unknown>,+) => {+ if (!isTauriRuntime()) {+ throw new Error("Ensu Packs are only available in the desktop app");+ }+ const { invoke } = await import("@tauri-apps/api/core");+ return invoke<T>(command, args);+};++export const loadKnowledgeCatalog = () =>+ invokeKnowledge<KnowledgePack[]>("knowledge_catalog");++export const downloadKnowledgePack = async (+ stableId: string,+ onProgress: (percent: number) => void,+) => {+ const { listen } = await import("@tauri-apps/api/event");+ const unlisten = await listen<KnowledgeDownloadProgress>(+ "knowledge-download-progress",+ (event) => {+ if (event.payload.stableId === stableId) {+ onProgress(event.payload.percent);+ }+ },+ );+ try {+ return await invokeKnowledge<KnowledgePack>("knowledge_download_pack", {+ stableId,+ });+ } finally {+ unlisten();+ }+};++export const cancelKnowledgePackDownload = (stableId: string) =>+ invokeKnowledge("knowledge_cancel_pack_download", { stableId });++export const retrieveKnowledge = (+ query: string,+ enabledStableIds: string[],+ maxContextUtf8Bytes: number,+ retrievalEpoch: number,+) =>+ invokeKnowledge<KnowledgePromptContext | null>("knowledge_retrieve", {+ query,+ enabledStableIds,+ maxContextUtf8Bytes,+ retrievalEpoch,+ });++export const loadEnabledKnowledgePacks = () => {+ if (typeof window === "undefined" || !isTauriRuntime()) {+ return new Set<string>();+ }+ try {+ const raw = window.localStorage.getItem(ENABLED_PACKS_STORAGE_KEY);+ const parsed = raw ? (JSON.parse(raw) as unknown) : [];+ return new Set(+ Array.isArray(parsed)+ ? parsed.filter((value): value is string =>+ Boolean(typeof value === "string" && value),+ )+ : [],+ );+ } catch (error) {+ log.warn("Failed to load enabled Ensu Packs", error);+ return new Set<string>();+ }+};++export const saveEnabledKnowledgePacks = (stableIds: Set<string>) => {+ if (typeof window === "undefined") return;+ try {+ window.localStorage.setItem(+ ENABLED_PACKS_STORAGE_KEY,+ JSON.stringify([...stableIds].sort()),+ );+ } catch (error) {+ log.warn("Failed to save enabled Ensu Packs", error);+ }+};++export const knowledgeErrorMessage = (error: unknown) => {+ const record =+ error && typeof error === "object"+ ? (error as { code?: unknown; message?: unknown })+ : undefined;+ const code = typeof record?.code === "string" ? record.code : undefined;+ switch (code) {+ case "storage_full":+ return "Not enough storage space to download this knowledge pack.";+ case "network":+ return "Couldn't download the knowledge pack. Check your connection and try again.";+ case "http":+ return "The knowledge pack is currently unavailable. Please try again later.";+ case "validation":+ case "size_mismatch":+ case "protocol":+ case "invalid_pack":+ case "invalid_target":+ return "The knowledge pack couldn't be verified. Please try again.";+ case "io":+ return "Couldn't save the knowledge pack. Please try again.";+ default:+ return "Knowledge pack setup failed. Please try again.";+ }+};diff --git a/web/apps/ensu/src/services/llm/inference.ts b/web/apps/ensu/src/services/llm/inference.tsindex c4c8a7d960..773110472c 100644--- a/web/apps/ensu/src/services/llm/inference.ts+++ b/web/apps/ensu/src/services/llm/inference.ts@@ -72,7 +72,7 @@ export interface InferenceBackend {mmprojPath: string,mediaMarker?: string,): Promise<void>;- cancel(jobId: number): void;+ cancel(jobId: number): Promise<void>;freeContext(): Promise<void>;freeModel(): Promise<void>;isModelAvailable(modelPath: string): Promise<boolean>;@@ -166,18 +166,19 @@ class WasmInference implements InferenceBackend {return this.generateCompletion(prompt, request, onEvent);}- cancel(jobId: number) {+ cancel(jobId: number): Promise<void> {if (jobId <= 0) {for (const controller of this.abortControllers.values()) {controller.abort();}this.abortControllers.clear();- return;+ return Promise.resolve();}const controller = this.abortControllers.get(jobId);if (controller) {controller.abort();}+ return Promise.resolve();}async freeContext() {@@ -660,9 +661,9 @@ class TauriInference implements InferenceBackend {}}- cancel(jobId: number) {+ async cancel(jobId: number) {log.info("LLM tauri cancel", { jobId });- void invoke("llm_cancel", { jobId });+ await invoke("llm_cancel", { jobId });}async freeContext() {diff --git a/web/apps/ensu/src/services/llm/provider.ts b/web/apps/ensu/src/services/llm/provider.tsindex 324efbf4e6..9573356838 100644--- a/web/apps/ensu/src/services/llm/provider.ts+++ b/web/apps/ensu/src/services/llm/provider.ts@@ -133,6 +133,11 @@ const MODEL_INFO_FALLBACKS = [...FALLBACK_DESKTOP_MODEL_PRESETS,];+const modelMissingError = () =>+ Object.assign(new Error("Required model assets are not downloaded"), {+ code: "model_missing",+ });+export class LlmProvider {private backend = createInferenceBackend({backend: "auto",@@ -253,12 +258,25 @@ export class LlmProvider {};}+ public async estimateMissingModelDownloadSize(settings: ModelSettings) {+ await this.initialize();+ if (this.backend.kind !== "tauri") return undefined;+ const { model } = this.resolveRuntimeSettings(settings);+ const { invoke } = await import("@tauri-apps/api/core");+ return (+ (await invoke<number | null>("llm_model_download_size", {+ modelId: model.id,+ })) ?? undefined+ );+ }+public async ensureModelReady(settings: ModelSettings,- options: { emitProgress?: boolean } = {},+ options: { emitProgress?: boolean; downloadIfMissing?: boolean } = {},) {await this.initialize();const emitProgress = options.emitProgress ?? true;+ const downloadIfMissing = options.downloadIfMissing ?? false;const { model, contextSize } = this.resolveRuntimeSettings(settings);const contextKey = JSON.stringify({ contextSize });@@ -310,7 +328,8 @@ export class LlmProvider {this.currentModel?.id === model.id &&this.currentModelPath === modelPath &&this.currentContextKey === contextKey &&- this.currentMmprojPath === mmprojPath+ this.currentMmprojPath === mmprojPath &&+ (!status || status.downloaded)) {log.info("LLM model already ready", { modelId: model.id });this.modelReady = true;@@ -331,8 +350,15 @@ export class LlmProvider {this.currentMmprojPath = undefined;this.currentContextKey = undefined;- if (modelId && !(await this.modelStatus(modelId)).downloaded) {- await this.downloadModelNative(modelId);+ if (modelId) {+ const isDownloaded = (await this.modelStatus(modelId))+ .downloaded;+ if (!isDownloaded && !downloadIfMissing) {+ throw modelMissingError();+ }+ if (downloadIfMissing && !isDownloaded) {+ await this.downloadModelNative(modelId);+ }}if (emitProgress) {@@ -396,7 +422,7 @@ export class LlmProvider {}public cancelGeneration(jobId: number) {- this.backend.cancel(jobId);+ return this.backend.cancel(jobId);}public async resetContext(contextSize?: number) {@@ -418,6 +444,35 @@ export class LlmProvider {}}+ private invalidateModelState() {+ this.currentModel = undefined;+ this.currentModelPath = undefined;+ this.currentMmprojPath = undefined;+ this.currentContextKey = undefined;+ this.modelReady = false;+ }++ public async withKnowledgeRetrieval<T>(+ operation: (retrievalEpoch: number) => Promise<T>,+ shouldContinue: () => boolean,+ ) {+ if (this.backend.kind !== "tauri") {+ throw new Error(+ "Knowledge retrieval is only available in the desktop app",+ );+ }+ const { invoke } = await import("@tauri-apps/api/core");+ const retrievalEpoch = await invoke<number>("llm_retrieval_epoch");+ await this.ensureInFlight?.promise.catch(() => undefined);+ if (!shouldContinue()) {+ throw Object.assign(new Error("Knowledge retrieval cancelled"), {+ code: "cancelled",+ });+ }+ this.invalidateModelState();+ return operation(retrievalEpoch);+ }+public cancelDownload() {if (this.downloadActive && this.backend.kind === "tauri") {void import("@tauri-apps/api/core").then(({ invoke }) =>