@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-core/src/agent/memory.rs

@@ -833,6 +833,25 @@ impl MemoryStore {
         )?)
     }
 
+    pub fn truncate_interactions_from(
+        &self,
+        chat_id: &str,
+        from_id: i64,
+    ) -> Result<usize, MemoryError> {
+        let chat_id = normalized_chat_id(chat_id);
+        let connection = self.connection()?;
+        let _ = connection.execute(
+            "DELETE FROM conversation_source_attachments WHERE interaction_id IN (
+                SELECT id FROM interaction_memories WHERE chat_id = ?1 AND id >= ?2
+            )",
+            params![chat_id, from_id],
+        );
+        Ok(connection.execute(
+            "DELETE FROM interaction_memories WHERE chat_id = ?1 AND id >= ?2",
+            params![chat_id, from_id],
+        )?)
+    }
+
     pub fn delete_chat_session(&self, chat_id: &str) -> Result<usize, MemoryError> {
         let chat_id = normalized_chat_id(chat_id);
         if chat_id == CHAT_CLI_ID {
@@ -1296,8 +1315,8 @@ fn restrict_to_owner(path: &Path) {
 fn restrict_to_owner(_path: &Path) {}
 
 pub fn memory_path() -> Result<PathBuf, MemoryError> {
-    dirs::config_dir()
-        .map(|directory| directory.join("mint").join("mint-knowledge.sqlite"))
+    crate::mint_config_dir()
+        .map(|directory| directory.join("mint-knowledge.sqlite"))
         .ok_or(MemoryError::ConfigDirectoryUnavailable)
 }
 
@@ -2102,6 +2121,41 @@ mod conversation_sync_tests {
         );
     }
 
+    #[test]
+    fn truncate_interactions_from_deletes_specified_and_subsequent_rows() {
+        let memory = store();
+        let id1 = memory
+            .add_interaction_for_chat("cli::test", "prompt 1", "reply 1", "test", "model")
+            .unwrap();
+        let id2 = memory
+            .add_interaction_for_chat("cli::test", "prompt 2", "reply 2", "test", "model")
+            .unwrap();
+        let id3 = memory
+            .add_interaction_for_chat("cli::test", "prompt 3", "reply 3", "test", "model")
+            .unwrap();
+
+        let cursor = memory.latest_conversation_sequence("cli::test").unwrap();
+        let deleted_count = memory.truncate_interactions_from("cli::test", id2).unwrap();
+        assert_eq!(deleted_count, 2);
+
+        let remaining = memory.interactions_for_chat("cli::test").unwrap();
+        assert_eq!(remaining.len(), 1);
+        assert_eq!(remaining[0].id, id1);
+
+        let changes = memory
+            .conversation_changes("cli::test", cursor, 100)
+            .unwrap();
+        let tombstones: Vec<i64> = changes
+            .changes
+            .iter()
+            .filter(|c| c.interaction.is_none())
+            .map(|c| c.interaction_id)
+            .collect();
+        assert!(tombstones.contains(&id2));
+        assert!(tombstones.contains(&id3));
+        assert!(!tombstones.contains(&id1));
+    }
+
     #[test]
     fn heartbeat_does_not_emit_visible_changes() {
         let memory = store();

package/crates/mint-core/src/agent/tasks.rs

@@ -260,8 +260,8 @@ impl TaskStore {
 }
 
 pub fn tasks_path() -> Result<PathBuf, TaskError> {
-    dirs::config_dir()
-        .map(|directory| directory.join("mint").join("tasks.json"))
+    crate::mint_config_dir()
+        .map(|directory| directory.join("tasks.json"))
         .ok_or(TaskError::ConfigDirectoryUnavailable)
 }
 

package/crates/mint-core/src/api_server/routes/chat.rs

@@ -53,6 +53,26 @@ impl ApiChatRequest {
     }
 }
 
+fn apply_request_overrides_to_config(config: &mut 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);
+    }
+}
+
 pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpStream) {
     let owner = match background_request_owner(ctx.request_str) {
         Ok(owner) => owner,
@@ -98,9 +118,10 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
     match (method, route) {
         ("POST", "/api/chat") => {
             if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
-                let config = load_config().unwrap_or_default();
+                let mut config = load_config().unwrap_or_default();
                 let metadata = req.attachment_metadata.clone();
                 let chat_req = req.into_chat_request(&config);
+                apply_request_overrides_to_config(&mut config, &chat_req);
                 let (mut chat_req, receipt) =
                     match crate::library::prepare_chat(&chat_req, metadata.as_ref(), &config).await
                     {
@@ -229,9 +250,10 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
 
         ("POST", "/api/chat-stream") => {
             if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
-                let config = load_config().unwrap_or_default();
+                let mut config = load_config().unwrap_or_default();
                 let metadata = req.attachment_metadata.clone();
                 let chat_req = req.into_chat_request(&config);
+                apply_request_overrides_to_config(&mut config, &chat_req);
                 let (mut chat_req, receipt) =
                     match crate::library::prepare_chat(&chat_req, metadata.as_ref(), &config).await
                     {

package/crates/mint-core/src/api_server/routes/gemini_live.rs

@@ -67,11 +67,24 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
             let chat_id = query_param(query, "chatId").unwrap_or_default();
 
             let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<String>();
+            let tx_approval = tx.clone();
             let handle = crate::gemini_live::start_session(
                 config,
                 root,
                 chat_id,
-                |_| Ok(ApprovalOutcome::Denied),
+                move |approval| {
+                    crate::PENDING_APPROVALS.request_blocking(|token| {
+                        let event = crate::gemini_live::GeminiLiveEvent::ApprovalRequested {
+                            token: token.to_owned(),
+                            approval: approval.clone(),
+                        };
+                        let json_val =
+                            serde_json::to_string(&event).map_err(|error| error.to_string())?;
+                        tx_approval
+                            .send(json_val)
+                            .map_err(|error| error.to_string())
+                    })
+                },
                 move |event| {
                     if let Ok(json_val) = serde_json::to_string(&event) {
                         let _ = tx.send(json_val);

package/crates/mint-core/src/api_server/routes/html_preview.rs

@@ -32,8 +32,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
             .as_str()
             .ok_or("Missing preview path")?
             .to_string();
-        let mint = body["mintBrowser"].as_bool().unwrap_or(false);
-        let mut config = load_config().map_err(|e| e.to_string())?;
+        let config = load_config().map_err(|e| e.to_string())?;
         let worker_config = config.clone();
         let preview = tokio::task::spawn_blocking(move || {
             crate::system::html_preview::start(
@@ -54,12 +53,6 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
             .map_err(|e| e.to_string())?
             .error_for_status()
             .map_err(|e| e.to_string())?;
-        if mint {
-            if crate::enable_browser_tools(&mut config) {
-                crate::save_config(&config).map_err(|e| e.to_string())?;
-            }
-            crate::browser::spawn_automation_browser_with_url(&config, Some(url)).await?;
-        }
         Ok::<_, String>(preview)
     }
     .await;

package/crates/mint-core/src/api_server/routes/sessions.rs

@@ -211,6 +211,27 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
             }
         }
 
+        ("POST", "/api/interactions/truncate") => {
+            let chat_id =
+                query_param(query, "chatId").unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+            let from_id = query_param(query, "fromId")
+                .and_then(|id| id.parse::<i64>().ok())
+                .unwrap_or(0);
+            let result =
+                with_memory(move |memory| memory.truncate_interactions_from(&chat_id, from_id))
+                    .await;
+            if result.is_ok() {
+                send_json_response(socket, "200 OK", "{\"status\":\"ok\"}").await;
+            } else {
+                send_json_response(
+                    socket,
+                    "500 Internal Server Error",
+                    "{\"status\":\"error\"}",
+                )
+                .await;
+            }
+        }
+
         ("POST", "/api/interactions") => {
             #[derive(Deserialize)]
             #[serde(rename_all = "camelCase")]

package/crates/mint-core/src/avatar_bridge.rs

@@ -358,28 +358,6 @@ fn resolve_tool_signal(action: &str, had_error: bool, is_start: bool) -> Option<
             return None; // silent on success — avatar_signal from the model is the source of truth
         }),
 
-        "browser_open"
-        | "browser_click"
-        | "browser_type"
-        | "browser_read"
-        | "browser_mouse_move"
-        | "browser_mouse_click"
-        | "browser_key_press"
-        | "browser_screenshot" => Some(if is_start {
-            AvatarSignal {
-                action: Some("searching"),
-                prop: Some("magnifying_glass"),
-                ..AvatarSignal::emotions(&[("interest", "high")])
-            }
-        } else if had_error {
-            AvatarSignal {
-                action: Some("dismissive"),
-                ..AvatarSignal::emotions(&[("fear", "medium"), ("surprise", "low")])
-            }
-        } else {
-            return None;
-        }),
-
         "generate_image"
         | "image_studio.generate"
         | "generate_video"

package/crates/mint-core/src/browser/cdp.rs

@@ -159,13 +159,19 @@ pub(super) fn validate_response(value: &Value) -> Result<(), String> {
     Ok(())
 }
 
-pub(super) async fn fetch_pages(config: &MintConfig) -> Result<Vec<Value>, String> {
-    let endpoint = config
+/// Debug endpoint of the managed headless browser for this run. Mint never
+/// borrows a browser on a well-known port: without a managed run the fallback
+/// is an unreachable address so calls fail instead of hijacking another browser.
+pub(super) fn debug_endpoint(config: &MintConfig) -> &str {
+    config
         .extra
         .get("browserDebugUrl")
         .and_then(Value::as_str)
-        .unwrap_or("http://127.0.0.1:9222/json/list");
-    fetch_pages_endpoint(endpoint).await
+        .unwrap_or("http://127.0.0.1:0/json/list")
+}
+
+pub(super) async fn fetch_pages(config: &MintConfig) -> Result<Vec<Value>, String> {
+    fetch_pages_endpoint(debug_endpoint(config)).await
 }
 
 pub(super) async fn fetch_pages_endpoint(endpoint: &str) -> Result<Vec<Value>, String> {