@pheem49/mint 1.15.0 → 1.17.0

package/crates/mint-core/src/orchestration/run_control.rs

@@ -0,0 +1,196 @@
+//! A cancellation belongs to a run, never to a reusable conversation ID.
+use std::{
+    collections::HashMap,
+    future::Future,
+    sync::{LazyLock, Mutex},
+};
+use tokio_util::sync::CancellationToken;
+
+struct Context {
+    chat: String,
+    token: CancellationToken,
+}
+tokio::task_local! { static CURRENT: Context; }
+static RUNS: LazyLock<Mutex<HashMap<String, (String, CancellationToken)>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
+
+struct Registration {
+    id: String,
+    token: CancellationToken,
+}
+impl Drop for Registration {
+    fn drop(&mut self) {
+        RUNS.lock().unwrap().remove(&self.id);
+        self.token.cancel();
+    }
+}
+
+pub(crate) async fn scope<F: Future>(chat: &str, future: F) -> F::Output {
+    let token = CURRENT
+        .try_with(|parent| {
+            if chat.starts_with(&format!("{}::subagent::", parent.chat)) {
+                parent.token.child_token()
+            } else {
+                CancellationToken::new()
+            }
+        })
+        .unwrap_or_default();
+    scope_with_token(chat, token, future).await
+}
+
+pub(crate) fn scope_with_token<F: Future>(
+    chat: &str,
+    token: CancellationToken,
+    future: F,
+) -> impl Future<Output = F::Output> {
+    // Agent futures are large. Box before building another async scope so their
+    // state is not copied into multiple nested cancellation frames on the stack.
+    let future = Box::pin(future);
+    async move {
+        let id = uuid::Uuid::new_v4().to_string();
+        RUNS.lock()
+            .unwrap()
+            .insert(id.clone(), (chat.into(), token.clone()));
+        let _registration = Registration {
+            id,
+            token: token.clone(),
+        };
+        CURRENT
+            .scope(
+                Context {
+                    chat: chat.into(),
+                    token,
+                },
+                future,
+            )
+            .await
+    }
+}
+
+pub(crate) fn token() -> Option<CancellationToken> {
+    CURRENT.try_with(|c| c.token.clone()).ok()
+}
+pub(crate) fn cancelled() -> bool {
+    token().is_some_and(|t| t.is_cancelled())
+}
+pub(crate) fn check() -> Result<(), super::OrchestrationError> {
+    if cancelled() {
+        Err(super::OrchestrationError::Agent(
+            "Agent turn canceled by user".into(),
+        ))
+    } else {
+        Ok(())
+    }
+}
+pub(crate) async fn run<T, E: Into<super::OrchestrationError>>(
+    future: impl Future<Output = Result<T, E>>,
+) -> Result<T, super::OrchestrationError> {
+    let Some(token) = token() else {
+        return future.await.map_err(Into::into);
+    };
+    tokio::select! {
+        biased;
+        _=token.cancelled()=>Err(super::OrchestrationError::Agent("Agent turn canceled by user".into())),
+        result=future=>{check()?;result.map_err(Into::into)},
+    }
+}
+pub(crate) fn cancel(chat: &str) -> usize {
+    let prefix = format!("{chat}::subagent::");
+    let runs = RUNS.lock().unwrap();
+    let mut count = 0;
+    for (name, token) in runs.values() {
+        if name == chat || name.starts_with(&prefix) {
+            token.cancel();
+            count += 1;
+        }
+    }
+    count
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn review_cancelled_turn_cannot_resume_in_a_fresh_mcp_scope_but_a_new_turn_can() {
+        let chat = format!("run-control-{}", uuid::Uuid::new_v4());
+        scope(&chat, async {
+            assert!(crate::cancel_agent(&chat));
+            let result = crate::mcp::catalog::describe_tool(
+                &crate::MintConfig::default(),
+                "not-configured",
+                "move",
+                &chat,
+            )
+            .await;
+            assert!(
+                matches!(result, Err(crate::mcp::McpError::Cancelled)),
+                "new MCP scopes must honor the canceled turn"
+            );
+        })
+        .await;
+        scope(&chat, async {
+            assert!(check().is_ok(), "new turn inherited stale cancellation");
+            let result = crate::mcp::catalog::describe_tool(
+                &crate::MintConfig::default(),
+                "not-configured",
+                "move",
+                &chat,
+            )
+            .await;
+            assert!(matches!(
+                result,
+                Err(crate::mcp::McpError::MissingServer(_))
+            ));
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn review_parent_cancellation_reaches_late_children_and_child_cancel_is_scoped() {
+        let chat = format!("parent-control-{}", uuid::Uuid::new_v4());
+        scope(&chat, async {
+            let child = format!("{chat}::subagent::one");
+            scope(&child, async {
+                assert!(crate::cancel_agent(&child));
+                assert!(check().is_err());
+            })
+            .await;
+            assert!(check().is_ok(), "canceling a child canceled its parent");
+            assert!(crate::cancel_agent(&chat));
+            scope(&format!("{chat}::subagent::late"), async {
+                assert!(check().is_err());
+            })
+            .await;
+            scope("unrelated-run", async {
+                assert!(check().is_ok());
+            })
+            .await;
+        })
+        .await;
+    }
+
+    #[tokio::test]
+    async fn review_old_run_cleanup_does_not_cancel_or_unregister_its_replacement() {
+        let chat = format!("overlap-control-{}", uuid::Uuid::new_v4());
+        let old_chat = chat.clone();
+        let (ready_tx, ready_rx) = tokio::sync::oneshot::channel();
+        let (done_tx, done_rx) = tokio::sync::oneshot::channel();
+        let old = tokio::spawn(async move {
+            scope(&old_chat, async {
+                ready_tx.send(()).unwrap();
+                done_rx.await.unwrap();
+            })
+            .await
+        });
+        ready_rx.await.unwrap();
+        assert!(crate::cancel_agent(&chat));
+        scope(&chat, async {
+            done_tx.send(()).unwrap();
+            old.await.unwrap();
+            assert!(check().is_ok(), "old cleanup canceled a new turn");
+            assert_eq!(cancel(&chat), 1, "replacement registration was lost");
+            assert!(check().is_err());
+        })
+        .await;
+    }
+}

package/crates/mint-core/src/orchestration/tools/files.rs

@@ -2,6 +2,11 @@ use std::path::Path;
 
 use super::super::*;
 
+fn is_skill_edit(root: &Path, path: &Path) -> Result<bool, OrchestrationError> {
+    crate::skills::skill_edit_requires_approval(root, path)
+        .map_err(|error| OrchestrationError::Agent(error.to_string()))
+}
+
 /// Handles the subset of `execute_tool` actions related to files.
 /// Only called for actions `execute_tool` has already routed here, so the
 /// fallback arm is unreachable in practice.
@@ -10,7 +15,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -21,7 +26,23 @@ pub(in crate::orchestration) async fn execute(
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?)
         }
         "read_file" => {
-            let path = workspace_path(root, required(&input.path, "path")?)?;
+            if input.start_line.is_none()
+                && input.end_line.is_none()
+                && let Some(skill) = crate::skills::skill_for_read_path(root, &input.path)
+            {
+                let memory = MemoryStore::open_default()?;
+                return crate::skills::read_skill_file(&memory, &skill, chat_id, config)
+                    .map_err(|error| OrchestrationError::Agent(error.to_string()));
+            }
+            // Explicit line-range reads are previews, never successful full skill loads.
+            // Known global skills may live outside the workspace, but still require
+            // the same path capability checks as any other file read.
+            let known_skill = crate::skills::skill_for_read_path(root, &input.path);
+            let path = if let Some(skill) = known_skill {
+                PathBuf::from(skill.source_path)
+            } else {
+                agent_read_path(root, required(&input.path, "path")?, config)?
+            };
             let start = input.start_line.unwrap_or(1);
             let end = input.end_line.unwrap_or_else(|| start.saturating_add(239));
             Ok(read_code_file(&path, start, end, config)
@@ -75,8 +96,36 @@ pub(in crate::orchestration) async fn execute(
                     "apply_patch requires at least one hunk".into(),
                 ));
             }
-            let edit = build_code_patch(root, patch.path.clone(), &patch.hunks, config)
-                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            let edit = match build_code_patch(root, patch.path.clone(), &patch.hunks, config) {
+                Ok(edit) => edit,
+                Err(e) => {
+                    let target_full_path = root.join(&patch.path);
+                    if let Ok(file_content) = std::fs::read_to_string(&target_full_path) {
+                        for (idx, hunk) in patch.hunks.iter().enumerate() {
+                            let occurrences = file_content.matches(hunk.old_text.as_str()).count();
+                            if occurrences == 0 {
+                                let guidance = crate::orchestration::diagnostics::format_patch_not_found_guidance(
+                                    &file_content,
+                                    &hunk.old_text,
+                                    idx + 1,
+                                    &patch.path,
+                                );
+                                return Err(OrchestrationError::Agent(guidance));
+                            } else if occurrences > 1 && !hunk.replace_all {
+                                let guidance = crate::orchestration::diagnostics::format_ambiguous_patch_guidance(
+                                    &file_content,
+                                    &hunk.old_text,
+                                    idx + 1,
+                                    &patch.path,
+                                    occurrences,
+                                );
+                                return Err(OrchestrationError::Agent(guidance));
+                            }
+                        }
+                    }
+                    return Err(OrchestrationError::Agent(e.to_string()));
+                }
+            };
             let proposal = propose_code_edits(root, std::slice::from_ref(&edit), config)
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
             let diff = proposal
@@ -86,12 +135,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::ApplyPatch {
-                path: patch.path.to_string_lossy().into_owned(),
-                hunks: patch.hunks.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(&patch.path))?
+            {
+                AgentApproval::SkillWrite {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::ApplyPatch {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    hunks: patch.hunks.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -122,12 +181,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::WriteFile {
-                path: path_str.to_owned(),
-                content: input.file_content.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(path_str))?
+            {
+                AgentApproval::SkillWrite {
+                    path: path_str.to_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::WriteFile {
+                    path: path_str.to_owned(),
+                    content: input.file_content.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -145,3 +214,109 @@ pub(in crate::orchestration) async fn execute(
         ),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn skill_writes_require_separate_approval_even_when_file_edits_are_allowed() {
+        let root =
+            std::env::temp_dir().join(format!("mint-skill-approval-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let config = MintConfig {
+            allowed_write_paths: vec![root.clone()],
+            allowed_read_paths: vec![root.clone()],
+            ..MintConfig::default()
+        };
+        let input = AgentInput {
+            path: ".agents/skills/example/SKILL.md".into(),
+            file_content: "---\ndescription: example\n---\nOriginal instructions".into(),
+            ..Default::default()
+        };
+        let mut requests = Vec::new();
+        let mut approve = |approval: &AgentApproval| {
+            let value = serde_json::to_value(approval).unwrap();
+            requests.push(value.clone());
+            Ok(if value.get("SkillWrite").is_some() {
+                ApprovalOutcome::Denied
+            } else {
+                ApprovalOutcome::Approved
+            })
+        };
+        execute(
+            "write_file",
+            &input,
+            &root,
+            &config,
+            "skill-test",
+            &mut approve,
+        )
+        .await
+        .unwrap();
+        assert!(
+            !root.join(&input.path).exists(),
+            "ordinary file approval must not authorize skill creation"
+        );
+        assert!(
+            requests[0]["SkillWrite"]["diff"]
+                .as_str()
+                .unwrap()
+                .contains("Original instructions")
+        );
+
+        let path = root.join(&input.path);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(&path, &input.file_content).unwrap();
+        let patch = AgentInput {
+            patch: Some(AgentPatch {
+                path: PathBuf::from(&input.path),
+                hunks: vec![CodePatchHunk {
+                    old_text: "Original instructions".into(),
+                    new_text: "Changed instructions".into(),
+                    replace_all: false,
+                }],
+            }),
+            ..Default::default()
+        };
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |approval| {
+                Ok(
+                    if serde_json::to_value(approval)
+                        .unwrap()
+                        .get("SkillWrite")
+                        .is_some()
+                    {
+                        ApprovalOutcome::Denied
+                    } else {
+                        ApprovalOutcome::Approved
+                    },
+                )
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(std::fs::read_to_string(&path).unwrap(), input.file_content);
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |_| Ok(ApprovalOutcome::Approved),
+        )
+        .await
+        .unwrap();
+        assert!(
+            std::fs::read_to_string(&path)
+                .unwrap()
+                .contains("Changed instructions")
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}

package/crates/mint-core/src/orchestration/tools/media.rs

@@ -10,7 +10,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     _root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     _approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -263,49 +263,34 @@ pub(in crate::orchestration) async fn execute(
                 num_images: Some(1),
                 ..Default::default()
             };
-            let res = crate::image_gen::generate_images(config, &req)
+            let res = crate::image_workflow::generate_and_save_images(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
-            let data_uris: Vec<String> = res.images.iter().map(|i| i.data_uri.clone()).collect();
-            if let Ok(saved) = crate::pictures::save_chat_images(
-                data_uris,
-                Some(res.provider.clone()),
-                Some(prompt_text.to_string()),
-            ) {
-                if !saved.is_empty() {
-                    let saved_path = saved[0].path.display().to_string();
-                    let json_payload = serde_json::json!({
-                        "prompt": prompt_text,
-                        "model": res.model,
-                        "provider": res.provider,
-                        "images": saved.iter()
-                            .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.images
+                            .iter()
+                            .map(|image| image.id.clone())
                             .collect::<Vec<_>>(),
-                    });
-                    let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                    let data = format!(
-                        "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                        res.model, res.provider, saved_path, json_str
-                    );
-                    return Ok(data);
-                }
-            }
-            if let Some(first) = res.images.first() {
-                let json_payload = serde_json::json!({
-                    "prompt": prompt_text,
-                    "model": res.model,
-                    "provider": res.provider,
-                    "images": [{ "url": first.data_uri }],
-                });
-                let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                let data = format!(
-                    "Image generated successfully with model `{}` ({}).\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                    res.model, res.provider, json_str
-                );
-                Ok(data)
-            } else {
-                Ok("No image returned from provider".to_string())
-            }
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            let saved_path = res.images[0].path.display().to_string();
+            let json_payload = serde_json::json!({
+                "prompt": res.prompt,
+                "model": res.model,
+                "provider": res.provider,
+                "images": res.images.iter()
+                    .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+                    .collect::<Vec<_>>(),
+            });
+            let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
+            Ok(format!(
+                "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
+                res.model, res.provider, saved_path, json_str
+            ))
         }
         "generate_video" | "veo.generate" | "video_generate" => {
             let prompt_text = if !input.prompt.trim().is_empty() {
@@ -334,6 +319,17 @@ pub(in crate::orchestration) async fn execute(
             let res = crate::video_gen::generate_video(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.videos
+                            .iter()
+                            .map(|video| video.id.clone())
+                            .collect::<Vec<_>>(),
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
             if let Some(first) = res.videos.first() {
                 let vid_md = format!(
                     "<video controls src=\"{}\" width=\"100%\" style=\"max-height:400px; border-radius:8px;\"></video>\n\n✓ Video generated successfully with Veo `{}` ({})",

package/crates/mint-core/src/orchestration/tools/misc.rs

@@ -102,9 +102,10 @@ pub(in crate::orchestration) async fn execute(
                             || skill.name.to_ascii_lowercase().contains(&query_lower)
                         {
                             results.push(format!(
-                                "[Skill: {}]\n{}",
+                                "[Skill: {}]\nDescription: {}\nPath: {}\nRead through read_file before using this skill.",
                                 skill.name,
-                                truncate_for_context(&skill.content, 300)
+                                skill.description.as_deref().unwrap_or("No description provided"),
+                                skill.source_path
                             ));
                         }
                     }

package/crates/mint-core/src/orchestration/tools/mod.rs

@@ -10,3 +10,5 @@ pub(super) mod plugins_mcp;
 pub(super) mod project;
 pub(super) mod shell;
 pub(super) mod web;
+
+pub(super) mod mods;