Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.tsx
index 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.tsx
index 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(
<IconButton
aria-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)",
+ },
+ },
+ ]}
>
<HugeiconsIcon
icon={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(
<IconButton
aria-label="Close settings"
onClick={closeSettingsModal}
- sx={actionButtonSx}
+ sx={drawerIconButtonSx}
>
<HugeiconsIcon
icon={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 && (
<ListItemButton
onClick={() => {
@@ -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>
+
<Dialog
open={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(
<Button
onClick={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.tsx
index 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.tsx
index 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 &&
currentSessionIdRef.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}
+ />
+ )}
<ChatComposer
showModelGate={showModelGate}
@@ -4197,13 +4679,16 @@ const Page: React.FC = () => {
<ChatDialogs
showSettingsModal={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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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 }) =>