@pheem49/mint 1.16.0 → 1.18.0

package/src-tauri/src/background/headless.rs

@@ -8,12 +8,10 @@ use mint_core::{
 use serde_json::{Value, json};
 use tauri::{AppHandle, Emitter, Manager};
 
-use mint_core::browser::{click, navigate, read_page_text, type_text};
-
 const MAX_STEPS: usize = 20;
 const SYSTEM_PROMPT: &str = r#"You are Mint's native background task agent. Return only JSON:
-{"thought":"short progress note","action":"done|propose_folder|propose_write_file|open_url|browser_read|browser_click|browser_type|knowledge_search|propose_bash","target":"path, URL, selector, query, command, or final result","data":"optional file content"}
-Use only one action per response. Background tasks never mutate the filesystem or execute shell commands. Use propose_folder, propose_write_file, and propose_bash so Mint can record a proposal for explicit user approval."#;
+{"thought":"short progress note","action":"done|propose_folder|propose_write_file|propose_url|knowledge_search|propose_bash","target":"path, URL, query, command, or final result","data":"optional file content"}
+Use only one action per response. Background tasks never mutate the filesystem or execute shell commands. Use propose_folder, propose_write_file, propose_url, and propose_bash so Mint can record a proposal for explicit user approval."#;
 
 #[derive(Debug, Deserialize)]
 struct AgentAction {
@@ -174,10 +172,18 @@ async fn execute_action(
                 action.target
             ))
         }
-        "open_url" => navigate(config, &action.target).await,
-        "browser_read" => read_page_text(config).await,
-        "browser_click" => click(config, &action.target).await,
-        "browser_type" => type_text(config, &action.target, &action.data).await,
+        "propose_url" | "open_url" => {
+            store
+                .add_artifact(
+                    &task.id,
+                    json!({ "type": "url_proposal", "url": action.target, "description": format!("Proposed by native task step {step}; explicit approval required") }),
+                )
+                .map_err(|error| error.to_string())?;
+            Ok(format!(
+                "url proposal recorded but not opened: {}",
+                action.target
+            ))
+        }
         "knowledge_search" => {
             let hits = KnowledgeStore::open_default()
                 .map_err(|error| error.to_string())?

package/src-tauri/src/commands/conversation.rs

@@ -27,6 +27,26 @@ pub(crate) enum DesktopStreamEvent {
     },
 }
 
