@pheem49/mint 1.15.0 → 1.17.0

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

@@ -52,7 +52,6 @@ use crate::{
     destroy_session,
     detect_silence,
     find_paths,
-    generate_images,
     generate_srt,
     generate_video,
     get_user,
@@ -63,9 +62,9 @@ use crate::{
     orchestrate_agent_loop,
     orchestrate_chat_stream_with_fallback,
     orchestrate_chat_with_fallback,
-    profile_pictures_dir,
     register_user,
     render_timeline,
+    resolve_avatar_file_path,
     save_avatar_file,
     save_chat_images,
     save_config,
@@ -116,6 +115,44 @@ pub(crate) fn log_api_err(context: &str, error: &dyn std::fmt::Display) {
     );
 }
 
+pub(crate) fn should_log_api_route(route: &str) -> bool {
+    let route = route.split('?').next().unwrap_or(route);
+    if !route.starts_with("/api/") {
+        return false;
+    }
+
+    if route.starts_with("/api/pictures/")
+        || route.starts_with("/api/thumbnails/")
+        || route.starts_with("/api/proxy-image")
+        || route.starts_with("/api/background-jobs")
+        || route == "/api/media"
+        || route == "/api/chat"
+        || route == "/api/chat-stream"
+        || route == "/api/image-generate"
+        || route == "/api/video-generate"
+        || route == "/api/action"
+        || route == "/api/config"
+        || route == "/api/gemini-live"
+        || route == "/api/interactions"
+        || route == "/api/conversation-snapshot"
+        || route == "/api/conversation-changes"
+        || route == "/api/conversation-sources"
+        || route == "/api/status"
+        || route == "/api/chat-sessions"
+        || route == "/api/mods"
+        || route.starts_with("/api/mods/")
+        || route == "/api/models"
+        || route.starts_with("/api/models/")
+        || (route.starts_with("/api/library/")
+            && (route.ends_with("/thumbnail") || route.ends_with("/content")))
+        || route.starts_with("/api/mcp-artifacts/")
+    {
+        return false;
+    }
+
+    true
+}
+
 /// Binds the local HTTP API on `port` and blocks forever serving requests.
 /// Also starts the messaging bridges and cron scheduler as a side effect —
 /// callers (`mint api`, `mint gateway start --api-port`, ...) must not call
@@ -124,6 +161,51 @@ pub(crate) fn log_api_err(context: &str, error: &dyn std::fmt::Display) {
 /// duplicate Discord gateway connections, duplicate replies to the owner).
 mod routes;
 
+/// Observe terminal shutdown without taking ownership of the host's lifetime.
+/// Embedded hosts must also request their own exit: stopping this HTTP server
+/// alone leaves a GUI event loop alive after Tokio intercepts the OS signal.
+pub async fn shutdown_on_signal(on_shutdown: impl FnOnce()) {
+    let shutdown = async {
+        #[cfg(unix)]
+        {
+            if let Ok(mut signal) =
+                tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+            {
+                tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = signal.recv() => {} }
+                return;
+            }
+        }
+        let _ = tokio::signal::ctrl_c().await;
+    };
+    shutdown.await;
+    on_shutdown();
+}
+
+fn parse_http_request_framing(buf: &[u8]) -> Option<(usize, usize)> {
+    let header_end = buf.windows(4).position(|window| window == b"\r\n\r\n")?;
+    let headers_str = String::from_utf8_lossy(&buf[..header_end]);
+    let content_len = headers_str
+        .lines()
+        .find_map(|line| {
+            let (name, value) = line.split_once(':')?;
+            if name.trim().eq_ignore_ascii_case("content-length") {
+                value.trim().parse::<usize>().ok()
+            } else {
+                None
+            }
+        })
+        .unwrap_or(0);
+    Some((header_end, header_end + 4 + content_len))
+}
+
+fn parse_request_line(headers: &str) -> Option<(&str, &str)> {
+    let first_line = headers.split("\r\n").next().unwrap_or(headers);
+    let mut parts = first_line.split_whitespace();
+    let method = parts.next()?;
+    let path = parts.next()?;
+    Some((method, path))
+}
+
 pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
     start_api_server_on(SocketAddr::from(([0, 0, 0, 0], port))).await
 }
