@pheem49/mint 1.15.0 → 1.16.0

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

@@ -10,12 +10,14 @@
 pub mod agent;
 pub mod avatar_bridge;
 pub mod browser;
+pub mod companion;
 pub mod cron;
 pub mod eval;
 pub mod git;
 pub mod integrations;
 pub mod live_sync;
 pub mod media;
+pub mod mods;
 pub mod orchestration;
 pub mod prompts;
 pub mod search;
@@ -27,6 +29,7 @@ pub use agent::chat;
 pub use agent::code_tools;
 pub use agent::memory;
 pub use agent::safety;
+pub use agent::skill_inventory;
 pub use agent::skills;
 pub use agent::subagents;
 pub use agent::tasks;
@@ -35,7 +38,10 @@ pub use media::auto_shorts;
 pub use media::gemini_live;
 pub use media::image_gen;
 pub use media::image_search;
+pub use media::image_workflow;
+pub use media::library;
 pub use media::mic_transcribe;
+pub use media::model_catalog;
 pub use media::pictures;
 pub use media::speech;
 pub use media::subtitle;
@@ -47,8 +53,10 @@ pub use media::video_gen;
 pub use integrations::bridge_health;
 pub use integrations::hooks;
 pub use integrations::mcp;
+pub use integrations::mcp_result;
 pub use integrations::oauth;
 pub use integrations::plugins;
+pub use integrations::webhooks;
 
 pub use search::files;
 pub use search::knowledge;
@@ -64,6 +72,7 @@ pub use system::bg_shell;
 pub use system::calculation;
 pub use system::config;
 pub use system::docker_sandbox;
+pub use system::release_notes;
 pub use system::shell;
 pub use system::stock;
 pub use system::weather;
@@ -235,42 +244,92 @@ pub static ACTIVE_AGENTS: std::sync::LazyLock<
     std::sync::Mutex<std::collections::HashMap<String, tokio::task::AbortHandle>>,
 > = std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashMap::new()));
 
+pub fn unregister_agent(chat_id: &str, task_id: tokio::task::Id) {
+    let mut agents = ACTIVE_AGENTS.lock().unwrap();
+    if agents
+        .get(chat_id)
+        .is_some_and(|handle| handle.id() == task_id)
+    {
+        agents.remove(chat_id);
+    }
+}
+
 pub fn cancel_agent(chat_id: &str) -> bool {
+    let turns = crate::orchestration::run_control::cancel(chat_id);
+    let mcp_calls = crate::mcp::cancel_mcp_calls(chat_id);
+    crate::mods::shutdown_chat(chat_id);
     let mut agents = ACTIVE_AGENTS.lock().unwrap();
     if let Some(handle) = agents.remove(chat_id) {
-        handle.abort();
+        if mcp_calls == 0 {
+            handle.abort();
+        } else {
+            // Give the cooperative MCP wait time to record its terminal status;
+            // the abort remains a bounded fallback if the server cannot be reached.
+            std::thread::spawn(move || {
+                std::thread::sleep(std::time::Duration::from_millis(1500));
+                handle.abort();
+            });
+        }
         true
     } else {
-        false
+        mcp_calls > 0 || turns > 0
     }
 }
 
-/// Pending web-side approval requests, keyed by a random token — the HTTP
-/// equivalent of desktop's `ApprovalsState` (`src-tauri/src/lib.rs`). A
-/// `oneshot::Sender` can only be consumed once, so entries are removed (not
-/// just read) on resolution, same as desktop's `submit_tool_approval`.
-pub static PENDING_APPROVALS: std::sync::LazyLock<
-    std::sync::Mutex<
-        std::collections::HashMap<String, tokio::sync::oneshot::Sender<ApprovalOutcome>>,
-    >,
-> = std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashMap::new()));
+#[cfg(test)]
+mod agent_registration_tests {
+    #[tokio::test]
+    async fn agent_registration_cleanup_keeps_a_new_run_cancellable() {
+        let chat = uuid::Uuid::new_v4().to_string();
+        let previous = tokio::spawn(std::future::pending::<()>());
+        let next = tokio::spawn(std::future::pending::<()>());
+        super::ACTIVE_AGENTS
+            .lock()
+            .unwrap()
+            .insert(chat.clone(), next.abort_handle());
+        super::unregister_agent(&chat, previous.id());
+        let cancellable = super::cancel_agent(&chat);
+        previous.abort();
+        next.abort();
+        assert!(
+            cancellable,
+            "completion of a cancelled run must not unregister its replacement"
+        );
+    }
+}
 
