@pheem49/mint 1.14.0 → 1.15.0

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

@@ -136,7 +136,7 @@ pub fn learned_skills_context(
     let mut has_history = false;
     if let Some(cid) = chat_id {
         if let Ok(memory) = MemoryStore::open_default() {
-            if let Ok(interactions) = memory.recent_interactions_for_chat(cid, 1) {
+            if let Ok(interactions) = memory.recent_completed_interactions_for_chat(cid, 1) {
                 has_history = !interactions.is_empty();
             }
         }

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

@@ -33,6 +33,10 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                 pinned_mcp_server: Option<String>,
                 #[serde(default)]
                 temperature: Option<f64>,
+                #[serde(default)]
+                thinking_enabled: Option<bool>,
+                #[serde(default)]
+                thinking_effort: Option<String>,
             }
 
             if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
@@ -52,6 +56,9 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                     messages: None,
                     tools: None,
                     temperature: req.temperature.or(config.temperature),
+                    thinking_enabled: req.thinking_enabled,
+                    thinking_effort: req.thinking_effort,
+                    ..Default::default()
                 };
                 let mut chat_req = match chat_req.with_document_context(&config) {
                     Ok(req) => req,
@@ -200,6 +207,10 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                 pinned_mcp_server: Option<String>,
                 #[serde(default)]
                 temperature: Option<f64>,
+                #[serde(default)]
+                thinking_enabled: Option<bool>,
+                #[serde(default)]
+                thinking_effort: Option<String>,
             }
 
             if let Ok(req) = serde_json::from_str::<ApiChatRequest>(body) {
@@ -219,6 +230,9 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                     messages: None,
                     tools: None,
                     temperature: req.temperature.or(config.temperature),
+                    thinking_enabled: req.thinking_enabled,
+                    thinking_effort: req.thinking_effort,
+                    ..Default::default()
                 };
                 let mut chat_req = match chat_req.with_document_context(&config) {
                     Ok(req) => req,
@@ -284,10 +298,18 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                             let config_clone = config.clone();
                             let chat_req_clone = chat_req.clone();
                             let tx_done = tx.clone();
+                            let tx_started = tx.clone();
                             let chat_id_str = chat_req.chat_id.clone().unwrap_or_default();
                             let auth_label_clone = auth_label.clone();
                             let join_handle = tokio::spawn(async move {
-                                let result = orchestrate_chat_stream_with_fallback(
+                                let expected_chat_id = chat_req_clone
+                                    .chat_id
+                                    .clone()
+                                    .unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+                                let result = crate::with_turn_start_listener(expected_chat_id, move |id| {
+                                    let event = serde_json::json!({ "type": "started", "interactionId": id });
+                                    let _ = tx_started.send(format!("{}\n", event));
+                                }, orchestrate_chat_stream_with_fallback(
                                     &config_clone,
                                     &chat_req_clone,
                                     move |chunk| {
@@ -300,7 +322,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                                             let _ = tx_chunk_inner.send(format!("{}\n", json_val));
                                         }
                                     },
-                                )
+                                ))
                                 .await;
 
                                 match result {
@@ -393,6 +415,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                             let agent_id = chat_req.agent_id.clone();
                             let pinned_mcp_server = chat_req.pinned_mcp_server.clone();
                             let tx_approval = tx.clone();
+                            let tx_started = tx.clone();
 
                             let join_handle = tokio::spawn(async move {
                                 // Real (not auto-deny) approval flow: the request-payload
@@ -421,7 +444,10 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                                     })
                                     .unwrap_or(ApprovalOutcome::Denied))
                                 };
-                                let result = orchestrate_agent_loop(
+                                let result = crate::with_turn_start_listener(agent_scoped_chat_id.clone(), move |id| {
+                                    let event = serde_json::json!({ "type": "started", "interactionId": id });
+                                    let _ = tx_started.send(format!("{}\n", event));
+                                }, orchestrate_agent_loop(
                                     &config_clone,
                                     &message,
                                     &root,
@@ -437,7 +463,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                                     approve_cb,
                                     progress_cb,
                                     on_chunk,
-                                )
+                                ))
                                 .await;
 
                                 match result {
@@ -447,7 +473,7 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, mut socket: TcpS
                                             model: res.model,
                                             text: res.summary,
                                             fallback_provider: res.fallback,
-                                            fallback_reason: None,
+                                            fallback_reason: res.fallback_reason,
                                             tool_calls: None,
                                             stop_reason: None,
                                             total_tokens: None,

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

@@ -15,6 +15,116 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
         auth_label: _auth_label,
     } = ctx;
     match (method, route) {
+        ("GET", route)
+            if route.starts_with("/api/linked-folders/") && route.ends_with("/status") =>
+        {
+            let name = percent_decode(
+                route
+                    .trim_start_matches("/api/linked-folders/")
+                    .trim_end_matches("/status"),
+            );
+            match crate::linked_folder_status(&name) {
+                Ok(status) => {
+                    send_json_response(socket, "200 OK", &json!(status).to_string()).await
+                }
+                Err(err) => {
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        &json!({"error":err.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
+        ("POST", route)
+            if route.starts_with("/api/linked-folders/") && route.ends_with("/refresh") =>
+        {
+            let name = percent_decode(
+                route
+                    .trim_start_matches("/api/linked-folders/")
+                    .trim_end_matches("/refresh"),
+            );
+            match crate::refresh_linked_folder(&name) {
+                Ok(status) => {
+                    send_json_response(socket, "200 OK", &json!(status).to_string()).await
+                }
+                Err(err) => {
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        &json!({"error":err.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
+        ("GET", route)
+            if route.starts_with("/api/linked-folders/") && route.ends_with("/notes") =>
+        {
+            let name = percent_decode(
+                route
+                    .trim_start_matches("/api/linked-folders/")
+                    .trim_end_matches("/notes"),
+            );
+            match crate::list_linked_folder_notes(&name) {
+                Ok(notes) => send_json_response(socket, "200 OK", &json!(notes).to_string()).await,
+                Err(err) => {
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        &json!({"error":err.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
+        ("POST", route)
+            if route.starts_with("/api/linked-folders/") && route.ends_with("/notes") =>
+        {
+            let name = percent_decode(
+                route
+                    .trim_start_matches("/api/linked-folders/")
+                    .trim_end_matches("/notes"),
+            );
+            let content = serde_json::from_str::<serde_json::Value>(body)
+                .ok()
+                .and_then(|v| v.get("content").and_then(|c| c.as_str()).map(str::to_owned))
+                .unwrap_or_default();
+            match crate::save_linked_folder_note(&name, &content) {
+                Ok(note) => send_json_response(socket, "200 OK", &json!(note).to_string()).await,
+                Err(err) => {
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        &json!({"error":err.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
+        ("GET", route)
+            if route.starts_with("/api/linked-folders/") && route.contains("/notes/") =>
+        {
+            let remainder = route.trim_start_matches("/api/linked-folders/");
+            let Some((name, id)) = remainder.split_once("/notes/") else {
+                unreachable!()
+            };
+            match crate::read_linked_folder_note(&percent_decode(name), &percent_decode(id)) {
+                Ok(content) => {
+                    send_json_response(socket, "200 OK", &json!({"content":content}).to_string())
+                        .await
+                }
+                Err(err) => {
+                    send_json_response(
+                        socket,
+                        "400 Bad Request",
+                        &json!({"error":err.to_string()}).to_string(),
+                    )
+                    .await
+                }
+            }
+        }
         ("GET", "/api/linked-folders") => {
             let folders = load_config()
                 .ok()
@@ -70,8 +180,13 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
             }
         }
 
-        _ => unreachable!(
-            "api_server routed an unhandled route into routes::linked_folders::execute: {method} {route}"
-        ),
+        _ => {
+            send_json_response(
+                socket,
+                "404 Not Found",
+                "{\"error\":\"unknown linked-folder route\"}",
+            )
+            .await
+        }
     }
 }

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

@@ -413,21 +413,17 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
                 .find_map(|kv| kv.strip_prefix("baseUrl="))
                 .map(|v| percent_decode(v));
 
-            let dynamic = crate::slash::model_fetcher::fetch_provider_models(
-                &provider,
-                &api_key,
-                base_url_opt.as_deref(),
-            )
-            .await;
-
-            let models = if !dynamic.is_empty() {
-                dynamic
-            } else {
-                // Fallback: static presets so the UI is never empty.
-                match load_config() {
-                    Ok(cfg) => crate::slash::models::model_options_for_provider(&cfg, &provider),
-                    Err(_) => Vec::new(),
+            let models = match load_config() {
+                Ok(cfg) => {
+                    crate::slash::models::model_options_for_provider_with_credentials_async(
+                        &cfg,
+                        &provider,
+                        &api_key,
+                        base_url_opt.as_deref(),
+                    )
+                    .await
                 }
+                Err(_) => Vec::new(),
             };
 
             send_json_response(

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

@@ -15,6 +15,50 @@ pub(in crate::api_server) async fn execute(ctx: RequestCtx<'_>, socket: TcpStrea
         auth_label: _auth_label,
     } = ctx;
     match (method, route) {
+        ("GET", "/api/conversation-snapshot") => {
+            let chat_id =
+                query_param(query, "chatId").unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+            let before_id = query_param(query, "beforeId").and_then(|s| s.parse::<i64>().ok());
+            let limit = query_param(query, "limit")
+                .and_then(|s| s.parse::<usize>().ok())
+                .unwrap_or(50);
+            match MemoryStore::open_default()
+                .and_then(|m| m.conversation_snapshot(&chat_id, before_id, limit))
+            {
+                Ok(snapshot) => {
+                    send_json_response(
+                        socket,
+                        "200 OK",
+                        &serde_json::to_string(&snapshot).unwrap_or_default(),
+                    )
+                    .await
+                }
+                Err(_) => send_json_response(socket, "500 Internal Server Error", "{}").await,
+            }
+        }
+        ("GET", "/api/conversation-changes") => {
+            let chat_id =
+                query_param(query, "chatId").unwrap_or_else(|| DEFAULT_CONVERSATION_ID.to_owned());
+            let after = query_param(query, "after")
+                .and_then(|s| s.parse::<i64>().ok())
+                .unwrap_or(0);
+            let limit = query_param(query, "limit")
+                .and_then(|s| s.parse::<usize>().ok())
+                .unwrap_or(100);
+            match MemoryStore::open_default()
+                .and_then(|m| m.conversation_changes(&chat_id, after, limit))
+            {
+                Ok(changes) => {
+                    send_json_response(
+                        socket,
+                        "200 OK",
+                        &serde_json::to_string(&changes).unwrap_or_default(),
+                    )
+                    .await
+                }
+                Err(_) => send_json_response(socket, "500 Internal Server Error", "{}").await,
+            }
+        }
         ("GET", "/api/interactions") => {
             let limit = query_param(query, "limit")
                 .and_then(|value| value.parse::<usize>().ok())

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

@@ -125,7 +125,12 @@ pub(crate) fn log_api_err(context: &str, error: &dyn std::fmt::Display) {
 mod routes;
 
 pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
-    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+    start_api_server_on(SocketAddr::from(([0, 0, 0, 0], port))).await
+}
+
+/// Serve the API on a caller-selected interface. Tailnet web mode uses
+/// loopback so only its local web proxy can reach the API directly.
+pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error> {
     let listener = TcpListener::bind(addr).await?;
     // API server banner removed to prevent duplicate output
 
@@ -288,6 +293,11 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                 && route != "/api/action"
                 && route != "/api/config"
                 && route != "/api/gemini-live"
+                && route != "/api/interactions"
+                && route != "/api/conversation-snapshot"
+                && route != "/api/conversation-changes"
+                && route != "/api/status"
+                && route != "/api/chat-sessions"
             {
                 log_api_req(method, route, "200 OK", Some(&auth_label));
             }
@@ -485,7 +495,7 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                     )
                     .await;
                 }
-                                ("GET", "/api/interactions") => {
+                                ("GET", "/api/interactions" | "/api/conversation-snapshot" | "/api/conversation-changes") => {
                     routes::sessions::execute(
                         routes::RequestCtx {
                             method,
@@ -742,6 +752,15 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
                         socket,
                     )
                     .await;
+                }
+                                ("GET" | "POST", route) if route.starts_with("/api/linked-folders/") => {
+                    routes::linked_folders::execute(
+                        routes::RequestCtx {
+                            method, route, query, body,
+                            request_str: &request_str, request_bytes: &request_bytes,
+                            header_end, auth_label: auth_label.clone(),
+                        }, socket,
+                    ).await;
                 }
                                 ("POST", "/api/linked-folders") => {
                     routes::linked_folders::execute(
@@ -1308,7 +1327,7 @@ async fn run_web_agent_loop(
         model: result.model,
         text: result.summary,
         fallback_provider: result.fallback,
-        fallback_reason: None,
+        fallback_reason: result.fallback_reason,
         tool_calls: None,
         stop_reason: None,
         total_tokens: None,

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

@@ -556,6 +556,8 @@ impl AvatarBridge {
                 self.transition(AvatarSignal::emotions(&[("interest", "medium")]), None);
             }
             AgentProgress::Thought { .. } => {}
+            AgentProgress::ThinkingDelta { .. } => {}
+            AgentProgress::ExtendedThinking { .. } => {}
             AgentProgress::WaitingForNetwork { .. } => {}
             AgentProgress::PlanUpdated { .. } => {}
             AgentProgress::RunCompleted { .. } => {}

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

@@ -11,105 +11,96 @@ use tokio_tungstenite::{connect_async, tungstenite::Message};
 
 use super::overlay::build_overlay_script;
 
-/// Full CDP call — injects the aura+cursor overlay before the actual call.
+/// Calls are pinned to the session target and bounded, including the handshake.
 pub(super) async fn cdp_call(
     config: &MintConfig,
     method: &str,
     params: Value,
 ) -> Result<Value, String> {
-    let page = fetch_pages(config)
-        .await?
-        .into_iter()
-        .find(|page| page["type"] == "page")
-        .ok_or("Chrome DevTools did not report an open browser page")?;
-    let socket_url = page["webSocketDebuggerUrl"]
-        .as_str()
-        .ok_or("Chrome DevTools page does not expose a websocket URL")?;
-    let (mut socket, _) = connect_async(socket_url)
-        .await
-        .map_err(|e| format!("unable to connect to Chrome DevTools websocket: {e}"))?;
-
-    let is_overlay = method == "Runtime.evaluate"
-        && params["expression"]
-            .as_str()
-            .map(|s| s.contains("mint-browser-aura"))
-            .unwrap_or(false);
-
-    if !is_overlay {
-        let overlay = build_overlay_script();
-        let _ = socket
-            .send(Message::Text(
-                json!({
-                    "id": 999,
-                    "method": "Runtime.evaluate",
-                    "params": { "expression": overlay, "returnByValue": false }
-                })
-                .to_string()
-                .into(),
-            ))
-            .await;
+    // The overlay is cosmetic; its failure must not turn an action into a retry.
+    if method != "Runtime.evaluate" {
+        let _ = cdp_call_raw(
+            config,
+            "Runtime.evaluate",
+            json!({
+                "expression": build_overlay_script(), "returnByValue": false
+            }),
+        )
+        .await;
     }
-
-    socket
-        .send(Message::Text(
-            json!({ "id": 1, "method": method, "params": params })
-                .to_string()
-                .into(),
-        ))
-        .await
-        .map_err(|e| e.to_string())?;
-
-    while let Some(message) = socket.next().await {
-        let message = message.map_err(|e| e.to_string())?;
-        let Message::Text(raw) = message else {
-            continue;
-        };
-        let value: Value = serde_json::from_str(&raw).map_err(|e| e.to_string())?;
-        if value["id"] == 1 {
-            return Ok(value);
-        }
-    }
-    Err("Chrome DevTools websocket closed before returning a response".into())
+    cdp_call_raw(config, method, params).await
 }
 
-/// Lightweight CDP call — no overlay injection. Used for Input.* and Page.captureScreenshot.
 pub(super) async fn cdp_call_raw(
     config: &MintConfig,
     method: &str,
     params: Value,
 ) -> Result<Value, String> {
-    let page = fetch_pages(config)
-        .await?
-        .into_iter()
-        .find(|page| page["type"] == "page")
-        .ok_or("Chrome DevTools did not report an open browser page")?;
-    let socket_url = page["webSocketDebuggerUrl"]
-        .as_str()
-        .ok_or("Chrome DevTools page does not expose a websocket URL")?;
-    let (mut socket, _) = connect_async(socket_url)
-        .await
-        .map_err(|e| format!("unable to connect to Chrome DevTools websocket: {e}"))?;
-
-    socket
-        .send(Message::Text(
-            json!({ "id": 1, "method": method, "params": params })
+    tokio::time::timeout(std::time::Duration::from_secs(10), async {
+        let pages = fetch_pages(config).await?;
+        let target = super::selected_tab();
+        let page = pages
+            .into_iter()
+            .find(|p| {
+                p["type"] == "page"
+                    && target
+                        .as_ref()
+                        .is_none_or(|id| p["id"].as_str() == Some(id.as_str()))
+            })
+            .ok_or_else(|| {
+                if target.is_some() {
+                    "tab_unavailable"
+                } else {
+                    "No browser page is open"
+                }
                 .to_string()
-                .into(),
-        ))
-        .await
-        .map_err(|e| e.to_string())?;
-
-    while let Some(message) = socket.next().await {
-        let message = message.map_err(|e| e.to_string())?;
-        let Message::Text(raw) = message else {
-            continue;
-        };
-        let value: Value = serde_json::from_str(&raw).map_err(|e| e.to_string())?;
-        if value["id"] == 1 {
-            return Ok(value);
+            })?;
+        let socket_url = page["webSocketDebuggerUrl"]
+            .as_str()
+            .ok_or("Missing browser websocket URL")?;
+        let (mut socket, _) = connect_async(socket_url)
+            .await
+            .map_err(|e| format!("browser_disconnected: {e}"))?;
+        socket
+            .send(Message::Text(
+                json!({ "id": 1, "method": method, "params": params })
+                    .to_string()
+                    .into(),
+            ))
+            .await
+            .map_err(|e| e.to_string())?;
+        while let Some(message) = socket.next().await {
+            let Message::Text(raw) = message.map_err(|e| e.to_string())? else {
+                continue;
+            };
+            let value: Value = serde_json::from_str(&raw).map_err(|e| e.to_string())?;
+            if value["id"] == 1 {
+                validate_response(&value)?;
+                return Ok(value);
+            }
         }
+        Err("browser_disconnected: websocket closed before response".into())
+    })
+    .await
+    .map_err(|_| {
+        "browser_timeout: outcome may be ambiguous; observe before acting again".to_string()
+    })?
+}
+
+pub(super) fn validate_response(value: &Value) -> Result<(), String> {
+    if value.get("error").is_some() {
+        return Err(response_error(value));
+    }
+    if let Some(exception) = value["result"].get("exceptionDetails") {
+        return Err(format!(
+            "browser_script_error: {}",
+            exception["exception"]["description"]
+                .as_str()
+                .or_else(|| exception["text"].as_str())
+                .unwrap_or("JavaScript evaluation failed")
+        ));
     }
-    Err("Chrome DevTools websocket closed before returning a response".into())
+    Ok(())
 }
 
 pub(super) async fn fetch_pages(config: &MintConfig) -> Result<Vec<Value>, String> {