@@ -132,6 +214,14 @@ pub async fn start_api_server(port: u16) -> Result<(), std::io::Error> {
 /// 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?;
+    let listener_addr = listener.local_addr()?;
+    let _webhook_lease = crate::webhooks::claim_api_listener(listener_addr);
+    tokio::task::spawn_blocking(|| {
+        if let Err(error) = crate::library::LibraryStore::open_default() {
+            eprintln!("[mint] Library startup: {error}")
+        }
+    });
+    crate::companion::start();
     // API server banner removed to prevent duplicate output
 
     // Start background messaging bridges (Telegram, Discord, Slack)
@@ -139,15 +229,30 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
     // Start the cron scheduler so scheduled agent tasks fire while this server is up
     crate::start_cron_scheduler();
 
+    let shutdown = shutdown_on_signal(|| {});
+    tokio::pin!(shutdown);
     loop {
-        let (mut socket, peer_addr) = match listener.accept().await {
+        let accepted = tokio::select! {
+            accepted = listener.accept() => accepted,
+            _ = &mut shutdown => {
+                let _ = tokio::task::spawn_blocking(crate::bg_shell::shutdown).await;
+                return Ok(());
+            }
+        };
+        let (mut socket, peer_addr) = match accepted {
             Ok(val) => val,
             Err(_) => continue,
         };
+        let _ = socket.set_nodelay(true);
         // Some routes (the native folder picker) only make sense for, and are
         // only safe for, a browser on this same machine — capture that now
         // while we still have the peer address.
         let from_loopback = peer_addr.ip().is_loopback();
+        // A wildcard API listener can cover more interfaces than a webhook is
+        // configured to accept. Classify callbacks by this connection's destination.
+        let Ok(connection_addr) = socket.local_addr() else {
+            continue;
+        };
 
         tokio::spawn(async move {
             // Isolates a panic anywhere in this connection's handling (a malformed
@@ -158,7 +263,7 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
             let outcome = std::panic::AssertUnwindSafe(async move {
             let mut request_bytes = Vec::with_capacity(8192);
             let mut chunk = [0_u8; 8192];
-            let mut expected_len: Option<usize> = None;
+            let mut framing: Option<(usize, usize)> = None;
 
             loop {
                 let n = match socket.read(&mut chunk).await {
@@ -176,31 +281,28 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                     return;
                 }
 
-                let headers_str = String::from_utf8_lossy(&request_bytes);
-                if expected_len.is_none() && headers_str.contains("\r\n\r\n") {
-                    expected_len = headers_str
-                        .to_lowercase()
-                        .find("content-length:")
-                        .and_then(|content_length_pos| {
-                            let sub = &headers_str[content_length_pos..];
-                            let line_end = sub.find("\r\n")?;
-                            sub["content-length:".len()..line_end]
-                                .trim()
-                                .parse::<usize>()
-                                .ok()
-                        })
-                        .and_then(|content_len| {
-                            let header_len = headers_str.find("\r\n\r\n")? + 4;
-                            Some(header_len + content_len)
-                        });
-                }
-
-                if let Some(total_len) = expected_len {
+                if framing.is_none() {
+                    if let Some((header_end, total_len)) = parse_http_request_framing(&request_bytes) {
+                        if total_len > MAX_API_REQUEST_BYTES {
+                            send_json_response(
+                                socket,
+                                "413 Payload Too Large",
+                                "{\"provider\":\"error\",\"model\":\"error\",\"text\":\"Request is too large. Try a smaller image or fewer images.\"}",
+                            )
+                            .await;
+                            return;
+                        }
+                        if total_len > request_bytes.capacity() {
+                            request_bytes.reserve(total_len - request_bytes.len());
+                        }
+                        framing = Some((header_end, total_len));
+                    }
+                }
+
+                if let Some((_, total_len)) = framing {
                     if request_bytes.len() >= total_len {
                         break;
                     }
-                } else if headers_str.contains("\r\n\r\n") {
-                    break;
                 }
             }
 
@@ -208,25 +310,21 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                 return;
             }
 
-            let request_str = String::from_utf8_lossy(&request_bytes);
-            let lines: Vec<&str> = request_str.split("\r\n").collect();
-            if lines.is_empty() {
+            let Some((header_end, total_len)) = framing.or_else(|| parse_http_request_framing(&request_bytes)) else {
                 return;
+            };
+            if request_bytes.len() > total_len {
+                request_bytes.truncate(total_len);
             }
 
-            let req_line: Vec<&str> = lines[0].split_whitespace().collect();
-            if req_line.len() < 2 {
+            let request_str = String::from_utf8_lossy(&request_bytes);
+            let Some(str_header_end) = request_str.find("\r\n\r\n") else {
+                return;
+            };
+            let Some((method, path)) = parse_request_line(&request_str[..str_header_end]) else {
                 return;
-            }
-
-            let method = req_line[0];
-            let path = req_line[1];
-
-            let header_end = match request_str.find("\r\n\r\n") {
-                Some(idx) => idx,
-                None => return,
             };
-            let body = &request_str[header_end + 4..];
+            let body = &request_str[str_header_end + 4..];
 
             if method == "OPTIONS" {
                 let response = "HTTP/1.1 200 OK\r\n\
@@ -242,6 +340,20 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
 
             let (route, query) = path.split_once('?').unwrap_or((path, ""));
 
+            // Provider-authenticated callbacks share this listener when their configured
+            // interface and port match it. Ordinary API routes still use the API token.
+            if let Ok(config) = crate::load_config()
+                && let Some(service) = crate::webhooks::api_service(&config, connection_addr, method, path)
+            {
+                let request = crate::webhooks::Request {
+                    method: method.into(), path: path.into(),
+                    headers: request_str[..str_header_end].into(),
+                    body: request_bytes[header_end + 4..].to_vec(),
+                };
+                crate::webhooks::handle(socket, service, config, request).await;
+                return;
+            }
+
             if !api_auth_ok(&request_str) {
                 send_json_response(
                     socket,
@@ -282,27 +394,58 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                 return;
             }
 
-            if route.starts_with("/api/")
-                && !route.starts_with("/api/pictures/")
-                && !route.starts_with("/api/thumbnails/")
-                && route != "/api/media"
-                && route != "/api/chat"
-                && route != "/api/chat-stream"
-                && route != "/api/image-generate"
-                && route != "/api/video-generate"
-                && 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"
-            {
+            if should_log_api_route(route) {
                 log_api_req(method, route, "200 OK", Some(&auth_label));
             }
 
+            if method == "POST" && route == "/api/speech" {
+                let result = match serde_json::from_str::<crate::tts::playback::SpeechRequest>(body) {
+                    Ok(request) => crate::tts::playback::request(request).await,
+                    Err(error) => Err(error.to_string()),
+                };
+                match result {
+                    Ok(reply) => send_json_response(socket, "200 OK", &serde_json::to_string(&reply).unwrap()).await,
+                    Err(error) => send_json_response(socket, "400 Bad Request", &json!({"error":error}).to_string()).await,
+                }
+                return;
+            }
             match (method, route) {
+                ("GET" | "POST" | "DELETE", route) if route == "/api/library" || route.starts_with("/api/library/") => {
+                    routes::library::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET" | "POST", "/api/conversation-sources") => {
+                    routes::sources::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET", route) if route.starts_with("/api/mcp-artifacts/") => {
+                    let id = route.trim_start_matches("/api/mcp-artifacts/").to_owned();
+                    let chat=reqwest::Url::parse(&format!("http://localhost/?{query}")).ok().and_then(|url|url.query_pairs().find(|(key,_)|key=="chatId").map(|(_,value)|value.into_owned()));
+                    let artifact = tokio::task::spawn_blocking(move || {
+                        let (entry,bytes)=crate::integrations::mcp_result::read_artifact(&id)?;
+                        if chat.as_deref()!=Some(entry.chat_id.as_str()) {return Err(String::from("Artifact unavailable"));}
+                        Ok((entry,bytes))
+                    }).await;
+                    match artifact {
+                        Ok(Ok((entry, bytes))) => {
+                            let mime = if entry.kind == "image" { entry.mime_type.as_str() } else { "application/octet-stream" };
+                            let disposition = if entry.kind == "image" {"inline"} else {"attachment"};
+                            let header = format!("HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nContent-Length: {}\r\nContent-Disposition: {disposition}; filename=\"{}\"\r\nX-Content-Type-Options: nosniff\r\nAccess-Control-Allow-Origin: *\r\nConnection: close\r\n\r\n", bytes.len(), entry.id);
+                            let mut socket = socket;
+                            let _ = socket.write_all(header.as_bytes()).await;
+                            let _ = socket.write_all(&bytes).await;
+                        }
+                        _ => send_json_response(socket, "404 Not Found", "{\"error\":\"Artifact unavailable\"}").await,
+                    }
+                }
+                ("POST", "/api/html-preview") => {
+                    routes::html_preview::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
+                ("GET" | "POST" | "DELETE", route) if route == "/api/background-jobs" || route.starts_with("/api/background-jobs/") => {
+                    routes::background_jobs::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/mods") => {
+                    routes::mods::execute(routes::RequestCtx { method, route, query, body, request_str: &request_str, request_bytes: &request_bytes, header_end, auth_label: auth_label.clone() }, socket).await;
+                }
                                 ("GET", "/api/status") => {
                     routes::status_health::execute(
                         routes::RequestCtx {
@@ -543,7 +686,7 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                     )
                     .await;
                 }
-                                ("POST", "/api/chat-sessions/rename") => {
+                                ("POST", "/api/chat-sessions/rename" | "/api/chat-sessions/workspace") => {
                     routes::sessions::execute(
                         routes::RequestCtx {
                             method,
@@ -1033,6 +1176,25 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                         socket,
                     )
                     .await;
+                }
+                                ("GET", route)
+                                    if route == "/api/proxy-image"
+                                        || route.starts_with("/api/proxy-image") =>
+                                {
+                    routes::misc::execute(
+                        routes::RequestCtx {
+                            method,
+                            route,
+                            query,
+                            body,
+                            request_str: &request_str,
+                            request_bytes: &request_bytes,
+                            header_end,
+                            auth_label: auth_label.clone(),
+                        },
+                        socket,
+                    )
+                    .await;
                 }
                                 ("GET", "/api/config") => {
                     routes::misc::execute(
@@ -1131,12 +1293,17 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
                     .await;
                 }
                 ("GET", "/api/models")
+                | ("GET", "/api/live-models")
                 | ("GET", "/api/image-models")
                 | ("GET", "/api/video-models")
                 | ("GET", "/api/checkpoints")
                 | ("POST", "/api/checkpoints/rollback")
                 | ("POST", "/api/checkpoints/undo")
-                | ("GET", "/api/file/read") => {
+                | ("GET", "/api/workspace-history")
+                | ("POST", "/api/workspace-history/undo")
+                | ("GET", "/api/file/read")
+                | ("GET", "/api/file/image")
+                | ("GET", "/api/file/media") => {
                     routes::misc::execute(
                         routes::RequestCtx {
                             method,
@@ -1279,22 +1446,32 @@ pub async fn start_api_server_on(addr: SocketAddr) -> Result<(), std::io::Error>
     }
 }
 
+pub(crate) fn resolve_agent_root(workspace_path: Option<&str>) -> std::path::PathBuf {
+    if let Some(path_str) = workspace_path.map(str::trim).filter(|s| !s.is_empty()) {
+        let path = std::path::PathBuf::from(path_str);
+        if let Ok(canonical) = path.canonicalize() {
+            if canonical.is_dir() {
+                return canonical;
+            }
+        } else if path.is_dir() {
+            return path;
+        }
+    }
+    let current = std::env::current_dir().unwrap_or_default();
+    current.canonicalize().unwrap_or(current)
+}
+
 async fn run_web_agent_loop(
     config: &MintConfig,
     request: &ChatRequest,
 ) -> Result<ChatResponse, String> {
-    let root = std::env::current_dir().map_err(|error| error.to_string())?;
+    let root = resolve_agent_root(request.workspace_path.as_deref());
     let fast_mode = config
         .extra
         .get("enableFastMode")
         .and_then(Value::as_bool)
         .unwrap_or(false);
-    // Same pre-scoping as `/api/chat-stream`'s agent-mode branch in
-    // routes/chat.rs and for the same reason: `root` above deliberately
-    // stays this server process's own cwd (not the client's workspace), so
-    // `orchestrate_agent_loop`'s self-derivation from `root` alone can't
-    // distinguish workspaces here — scope from the client's `workspace_path`
-    // explicitly instead. Idempotent/safe either way (see `scoped_chat_id`).
+    // Resolve client's workspace path for parity with desktop. Idempotent on scoped_chat_id.
     let scoped_chat_id = crate::agent::memory::scoped_chat_id(
         request
             .chat_id
@@ -1314,7 +1491,7 @@ async fn run_web_agent_loop(
         None,
         request.pinned_mcp_server.as_deref(),
         fast_mode,
-        false,
+        request.plan_mode,
         |_| Ok(ApprovalOutcome::Denied),
         |_| {},
         |_| {},
@@ -1489,7 +1666,9 @@ fn picture_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
         .into_iter()
         .find(|entry| entry.filename == filename)
         .ok_or_else(|| "picture not found".to_string())?;
-    let bytes = std::fs::read(&picture.path).map_err(|error| error.to_string())?;
+    let (_, bytes) = crate::library::LibraryStore::open_default()
+        .and_then(|store| store.read(&picture.id, false))
+        .map_err(|error| error.to_string())?;
     Ok((picture.mime_type, bytes))
 }
 
@@ -1505,10 +1684,9 @@ fn thumbnail_bytes(filename: &str) -> Result<(String, Vec<u8>), String> {
         .into_iter()
         .find(|entry| entry.id == id)
         .ok_or_else(|| "picture not found".to_string())?;
-    let thumb_path = picture
-        .thumbnail_path
-        .ok_or_else(|| "thumbnail not found".to_string())?;
-    let bytes = std::fs::read(&thumb_path).map_err(|error| error.to_string())?;
+    let (_, bytes) = crate::library::LibraryStore::open_default()
+        .and_then(|store| store.read(&picture.id, true))
+        .map_err(|error| error.to_string())?;
     Ok(("image/png".to_string(), bytes))
 }
 
@@ -1591,6 +1769,25 @@ fn authorized_user_id(request_str: &str) -> Option<String> {
     session_user_id(token.trim())
 }
 
+fn background_request_owner(request: &str) -> Result<Option<String>, &'static str> {
+    let owner = authorized_user_id(request);
+    if get_header(request, "Authorization").is_some() && owner.is_none() {
+        let configured = load_config().ok().and_then(|c| {
+            c.extra
+                .get("apiAuthToken")
+                .and_then(Value::as_str)
+                .map(str::to_owned)
+        });
+        if !configured
+            .filter(|t| !t.is_empty())
+            .is_some_and(|token| token_matches(request, &token))
+        {
+            return Err("Session expired or invalid");
+        }
+    }
+    Ok(owner)
+}
+
 fn percent_decode(raw: &str) -> String {
     let bytes = raw.as_bytes();
     let mut output = Vec::with_capacity(bytes.len());
@@ -1866,4 +2063,62 @@ mod tests {
         assert!(ts >= before);
         assert!(ts < before + 5);
     }
+
+    #[test]
+    fn test_should_log_api_route_exclusions() {
+        // Routine noisy/polling routes should be suppressed from terminal log spam
+        assert!(!should_log_api_route("/api/background-jobs"));
+        assert!(!should_log_api_route("/api/background-jobs/abc"));
+        assert!(!should_log_api_route("/api/mods"));
+        assert!(!should_log_api_route("/api/models"));
+        assert!(!should_log_api_route("/api/status"));
+        assert!(!should_log_api_route("/api/conversation-sources"));
+        assert!(!should_log_api_route("/api/interactions"));
+        assert!(!should_log_api_route("/api/pictures/foo.png"));
+        assert!(!should_log_api_route("/api/thumbnails/bar.jpg"));
+        assert!(!should_log_api_route("/api/proxy-image"));
+        assert!(!should_log_api_route(
+            "/api/proxy-image?url=https://example.com/pic.jpg"
+        ));
+        assert!(!should_log_api_route("/not-api/test"));
+        assert!(!should_log_api_route(
+            "/api/library/c2db083a-728b-49fb-8e96-ef1c6c4553a0/thumbnail"
+        ));
+        assert!(!should_log_api_route(
+            "/api/library/mint-20261011-130823-512a5fb5/thumbnail"
+        ));
+        assert!(!should_log_api_route(
+            "/api/library/c2db083a-728b-49fb-8e96-ef1c6c4553a0/content"
+        ));
+        assert!(!should_log_api_route("/api/mcp-artifacts/artifact-123"));
+
+        // Standard operational API calls should still be logged
+        assert!(should_log_api_route("/api/library"));
+        assert!(should_log_api_route("/api/library?kind=file"));
+        assert!(should_log_api_route(
+            "/api/library/c2db083a-728b-49fb-8e96-ef1c6c4553a0"
+        ));
+        assert!(should_log_api_route(
+            "/api/library/c2db083a-728b-49fb-8e96-ef1c6c4553a0/trash"
+        ));
+        assert!(should_log_api_route("/api/system-info"));
+        assert!(should_log_api_route("/api/select-folder"));
+    }
+
+    #[test]
+    fn http_request_framing_parses_headers_once_without_utf8_scanning_binary_or_large_body() {
+        let mut raw = b"POST /api/chat-stream HTTP/1.1\r\nHost: localhost:3000\r\nContent-Length: 10\r\n\r\n1234".to_vec();
+        // Even if the body contains invalid UTF-8 bytes, header framing only inspects the header slice.
+        raw.extend_from_slice(&[0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa]);
+        let (header_end, total_len) = parse_http_request_framing(&raw).expect("headers complete");
+        assert_eq!(&raw[header_end..header_end + 4], b"\r\n\r\n");
+        assert_eq!(total_len, header_end + 4 + 10);
+        assert_eq!(raw.len(), total_len);
+
+        let header_str = std::str::from_utf8(&raw[..header_end]).unwrap();
+        assert_eq!(
+            parse_request_line(header_str),
+            Some(("POST", "/api/chat-stream"))
+        );
+    }
 }

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

@@ -402,7 +402,7 @@ fn resolve_tool_signal(action: &str, had_error: bool, is_start: bool) -> Option<
             }
         }),
 
-        "dispatch_subagent" => Some(if is_start {
+        "dispatch_agents" | "dispatch_subagent" => Some(if is_start {
             AvatarSignal {
                 action: Some("typing"),
                 prop: Some("keyboard"),
@@ -506,7 +506,7 @@ impl AvatarBridge {
     }
 
     /// Hook this into whatever emits `AgentProgress` for a turn (currently
-    /// wired at the `progress_cb` closure in `src-tauri/src/lib.rs` around
+    /// wired at the `progress_cb` closure in `src-tauri/src/commands/conversation.rs` around
     /// the `orchestrate_agent_loop` call).
     pub fn on_agent_progress(&self, progress: &AgentProgress) {
         if !self.is_active() {
@@ -517,6 +517,7 @@ impl AvatarBridge {
                 action,
                 input,
                 subagent,
+                ..
             } => {
                 let session = SessionMeta::for_subagent(subagent.as_deref());
                 // The model's own explicit signal is the primary source of
@@ -559,8 +560,16 @@ impl AvatarBridge {
             AgentProgress::ThinkingDelta { .. } => {}
             AgentProgress::ExtendedThinking { .. } => {}
             AgentProgress::WaitingForNetwork { .. } => {}
+            AgentProgress::ContextCompaction { .. } => {}
             AgentProgress::PlanUpdated { .. } => {}
-            AgentProgress::RunCompleted { .. } => {}
+            AgentProgress::RunCompleted { .. }
+            | AgentProgress::SubagentStarted { .. }
+            | AgentProgress::SubagentFinished { .. }
+            | AgentProgress::ToolProgress { .. }
+            | AgentProgress::ToolArtifacts { .. }
+            | AgentProgress::ToolDiscovery { .. }
+            | AgentProgress::DeviceState { .. }
+            | AgentProgress::ExecutionUpdate { .. } => {}
         }
     }
 
@@ -795,6 +804,7 @@ mod tests {
     async fn tool_start_without_subagent_uses_main_session_at_priority_zero() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: None,
@@ -813,6 +823,7 @@ mod tests {
     async fn tool_start_inside_a_subagent_gets_its_own_lower_priority_session() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: Some("researcher".into()),
@@ -831,6 +842,7 @@ mod tests {
     async fn thinking_falls_back_to_the_last_known_session() {
         let bridge = AvatarBridge::new(test_cfg());
         bridge.on_agent_progress(&AgentProgress::ToolStart {
+            call_id: None,
             action: "run_shell".into(),
             input: serde_json::Value::Null,
             subagent: Some("researcher".into()),