-/// Resolves a pending approval by token — mirrors desktop's
-/// `submit_tool_approval` command exactly (a non-empty `answer` always wins
-/// over `approved`, used for the "ask a clarifying question" flow). Returns
-/// `false` if the token was never pending (already resolved, expired, or
-/// bogus) rather than erroring, matching `cancel_agent`'s lenient style.
+pub use orchestration::approvals::ApprovalRegistry;
+
+/// The HTTP approval registry. Native Desktop owns a separate instance of the same module.
+pub static PENDING_APPROVALS: std::sync::LazyLock<ApprovalRegistry> =
+    std::sync::LazyLock::new(ApprovalRegistry::default);
+
+/// Resolve once by token. Explicitly blank answers decline; non-empty feedback wins
+/// over `approved`. Unknown, consumed and cancelled tokens return `false`.
 pub fn resolve_pending_approval(token: &str, approved: bool, answer: Option<String>) -> bool {
-    let Some(tx) = PENDING_APPROVALS.lock().unwrap().remove(token) else {
-        return false;
-    };
-    let outcome = match answer.filter(|a| !a.trim().is_empty()) {
-        Some(ans) => ApprovalOutcome::Intercepted(ans),
-        None if approved => ApprovalOutcome::Approved,
-        None => ApprovalOutcome::Denied,
-    };
-    let _ = tx.send(outcome);
-    true
+    PENDING_APPROVALS.resolve(token, approved, answer)
+}
+
+#[cfg(test)]
+mod approval_resolution_tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn explicitly_empty_approval_answers_decline_instead_of_approving() {
+        for answer in ["", " \t\n"] {
+            let mut token = String::new();
+            let result = PENDING_APPROVALS
+                .request(|emitted| {
+                    token = emitted.to_owned();
+                    assert!(resolve_pending_approval(emitted, true, Some(answer.into())));
+                    Ok(())
+                })
+                .await
+                .unwrap();
+            assert_eq!(result, ApprovalOutcome::Denied);
+            assert!(!resolve_pending_approval(&token, true, None));
+        }
+    }
 }
 
 /// Plain-text notices from detached background tasks (currently just

package/crates/mint-core/src/media/gemini_live.rs

@@ -15,8 +15,10 @@ use futures_util::{SinkExt, StreamExt};
 use serde::Serialize;
 use serde_json::{Value, json};
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 use tokio::sync::mpsc;
 use tokio_tungstenite::tungstenite::Message;
+use tokio_util::sync::CancellationToken;
 
 use crate::MintConfig;
 use crate::orchestration::{AgentApproval, ApprovalOutcome, execute_tool_from_json};