+fn apply_request_overrides_to_config(config: &mut mint_core::MintConfig, chat_req: &ChatRequest) {
+    let active_model = config.active_model().to_string();
+    if let Some(temp) = chat_req.temperature {
+        config.temperature = Some(temp);
+        config.set_model_temperature(&active_model, Some(temp));
+    }
+    if chat_req.thinking_enabled.is_some() || chat_req.thinking_effort.is_some() {
+        let (cur_enabled, cur_effort) = config.resolved_thinking();
+        let enabled = chat_req.thinking_enabled.unwrap_or(cur_enabled);
+        let effort = chat_req
+            .thinking_effort
+            .as_deref()
+            .unwrap_or(cur_effort)
+            .to_string();
+        config.thinking_enabled = enabled;
+        config.thinking_effort = effort.clone();
+        config.set_model_thinking(&active_model, enabled, &effort);
+    }
+}
+
 #[tauri::command]
 pub(crate) async fn send_chat_message(
     app: AppHandle,
@@ -52,6 +72,7 @@ pub(crate) async fn send_chat_message(
     }
     let (request, receipt) =
         mint_core::library::prepare_chat(&request, attachment_metadata.as_ref(), &config).await?;
+    apply_request_overrides_to_config(&mut config, &request);
 
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
@@ -225,6 +246,7 @@ pub(crate) async fn stream_chat_message(
     }
     let (request, receipt) =
         mint_core::library::prepare_chat(&request, attachment_metadata.as_ref(), &config).await?;
+    apply_request_overrides_to_config(&mut config, &request);
 
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
@@ -417,144 +439,186 @@ pub(crate) async fn cancel_chat_message(chat_id: String) -> Result<(), String> {
     Ok(())
 }
 
+async fn run_blocking_db<T, F>(task: F) -> Result<T, String>
+where
+    T: Send + 'static,
+    F: FnOnce() -> Result<T, String> + Send + 'static,
+{
+    tokio::task::spawn_blocking(task)
+        .await
+        .map_err(|error| error.to_string())?
+}
+
+async fn with_default_memory<T, F>(task: F) -> Result<T, String>
+where
+    T: Send + 'static,
+    F: FnOnce(MemoryStore) -> Result<T, mint_core::agent::memory::MemoryError> + Send + 'static,
+{
+    run_blocking_db(move || {
+        MemoryStore::open_default()
+            .and_then(task)
+            .map_err(|error| error.to_string())
+    })
+    .await
+}
+
 #[tauri::command]
-pub(crate) fn save_interaction_agent_activity(
+pub(crate) async fn save_interaction_agent_activity(
     interaction_id: i64,
     activity: Vec<AgentProgress>,
 ) -> Result<(), String> {
-    let activity_json = serde_json::to_string(&activity).map_err(|error| error.to_string())?;
-    MemoryStore::open_default()
-        .and_then(|memory| {
-            memory
-                .set_interaction_agent_activity_json(interaction_id, &activity_json)
-                .map(|_| ())
-        })
-        .map_err(|error| error.to_string())
+    run_blocking_db(move || {
+        let activity_json = serde_json::to_string(&activity).map_err(|error| error.to_string())?;
+        MemoryStore::open_default()
+            .and_then(|memory| {
+                memory
+                    .set_interaction_agent_activity_json(interaction_id, &activity_json)
+                    .map(|_| ())
+            })
+            .map_err(|error| error.to_string())
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn save_system_interaction(
+pub(crate) async fn save_system_interaction(
     chat_id: String,
     user_text: String,
     ai_text: Option<String>,
     provider: String,
     model: String,
 ) -> Result<i64, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| {
-            memory.add_interaction_for_chat(
-                &chat_id,
-                &user_text,
-                ai_text.as_deref().unwrap_or(""),
-                &provider,
-                &model,
-            )
-        })
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| {
+        memory.add_interaction_for_chat(
+            &chat_id,
+            &user_text,
+            ai_text.as_deref().unwrap_or(""),
+            &provider,
+            &model,
+        )
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn update_chat_session_workspace(
+pub(crate) async fn update_chat_session_workspace(
     chat_id: String,
     workspace_path: Option<String>,
 ) -> Result<(), String> {
-    MemoryStore::open_default()
-        .and_then(|memory| memory.set_chat_session_workspace(&chat_id, workspace_path.as_deref()))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| {
+        memory.set_chat_session_workspace(&chat_id, workspace_path.as_deref())
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn get_recent_interactions(
+pub(crate) async fn get_recent_interactions(
     limit: Option<usize>,
     chat_id: Option<String>,
     workspace_path: Option<String>,
 ) -> Result<Vec<InteractionMemory>, String> {
-    let scoped_chat_id = mint_core::scoped_chat_id(
-        chat_id
-            .as_deref()
-            .unwrap_or(mint_core::DEFAULT_CONVERSATION_ID),
-        workspace_path.as_deref(),
-    );
-    MemoryStore::open_default()
-        .and_then(|memory| memory.recent_interactions_for_chat(&scoped_chat_id, limit.unwrap_or(5)))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| {
+        let scoped_chat_id = mint_core::scoped_chat_id(
+            chat_id
+                .as_deref()
+                .unwrap_or(mint_core::DEFAULT_CONVERSATION_ID),
+            workspace_path.as_deref(),
+        );
+        memory.recent_interactions_for_chat(&scoped_chat_id, limit.unwrap_or(5))
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn get_conversation_snapshot(
+pub(crate) async fn get_conversation_snapshot(
     chat_id: String,
     before_id: Option<i64>,
     limit: Option<usize>,
 ) -> Result<ConversationSnapshot, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| memory.conversation_snapshot(&chat_id, before_id, limit.unwrap_or(50)))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| {
+        memory.conversation_snapshot(&chat_id, before_id, limit.unwrap_or(50))
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn get_conversation_sources(
+pub(crate) async fn get_conversation_sources(
     chat_id: String,
 ) -> Result<mint_core::agent::memory::ConversationSources, String> {
-    MemoryStore::open_default()
-        .and_then(|store| store.conversation_sources(&chat_id))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |store| store.conversation_sources(&chat_id)).await
 }
 
 #[tauri::command]
-pub(crate) fn save_source_attachments(
+pub(crate) async fn save_source_attachments(
     chat_id: String,
     interaction_id: i64,
     attachments: Vec<mint_core::agent::memory::SourceAttachment>,
 ) -> Result<(), String> {
-    MemoryStore::open_default()
-        .map_err(|error| error.to_string())?
-        .save_source_attachments(&chat_id, interaction_id, &attachments)
+    run_blocking_db(move || {
+        MemoryStore::open_default()
+            .map_err(|error| error.to_string())?
+            .save_source_attachments(&chat_id, interaction_id, &attachments)
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn get_conversation_changes(
+pub(crate) async fn get_conversation_changes(
     chat_id: String,
     after: i64,
     limit: Option<usize>,
 ) -> Result<ConversationChanges, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| memory.conversation_changes(&chat_id, after, limit.unwrap_or(100)))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| {
+        memory.conversation_changes(&chat_id, after, limit.unwrap_or(100))
+    })
+    .await
 }
 
 #[tauri::command]
-pub(crate) fn list_chat_sessions() -> Result<Vec<ChatSession>, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| memory.list_chat_sessions())
-        .map_err(|error| error.to_string())
+pub(crate) async fn list_chat_sessions() -> Result<Vec<ChatSession>, String> {
+    with_default_memory(|memory| memory.list_chat_sessions()).await
 }
 
 #[tauri::command]
-pub(crate) fn delete_chat_session(chat_id: String) -> Result<usize, String> {
+pub(crate) async fn delete_chat_session(chat_id: String) -> Result<usize, String> {
     mint_core::cancel_agent(&chat_id);
-    MemoryStore::open_default()
-        .and_then(|memory| memory.delete_chat_session(&chat_id))
-        .map_err(|error| error.to_string())
+    with_default_memory(move |memory| memory.delete_chat_session(&chat_id)).await
 }
 
 #[tauri::command]
-pub(crate) fn rename_chat_session(chat_id: String, new_title: String) -> Result<usize, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| memory.rename_chat_session(&chat_id, &new_title))
-        .map_err(|error| error.to_string())
+pub(crate) async fn rename_chat_session(
+    chat_id: String,
+    new_title: String,
+) -> Result<usize, String> {
+    with_default_memory(move |memory| memory.rename_chat_session(&chat_id, &new_title)).await
 }
 
 #[tauri::command]
-pub(crate) fn clear_chat_history(chat_id: Option<String>) -> Result<usize, String> {
-    MemoryStore::open_default()
-        .and_then(|memory| {
-            memory.clear_interactions_for_chat(
-                chat_id
-                    .as_deref()
-                    .unwrap_or(mint_core::DEFAULT_CONVERSATION_ID),
-            )
-        })
-        .map_err(|error| error.to_string())
+pub(crate) async fn clear_chat_history(chat_id: Option<String>) -> Result<usize, String> {
+    with_default_memory(move |memory| {
+        memory.clear_interactions_for_chat(
+            chat_id
+                .as_deref()
+                .unwrap_or(mint_core::DEFAULT_CONVERSATION_ID),
+        )
+    })
+    .await
+}
+
+#[tauri::command]
+pub(crate) async fn truncate_interactions_from(
+    chat_id: Option<String>,
+    from_id: i64,
+) -> Result<usize, String> {
+    with_default_memory(move |memory| {
+        memory.truncate_interactions_from(
+            chat_id
+                .as_deref()
+                .unwrap_or(mint_core::DEFAULT_CONVERSATION_ID),
+            from_id,
+        )
+    })
+    .await
 }
 
 #[tauri::command]

package/src-tauri/src/commands/integrations.rs

@@ -43,10 +43,16 @@ pub(crate) async fn test_mcp_connection(
 }
 
 #[tauri::command]
-pub(crate) async fn read_mcp_artifact(id: String) -> Result<String, String> {
+pub(crate) async fn read_mcp_artifact(
+    id: String,
+    chat_id: Option<String>,
+) -> Result<String, String> {
     tokio::task::spawn_blocking(move || {
         use base64::Engine as _;
         let (entry, bytes) = mint_core::integrations::mcp_result::read_artifact(&id)?;
+        if chat_id.as_deref() != Some(entry.chat_id.as_str()) {
+            return Err("Artifact unavailable in this conversation".into());
+        }
         let mime = if entry.kind == "image" {
             entry.mime_type
         } else {

package/src-tauri/src/commands/media.rs

@@ -177,3 +177,10 @@ pub(crate) async fn remove_library_item(id: String) -> Result<(), String> {
     .await
     .map_err(|e| e.to_string())?
 }
+
+#[tauri::command]
+pub(crate) async fn speech_request(
+    request: mint_core::tts::playback::SpeechRequest,
+) -> Result<mint_core::tts::playback::SpeechReply, String> {
+    mint_core::tts::playback::request(request).await
+}

package/src-tauri/src/commands/workspace.rs

@@ -489,6 +489,44 @@ pub(crate) fn undo_git_checkpoint(workspace_path: Option<String>) -> Result<Stri
     mint_core::git::undo_rollback(&root)
 }
 
+#[tauri::command]
+pub(crate) async fn prepare_workspace_media(
+    app: tauri::AppHandle,
+    path: String,
+    workspace_path: String,
+) -> Result<mint_core::workspace::PreparedWorkspaceMedia, String> {
+    use tauri::Manager;
+    let media = tokio::task::spawn_blocking(move || {
+        mint_core::workspace::prepare_media(
+            std::path::Path::new(&workspace_path),
+            &path,
+            &load_config().map_err(|error| error.to_string())?,
+        )
+    })
+    .await
+    .map_err(|error| format!("media preparation failed: {error}"))??;
+    app.asset_protocol_scope()
+        .allow_file(&media.path)
+        .map_err(|error| error.to_string())?;
+    Ok(media)
+}
+
+#[tauri::command]
+pub(crate) async fn read_workspace_image(
+    path: String,
+    workspace_path: String,
+) -> Result<String, String> {
+    tokio::task::spawn_blocking(move || {
+        mint_core::workspace::read_image(
+            std::path::Path::new(&workspace_path),
+            &path,
+            &load_config().map_err(|error| error.to_string())?,
+        )
+    })
+    .await
+    .map_err(|error| format!("image read task failed: {error}"))?
+}
+
 #[tauri::command]
 pub(crate) fn read_workspace_file(
     path: String,

package/src-tauri/src/native/mod.rs

@@ -1,6 +1,5 @@
 //! Native platform IO, windows, terminal ownership and Desktop integrations.
 pub(crate) mod actions;
-pub(crate) mod browser;
 pub(crate) mod capture;
 pub(crate) mod discord_rpc;
 pub(crate) mod integrations;

package/src-tauri/src/native/system.rs

@@ -29,62 +29,19 @@ pub async fn smart_context() -> SmartContext {
         captured_at: unix_timestamp().to_string(),
         platform: std::env::consts::OS,
         host: hostname(),
-        browser: browser_context(&active_window).await,
+        browser: browser_context().await,
         active_window,
         current_app,
         selected_text: selected_text(),
     }
 }
 
-async fn browser_context(active_window: &Option<Value>) -> Option<Value> {
-    let is_chromium = active_window
-        .as_ref()
-        .and_then(|window| window["appName"].as_str())
-        .map(str::to_ascii_lowercase)
-        .is_some_and(|name| {
-            ["chrome", "chromium", "brave", "edge"]
-                .iter()
-                .any(|browser| name.contains(browser))
-        });
-    if is_chromium && let Some(context) = chromium_context().await {
-        return Some(context);
-    }
+/// Active-tab context comes from the optional browser extension only; Mint no
+/// longer reads a remote-debugging port.
+async fn browser_context() -> Option<Value> {
     browser_extension_context().await
 }
 
-async fn chromium_context() -> Option<Value> {
-    let endpoint = load_config()
-        .ok()
-        .and_then(|config| {
-            config
-                .extra
-                .get("browserDebugUrl")
-                .and_then(Value::as_str)
-                .map(str::to_owned)
-        })
-        .unwrap_or_else(|| "http://127.0.0.1:9222/json/list".into());
-    let pages: Value = mint_core::HTTP_CLIENT
-        .clone()
-        .get(endpoint)
-        .send()
-        .await
-        .ok()?
-        .json()
-        .await
-        .ok()?;
-    pages
-        .as_array()?
-        .iter()
-        .find(|page| page["type"] == "page")
-        .map(|page| {
-            json!({
-                "title": page["title"],
-                "url": page["url"],
-                "source": "chromium-remote-debug"
-            })
-        })
-}
-
 async fn browser_extension_context() -> Option<Value> {
     let endpoint = load_config()
         .ok()

package/tsconfig.json

@@ -28,5 +28,19 @@
       "@shared/*": ["./src/renderer/shared/*"]
     }
   },
-  "include": ["src/renderer/src", "src/renderer/src-web", "src/renderer/src/env.d.ts"]
+  "include": [
+    "src/renderer/src",
+    "src/renderer/src-web",
+    "src/renderer/shared",
+    "src/renderer/src/env.d.ts",
+    "src/renderer/src-web/env.d.ts",
+    "src/renderer/shared/env.d.ts"
+  ],
+  "exclude": [
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "src/renderer/tests"
+  ]
 }

package/vite.config.ts

@@ -3,6 +3,7 @@ import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
 import { resolve } from 'path'
+import { pdfjsAssets } from './src/bin/pdfjs-assets.mjs'
 
 export default defineConfig({
   root: resolve(__dirname, 'src/renderer'),
@@ -25,7 +26,7 @@ export default defineConfig({
       ]
     }
   },
-  plugins: [react(), tailwindcss()],
+  plugins: [react(), tailwindcss(), pdfjsAssets()],
   resolve: {
     alias: {
       '@/components/ui': resolve(__dirname, 'src/renderer/shared/components/ui'),

package/vite.config.web.ts

@@ -3,6 +3,7 @@ import { defineConfig } from 'vite'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
 import { resolve } from 'path'
+import { pdfjsAssets } from './src/bin/pdfjs-assets.mjs'
 
 export default defineConfig({
   root: resolve(__dirname, 'src/renderer'),
@@ -54,6 +55,7 @@ export default defineConfig({
   plugins: [
     react(),
     tailwindcss(),
+    pdfjsAssets(),
     {
       name: 'rewrite-html',
       configureServer(server) {