@@ -60,6 +62,13 @@ pub enum GeminiLiveEvent {
 /// Handle for pushing mic audio into a running session.
 pub struct GeminiLiveHandle {
     audio_tx: mpsc::UnboundedSender<Vec<u8>>,
+    cancellation: CancellationToken,
+}
+
+impl Drop for GeminiLiveHandle {
+    fn drop(&mut self) {
+        self.cancellation.cancel();
+    }
 }
 
 impl GeminiLiveHandle {
@@ -87,24 +96,60 @@ where
 {
     let (audio_tx, audio_rx) = mpsc::unbounded_channel::<Vec<u8>>();
 
+    let on_event = Arc::new(on_event);
+    let session_events = Arc::clone(&on_event);
+    spawn_cancellable_live_session(
+        chat_id.clone(),
+        audio_tx,
+        async move {
+            let mut audio_rx = audio_rx;
+            if let Err(message) = run_session(
+                &config,
+                &workspace_root,
+                &chat_id,
+                &mut approve_cb,
+                &*session_events,
+                &mut audio_rx,
+            )
+            .await
+            {
+                session_events(GeminiLiveEvent::Error { message });
+            }
+        },
+        move || on_event(GeminiLiveEvent::Closed),
+    )
+}
+
+fn spawn_cancellable_live_session<F>(
+    chat_id: String,
+    audio_tx: mpsc::UnboundedSender<Vec<u8>>,
+    session: F,
+    on_closed: impl FnOnce() + Send + 'static,
+) -> GeminiLiveHandle
+where
+    F: std::future::Future<Output = ()> + Send + 'static,
+{
+    let cancellation = CancellationToken::new();
+    let session_cancellation = cancellation.clone();
     spawn_live_session(async move {
-        let mut audio_rx = audio_rx;
-        if let Err(message) = run_session(
-            &config,
-            &workspace_root,
+        crate::orchestration::run_control::scope_with_token(
             &chat_id,
-            &mut approve_cb,
-            &on_event,
-            &mut audio_rx,
+            session_cancellation.clone(),
+            async move {
+                tokio::select! {
+                    biased;
+                    _ = session_cancellation.cancelled() => {},
+                    _ = session => {},
+                }
+            },
         )
-        .await
-        {
-            on_event(GeminiLiveEvent::Error { message });
-        }
-        on_event(GeminiLiveEvent::Closed);
+        .await;
+        on_closed();
     });
-
-    GeminiLiveHandle { audio_tx }
+    GeminiLiveHandle {
+        audio_tx,
+        cancellation,
+    }
 }
 
 /// Keep browser targeting, evidence, and recovery state for the entire voice
@@ -459,3 +504,78 @@ where
 
     Ok(())
 }
+
+#[cfg(test)]
+mod approval_lifecycle_tests {
+    use super::*;
+    use crate::ApprovalRegistry;
+    use std::time::Duration;
+    use tokio::sync::oneshot;
+
+    #[tokio::test]
+    async fn stopping_voice_releases_pending_approval_and_emits_closed() {
+        let registry = Arc::new(ApprovalRegistry::default());
+        let pending = registry.clone();
+        let (token_tx, token_rx) = oneshot::channel();
+        let (closed_tx, mut closed_rx) = oneshot::channel();
+        let (audio_tx, _audio_rx) = mpsc::unbounded_channel();
+        let handle = spawn_cancellable_live_session(
+            uuid::Uuid::new_v4().to_string(),
+            audio_tx,
+            async move {
+                pending
+                    .request(|token| {
+                        token_tx.send(token.to_owned()).unwrap();
+                        Ok(())
+                    })
+                    .await
+                    .unwrap();
+            },
+            move || {
+                let _ = closed_tx.send(());
+            },
+        );
+        let token = token_rx.await.unwrap();
+        drop(handle);
+        let result = tokio::time::timeout(Duration::from_secs(5), &mut closed_rx).await;
+        if result.is_err() {
+            registry.resolve(&token, false, None);
+            let _ = closed_rx.await;
+        }
+        assert!(
+            matches!(result, Ok(Ok(()))),
+            "voice stop did not release approval wait: {result:?}"
+        );
+        assert!(!registry.resolve(&token, true, None));
+    }
+
+    #[tokio::test]
+    async fn stopping_voice_closes_a_session_waiting_on_transport() {
+        let (ready_tx, ready_rx) = oneshot::channel();
+        let (io_tx, io_rx) = oneshot::channel();
+        let (closed_tx, mut closed_rx) = oneshot::channel();
+        let (audio_tx, _audio_rx) = mpsc::unbounded_channel();
+        let handle = spawn_cancellable_live_session(
+            uuid::Uuid::new_v4().to_string(),
+            audio_tx,
+            async move {
+                ready_tx.send(()).unwrap();
+                let _ = io_rx.await;
+            },
+            move || {
+                let _ = closed_tx.send(());
+            },
+        );
+        ready_rx.await.unwrap();
+        drop(handle);
+        let result = tokio::time::timeout(Duration::from_secs(5), &mut closed_rx).await;
+        if result.is_err() {
+            let _ = io_tx.send(());
+            let _ = closed_rx.await;
+        }
+        assert!(
+            matches!(result, Ok(Ok(()))),
+            "voice stop waited for transport: {result:?}"
+        );
+    }
+}

package/crates/mint-core/src/media/image_models.rs

@@ -72,37 +72,13 @@ pub fn image_model_options_for_provider(_config: &MintConfig, provider: &str) ->
     .collect()
 }
 
-/// Tries the provider's live API first to fetch available image models,
-/// falling back to static presets on network error, timeout, or missing key.
+/// Discovers models with saved credentials and appends missing static presets.
+/// The shared catalog owns credential selection and fallback behavior.
 pub async fn image_model_options_for_provider_async(
     config: &MintConfig,
     provider: &str,
 ) -> Vec<String> {
-    use super::image_model_fetcher;
-
-    let lower = provider.trim().to_lowercase();
-    let api_key = match lower.as_str() {
-        "nanobanana" | "gemini" | "google" => &config.api_key,
-        "dalle" | "openai" => &config.openai_api_key,
-        "stability" => &config.stability_api_key,
-        "ideogram" => &config.ideogram_api_key,
-        "replicate" => &config.replicate_api_key,
-        "bfl" | "flux" => &config.bfl_api_key,
-        _ => return image_model_options_for_provider(config, provider),
-    };
-
-    let dynamic = image_model_fetcher::fetch_image_provider_models(&lower, api_key).await;
-    if !dynamic.is_empty() {
-        let mut merged = dynamic;
-        for preset in image_model_options_for_provider(config, provider) {
-            if !merged.contains(&preset) {
-                merged.push(preset);
-            }
-        }
-        merged
-    } else {
-        image_model_options_for_provider(config, provider)
-    }
+    super::model_catalog::image_models(config, provider, "").await
 }
 
 /// Get the active model for an image provider from config.

package/crates/mint-core/src/media/image_workflow.rs

@@ -0,0 +1,216 @@
+//! Generate images and persist them in Library before reporting success.
+
+use crate::{
+    MintConfig,
+    image_gen::{ImageGenError, ImageGenRequest, ImageGenResponse},
+    pictures::{PictureEntry, PictureError},
+};
+use serde::Serialize;
+use std::future::Future;
+use thiserror::Error;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedImageGenResponse {
+    pub images: Vec<PictureEntry>,
+    pub model: String,
+    pub provider: String,
+    pub prompt: String,
+    pub description: Option<String>,
+}
+
+#[derive(Debug, Error)]
+pub enum ImageWorkflowError {
+    #[error(transparent)]
+    Generate(#[from] ImageGenError),
+    #[error(transparent)]
+    Save(#[from] PictureError),
+}
+
+/// Returns persisted Library media entries, preserving the actual generation metadata.
+/// Provider or persistence errors propagate; invalid image data is rejected before writes.
+pub async fn generate_and_save_images(
+    config: &MintConfig,
+    request: &ImageGenRequest,
+) -> Result<SavedImageGenResponse, ImageWorkflowError> {
+    generate_and_save_with(
+        || crate::image_gen::generate_images(config, request),
+        |images, source, prompt| {
+            crate::save_chat_images(images, Some(source.into()), Some(prompt.into()))
+        },
+    )
+    .await
+}
+
+async fn generate_and_save_with<G, Fut, S>(
+    generate: G,
+    save: S,
+) -> Result<SavedImageGenResponse, ImageWorkflowError>
+where
+    G: FnOnce() -> Fut,
+    Fut: Future<Output = Result<ImageGenResponse, ImageGenError>>,
+    S: FnOnce(Vec<String>, &str, &str) -> Result<Vec<PictureEntry>, PictureError>,
+{
+    let result = generate().await?;
+    if result.images.is_empty() {
+        return Err(ImageGenError::NoImagesReturned.into());
+    }
+    for image in &result.images {
+        if !crate::parse_data_uri(&image.data_uri)
+            .is_some_and(|(mime, _, bytes)| mime.starts_with("image/") && !bytes.is_empty())
+        {
+            return Err(PictureError::InvalidDataUri.into());
+        }
+    }
+    let images = save(
+        result
+            .images
+            .into_iter()
+            .map(|image| image.data_uri)
+            .collect(),
+        &result.provider,
+        &result.prompt,
+    )?;
+    Ok(SavedImageGenResponse {
+        images,
+        model: result.model,
+        provider: result.provider,
+        prompt: result.prompt,
+        description: result.description,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::image_gen::GeneratedImage;
+    use std::{fs, path::PathBuf};
+
+    struct Fixture(PathBuf);
+    impl Fixture {
+        fn store(&self) -> Result<crate::library::LibraryStore, crate::library::LibraryError> {
+            crate::library::LibraryStore::open(
+                crate::MemoryStore::open(self.0.join("memory.sqlite")),
+                self.0.join("Library"),
+                self.0.join("Pictures"),
+            )
+        }
+        fn save(
+            &self,
+            images: Vec<String>,
+            source: &str,
+            message: &str,
+        ) -> Result<Vec<PictureEntry>, PictureError> {
+            crate::pictures::save_chat_images_in(
+                self.store()?,
+                images,
+                Some(source.into()),
+                Some(message.into()),
+            )
+        }
+        fn new() -> Self {
+            Self(std::env::temp_dir().join(format!("mint-image-workflow-{}", uuid::Uuid::new_v4())))
+        }
+    }
+    impl Drop for Fixture {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.0);
+        }
+    }
+    fn generated(images: &[&str]) -> ImageGenResponse {
+        ImageGenResponse {
+            images: images
+                .iter()
+                .map(|data| GeneratedImage {
+                    data_uri: (*data).into(),
+                    mime_type: "image/png".into(),
+                })
+                .collect(),
+            model: "actual-model".into(),
+            provider: "replicate".into(),
+            prompt: "provider prompt".into(),
+            description: Some("description".into()),
+        }
+    }
+
+    #[tokio::test]
+    async fn core_migration_saved_images_use_actual_provider_and_return_persisted_metadata() {
+        let f = Fixture::new();
+        let result = generate_and_save_with(
+            || async {
+                Ok(generated(&[
+                    "data:image/png;base64,aGk=",
+                    "data:image/png;base64,dGhlcmU=",
+                ]))
+            },
+            |images, source, message| f.save(images, source, message),
+        )
+        .await
+        .unwrap();
+        assert_eq!(result.images.len(), 2);
+        assert_eq!(fs::read(&result.images[0].path).unwrap(), b"hi");
+        assert_eq!(fs::read(&result.images[1].path).unwrap(), b"there");
+        assert_eq!(result.images[0].source, "replicate");
+        assert_eq!(result.images[0].message, "provider prompt");
+        assert_eq!(result.model, "actual-model");
+        assert_eq!(result.provider, "replicate");
+        assert_eq!(result.description.as_deref(), Some("description"));
+        let index = f
+            .store()
+            .unwrap()
+            .list(&crate::library::LibraryQuery::default())
+            .unwrap();
+        assert_eq!(index.items.len(), 2);
+        assert!(index.items.iter().all(|item| item.origin == "generated"));
+        assert!(
+            index
+                .items
+                .iter()
+                .any(|item| item.id == result.images[1].id)
+        );
+        assert!(!f.0.join("Pictures/pictures.json").exists());
+    }
+
+    #[tokio::test]
+    async fn core_migration_failed_generation_does_not_write_pictures() {
+        let f = Fixture::new();
+        let result = generate_and_save_with(
+            || async { Err(ImageGenError::ModelError("provider unavailable".into())) },
+            |images, source, message| f.save(images, source, message),
+        )
+        .await;
+        assert!(matches!(
+            result,
+            Err(ImageWorkflowError::Generate(ImageGenError::ModelError(_)))
+        ));
+        assert!(!f.0.exists());
+    }
+
+    #[tokio::test]
+    async fn core_migration_failed_persistence_is_not_reported_as_success() {
+        let f = Fixture::new();
+        fs::write(&f.0, "a file blocks the Pictures directory").unwrap();
+        let result = generate_and_save_with(
+            || async { Ok(generated(&["data:image/png;base64,aGk="])) },
+            |images, source, message| f.save(images, source, message),
+        )
+        .await;
+        assert!(matches!(result, Err(ImageWorkflowError::Save(_))));
+        let _ = fs::remove_file(&f.0);
+    }
+
+    #[tokio::test]
+    async fn core_migration_invalid_generated_image_is_rejected_before_partial_persistence() {
+        let f = Fixture::new();
+        let result = generate_and_save_with(
+            || async { Ok(generated(&["data:image/png;base64,aGk=", "invalid image"])) },
+            |images, source, message| f.save(images, source, message),
+        )
+        .await;
+        assert!(matches!(
+            result,
+            Err(ImageWorkflowError::Save(PictureError::InvalidDataUri))
+        ));
+        assert!(!f.0.exists());
+    }
+}