@pheem49/mint 1.15.0 → 1.16.0

package/crates/mint-companion-protocol/src/lib.rs

@@ -0,0 +1,163 @@
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+pub const VERSION: u32 = 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HostDescriptor {
+    pub version: u32,
+    pub host_id: String,
+    pub name: String,
+    pub endpoint: String,
+    pub token: String,
+}
+
+pub fn hosts_dir() -> Option<std::path::PathBuf> {
+    dirs::config_dir().map(|p| p.join("mint/companion/hosts"))
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum Status {
+    Queued,
+    #[default]
+    Thinking,
+    Working,
+    Responding,
+    Waiting,
+    Completed,
+    Failed,
+    Interrupted,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Session {
+    pub chat_id: String,
+    pub title: String,
+    pub workspace: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Turn {
+    pub chat_id: String,
+    pub turn_id: i64,
+    pub seq: u64,
+    pub status: Status,
+    pub tool: Option<String>,
+    pub text: String,
+    #[serde(default)]
+    pub prompt: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
+pub enum Command {
+    ListSessions,
+    Subscribe {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+    },
+    SendChat {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+        #[serde(rename = "requestId")]
+        request_id: String,
+        message: String,
+    },
+    Interact {
+        #[serde(rename = "chatId")]
+        chat_id: String,
+        #[serde(rename = "requestId")]
+        request_id: String,
+        area: String,
+    },
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum Event {
+    Snapshot {
+        #[serde(rename = "hostId")]
+        host_id: String,
+        version: u32,
+        sessions: Vec<Session>,
+        turns: Vec<Turn>,
+    },
+    Update {
+        #[serde(rename = "hostId")]
+        host_id: String,
+        turn: Turn,
+    },
+    Accepted {
+        #[serde(rename = "requestId")]
+        request_id: String,
+        #[serde(rename = "turnId")]
+        turn_id: Option<i64>,
+    },
+    Error {
+        #[serde(rename = "requestId")]
+        request_id: Option<String>,
+        message: String,
+    },
+}
+
+#[derive(Default)]
+pub struct TurnBook(pub BTreeMap<(String, i64), Turn>);
+
+impl TurnBook {
+    pub fn apply(&mut self, turn: Turn) -> bool {
+        let key = (turn.chat_id.clone(), turn.turn_id);
+        if self.0.get(&key).is_some_and(|old| old.seq >= turn.seq) {
+            return false;
+        }
+        self.0.insert(key, turn);
+        true
+    }
+    pub fn session(&self, chat_id: &str) -> Vec<Turn> {
+        self.0
+            .values()
+            .filter(|t| t.chat_id == chat_id)
+            .cloned()
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn turn(chat: &str, id: i64, seq: u64, status: Status) -> Turn {
+        Turn {
+            chat_id: chat.into(),
+            turn_id: id,
+            seq,
+            status,
+            tool: None,
+            text: String::new(),
+            prompt: String::new(),
+        }
+    }
+    #[test]
+    fn snapshots_keep_concurrent_sessions_separate() {
+        let mut book = TurnBook::default();
+        book.apply(turn("one", 1, 1, Status::Working));
+        book.apply(turn("two", 2, 2, Status::Responding));
+        assert_eq!(book.session("one").len(), 1);
+        assert_eq!(book.session("one")[0].status, Status::Working);
+    }
+    #[test]
+    fn late_updates_cannot_overwrite_completed_turns() {
+        let mut book = TurnBook::default();
+        assert!(book.apply(turn("one", 1, 3, Status::Completed)));
+        assert!(!book.apply(turn("one", 1, 2, Status::Thinking)));
+        assert_eq!(book.session("one")[0].status, Status::Completed);
+    }
+    #[test]
+    fn clients_cannot_inject_tools_or_system_instructions() {
+        let wire =
+            r#"{"type":"send_chat","chatId":"one","requestId":"req","message":"hi","tools":[{}]}"#;
+        assert!(serde_json::from_str::<Command>(wire).is_err());
+    }
+}

package/crates/mint-core/Cargo.toml

@@ -21,6 +21,10 @@ hmac.workspace = true
 hound = "3"
 ignore.workspace = true
 image.workspace = true
+mint-companion-protocol = { path = "../mint-companion-protocol" }
+mint-mod-runtime = { path = "../mint-mod-runtime" }
+jsonschema = { version = "0.58.6", default-features = false }
+libc = "0.2"
 quick-xml.workspace = true
 regex.workspace = true
 reqwest.workspace = true
@@ -34,11 +38,10 @@ similar.workspace = true
 srtlib.workspace = true
 thiserror.workspace = true
 tokio.workspace = true
+tokio-util = { version = "0.7", features = ["rt"] }
 tokio-tungstenite.workspace = true
+trash = "5.2"
 tree-sitter.workspace = true
 tree-sitter-rust.workspace = true
 tree-sitter-typescript.workspace = true
 uuid.workspace = true
-
-
-

package/crates/mint-core/build.rs

@@ -0,0 +1,26 @@
+use std::{env, fs, path::PathBuf};
+
+fn main() {
+    let manifest = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
+    let root = manifest.join("../..");
+    let notes = root.join("Release_Note.md");
+    let bundle =
+        env::var("MINT_BUNDLE_RELEASE_NOTES").as_deref() == Ok("1") || !root.join(".git").exists();
+
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-env-changed=MINT_BUNDLE_RELEASE_NOTES");
+    if bundle {
+        println!("cargo:rerun-if-changed={}", notes.display());
+    }
+    println!(
+        "cargo:rustc-env=MINT_LIVE_RELEASE_NOTES={}",
+        if bundle { "0" } else { "1" }
+    );
+
+    // Keep the snapshot in OUT_DIR: a dev notes edit must not invalidate Rust's
+    // include_str dependency. Shipping builds explicitly track the source file.
+    let snapshot =
+        fs::read(&notes).expect("Release_Note.md is required when creating the snapshot");
+    let output = PathBuf::from(env::var_os("OUT_DIR").unwrap()).join("release-notes.md");
+    fs::write(output, snapshot).expect("write the release notes snapshot");
+}

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

@@ -343,6 +343,43 @@ const MAX_DOCUMENT_CONTEXT_CHARS: usize = 400_000;
 static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
 
 impl ChatRequest {
+    pub(crate) fn with_stored_document_context(
+        &self,
+        _config: &crate::MintConfig,
+        path: &std::path::Path,
+    ) -> Result<ChatRequest, String> {
+        let Some(document) = &self.document_attachment else {
+            return Ok(self.clone());
+        };
+        let extracted =
+            crate::knowledge::extract_managed_document_text(path).map_err(|e| e.to_string())?;
+        self.with_document_text(document, extracted)
+    }
+    fn with_document_text(
+        &self,
+        document: &DocumentAttachment,
+        extracted: String,
+    ) -> Result<ChatRequest, String> {
+        let mut context: String = extracted.chars().take(MAX_DOCUMENT_CONTEXT_CHARS).collect();
+        if extracted.chars().count() > MAX_DOCUMENT_CONTEXT_CHARS {
+            context.push_str("\n\n[Document text truncated because it is long.]");
+        }
+
+        let filename = document.filename.trim();
+        let filename = if filename.is_empty() {
+            "attached document"
+        } else {
+            filename
+        };
+
+        let mut enriched = self.clone();
+        enriched.document_attachment = None;
+        enriched.message = format!(
+            "{}\n\nAttached document: {filename}\nUse the extracted document text below when answering. If the user asks for a summary, summarize this document.\n\n--- Extracted document text ---\n{context}\n--- End extracted document text ---",
+            self.message
+        );
+        Ok(enriched)
+    }
     pub fn with_document_context(&self, config: &crate::MintConfig) -> Result<ChatRequest, String> {
         let Some(document) = &self.document_attachment else {
             return Ok(self.clone());
@@ -404,25 +441,7 @@ impl ChatRequest {
         let _ = std::fs::remove_file(&path);
         let extracted = extracted?;
 
-        let mut context: String = extracted.chars().take(MAX_DOCUMENT_CONTEXT_CHARS).collect();
-        if extracted.chars().count() > MAX_DOCUMENT_CONTEXT_CHARS {
-            context.push_str("\n\n[Document text truncated because it is long.]");
-        }
-
-        let filename = document.filename.trim();
-        let filename = if filename.is_empty() {
-            "attached document"
-        } else {
-            filename
-        };
-
-        let mut enriched = self.clone();
-        enriched.document_attachment = None;
-        enriched.message = format!(
-            "{}\n\nAttached document: {filename}\nUse the extracted document text below when answering. If the user asks for a summary, summarize this document.\n\n--- Extracted document text ---\n{context}\n--- End extracted document text ---",
-            self.message
-        );
-        Ok(enriched)
+        self.with_document_text(document, extracted)
     }
 }
 
@@ -970,6 +989,15 @@ async fn send_openai_style_request(
     Ok(response.json().await?)
 }
 
+// Preserve malformed arguments so the executor can reject them. Replacing them
+// with {} would silently turn a requested directory into the workspace root.
+fn decode_tool_arguments(arguments: &Value) -> Value {
+    match arguments.as_str() {
+        Some(raw) => serde_json::from_str(raw).unwrap_or_else(|_| arguments.clone()),
+        None => arguments.clone(),
+    }
+}
+
 /// Parses an OpenAI Chat Completions-shaped response (`choices[0].message`),
 /// extracting both plain text and any native `tool_calls`. Shared by OpenAI,
 /// custom OpenAI-compatible providers, and (for its response shape only) reused
@@ -999,10 +1027,7 @@ fn parse_openai_style_reply(model: String, response: &Value) -> Result<ProviderR
                 .iter()
                 .filter_map(|call| {
                     let name = call["function"]["name"].as_str()?.to_string();
-                    let input = call["function"]["arguments"]
-                        .as_str()
-                        .and_then(|raw| serde_json::from_str(raw).ok())
-                        .unwrap_or_else(|| json!({}));
+                    let input = decode_tool_arguments(&call["function"]["arguments"]);
                     Some(ToolCall {
                         id: call["id"].as_str().unwrap_or_default().to_string(),
                         name,
@@ -1064,11 +1089,10 @@ async fn call_ollama(
     let native = request.messages.is_some()
         && config.tool_calling_mode() == crate::config::ToolCallingMode::Native;
     let mut body = if native {
-        let messages = request.messages.as_deref().unwrap_or(&[]);
         let mut payload = json!({
             "model": model,
             "stream": false,
-            "messages": ollama_native_messages(messages),
+            "messages": ollama_request_messages(request),
         });
         if let Some(tools) = &request.tools {
             payload["tools"] = json!(
@@ -1127,6 +1151,19 @@ async fn call_ollama(
 /// Unlike OpenAI, Ollama expects tool-call `arguments` as a JSON object (not a
 /// stringified JSON blob) and doesn't require a `tool_call_id` on tool-result
 /// messages.
+fn ollama_request_messages(request: &ChatRequest) -> Vec<Value> {
+    let history = request.messages.as_deref().unwrap_or(&[]);
+    let mut result = ollama_native_messages(history);
+    if !request.system_instruction.is_empty() && !history.iter().any(|m| m.role == ChatRole::System)
+    {
+        result.insert(
+            0,
+            json!({"role":"system","content":request.system_instruction}),
+        );
+    }
+    result
+}
+
 fn ollama_native_messages(messages: &[ChatMessage]) -> Vec<Value> {
     let mut result = Vec::new();
     for message in messages {
@@ -1228,11 +1265,7 @@ fn parse_ollama_reply(model: String, response: &Value) -> Result<ProviderReply,
                 .filter_map(|(index, call)| {
                     let name = call["function"]["name"].as_str()?.to_string();
                     let arguments = &call["function"]["arguments"];
-                    let input = if let Some(raw) = arguments.as_str() {
-                        serde_json::from_str(raw).unwrap_or_else(|_| json!({}))
-                    } else {
-                        arguments.clone()
-                    };
+                    let input = decode_tool_arguments(arguments);
                     let id = call["id"]
                         .as_str()
                         .map(str::to_owned)
@@ -1498,6 +1531,19 @@ fn anthropic_content_block(block: &ContentBlock) -> Result<Value, ChatError> {
 /// `tool_use` content blocks (Anthropic may return a `tool_use` block before,
 /// after, or interleaved with text — unlike the old code, this does not assume
 /// the first block is text).
+// Anthropic reports uncached, cache-read and cache-created input separately.
+fn anthropic_input_tokens(usage: &Value) -> Option<u32> {
+    [
+        "input_tokens",
+        "cache_read_input_tokens",
+        "cache_creation_input_tokens",
+    ]
+    .into_iter()
+    .filter_map(|key| usage[key].as_u64())
+    .reduce(u64::saturating_add)
+    .map(|n| n.min(u32::MAX as u64) as u32)
+}
+
 fn parse_anthropic_reply(model: String, response: &Value) -> Result<ProviderReply, ChatError> {
     let blocks = response["content"].as_array().cloned().unwrap_or_default();
     let mut text = String::new();
@@ -1544,7 +1590,7 @@ fn parse_anthropic_reply(model: String, response: &Value) -> Result<ProviderRepl
                 thought: Some(th.clone()),
                 tool_calls: None,
                 stop_reason: response["stop_reason"].as_str().map(str::to_owned),
-                input_tokens: response["usage"]["input_tokens"].as_u64().map(|n| n as u32),
+                input_tokens: anthropic_input_tokens(&response["usage"]),
                 output_tokens: response["usage"]["output_tokens"]
                     .as_u64()
                     .map(|n| n as u32),
@@ -1558,7 +1604,7 @@ fn parse_anthropic_reply(model: String, response: &Value) -> Result<ProviderRepl
         thought,
         tool_calls: (!tool_calls.is_empty()).then_some(tool_calls),
         stop_reason: response["stop_reason"].as_str().map(str::to_owned),
-        input_tokens: response["usage"]["input_tokens"].as_u64().map(|n| n as u32),
+        input_tokens: anthropic_input_tokens(&response["usage"]),
         output_tokens: response["usage"]["output_tokens"]
             .as_u64()
             .map(|n| n as u32),
@@ -1692,7 +1738,7 @@ fn ollama_stream_payload(
         let mut value = json!({
             "model": model,
             "stream": true,
-            "messages": ollama_native_messages(request.messages.as_deref().unwrap_or(&[])),
+            "messages": ollama_request_messages(request),
         });
         if let Some(tools) = &request.tools {
             value["tools"] = json!(
@@ -2137,9 +2183,7 @@ impl StreamReplyAccumulator {
     {
         match value["type"].as_str() {
             Some("message_start") => {
-                self.input_tokens = value["message"]["usage"]["input_tokens"]
-                    .as_u64()
-                    .map(|n| n as u32);
+                self.input_tokens = anthropic_input_tokens(&value["message"]["usage"]);
             }
             Some("content_block_start") => {
                 let block_index = value["index"].as_u64().unwrap_or(0) as usize;
@@ -2214,9 +2258,9 @@ impl StreamReplyAccumulator {
             .into_iter()
             .filter(|tool| !tool.name.is_empty())
             .map(|tool| {
-                let input = tool.input.unwrap_or_else(|| {
-                    serde_json::from_str(&tool.arguments).unwrap_or_else(|_| json!({}))
-                });
+                let input = tool
+                    .input
+                    .unwrap_or_else(|| decode_tool_arguments(&Value::String(tool.arguments)));
                 ToolCall {
                     id: tool.id,
                     name: tool.name,
@@ -2995,6 +3039,38 @@ mod tests {
         assert!(parse_stream_value(StreamFormat::Anthropic, "data: [DONE]").is_none());
     }
 
+    #[test]
+    fn malformed_tool_arguments_survive_provider_parsing_for_rejection() {
+        let malformed = r#"{"path":"~/Downloads/YOUTUBE_DL""#;
+        let function = json!({"name": "list_files", "arguments": malformed});
+        let openai = parse_openai_style_reply(
+            "test".into(),
+            &json!({
+                "choices": [{"message": {"tool_calls": [{"id": "call_1", "function": function}]}}]
+            }),
+        )
+        .unwrap();
+        let ollama = parse_ollama_reply(
+            "test".into(),
+            &json!({
+                "message": {"tool_calls": [{"function": function}]}
+            }),
+        )
+        .unwrap();
+        let mut accumulator = StreamReplyAccumulator::default();
+        accumulator.consume_openai(&json!({
+            "choices": [{"delta": {"tool_calls": [{"index": 0, "id": "call_1", "function": function}]}}]
+        }), &mut |_| {});
+        let streamed = accumulator.finish("test".into()).unwrap();
+        for reply in [openai, ollama, streamed] {
+            let calls = reply.tool_calls.unwrap();
+            assert_eq!(calls.len(), 1);
+            assert_eq!(calls[0].input, Value::String(malformed.into()));
+        }
+        assert_eq!(decode_tool_arguments(&json!("{}")), json!({}));
+        assert_eq!(decode_tool_arguments(&Value::Null), Value::Null);
+    }
+
     #[test]
     fn accumulates_openai_reasoning_tools_and_usage() {
         let mut accumulator = StreamReplyAccumulator::default();
@@ -3168,6 +3244,32 @@ mod tests {
         assert_eq!(payload["system"][0]["cache_control"]["type"], "ephemeral");
     }
 
+    #[test]
+    fn review_anthropic_tool_results_preserve_failure_and_success_flags() {
+        for (text, is_error) in [
+            ("User denied MCP tool call", true),
+            ("MCP call was not approved; user feedback", true),
+            ("Error: literal diagnostic label", false),
+        ] {
+            let request = native_request(
+                vec![ChatMessage {
+                    role: ChatRole::Tool,
+                    content: vec![ContentBlock::ToolResult {
+                        tool_use_id: "mcp-call".into(),
+                        content: text.into(),
+                        is_error,
+                    }],
+                }],
+                None,
+            );
+            let payload =
+                anthropic_chat_payload(&MintConfig::default(), "claude-x", &request, false)
+                    .unwrap();
+            assert_eq!(payload["messages"][0]["content"][0]["is_error"], is_error);
+            assert_eq!(payload["messages"][0]["content"][0]["content"], text);
+        }
+    }
+
     #[test]
     fn anthropic_payload_omits_the_cache_breakpoint_for_an_empty_system_prompt() {
         let mut request = native_request(vec![ChatMessage::text(ChatRole::User, "hi")], None);
@@ -3758,6 +3860,32 @@ mod tests {
             (Some(80), Some(40))
         );
     }
+    #[test]
+    fn anthropic_cached_prompt_tokens_count_toward_context_in_json_and_streams() {
+        let usage = json!({"input_tokens":100,"cache_read_input_tokens":98_000,"cache_creation_input_tokens":1_000,"output_tokens":400,"cache_creation":{"ephemeral_5m_input_tokens":1_000}});
+        let reply = parse_anthropic_reply(
+            "claude-test".into(),
+            &json!({"content":[{"type":"text","text":"Ready"}],"usage":usage}),
+        )
+        .unwrap();
+        assert_eq!(reply.input_tokens, Some(99_100));
+        let mut stream = StreamReplyAccumulator::default();
+        stream.consume_anthropic(
+            &json!({"type":"message_start","message":{"usage":usage}}),
+            &mut |_| {},
+        );
+        stream.consume_anthropic(
+            &json!({"type":"content_block_delta","delta":{"type":"text_delta","text":"Ready"}}),
+            &mut |_| {},
+        );
+        stream.consume_anthropic(
+            &json!({"type":"message_delta","usage":{"output_tokens":400}}),
+            &mut |_| {},
+        );
+        let reply = stream.finish("claude-test".into()).unwrap();
+        assert_eq!(reply.input_tokens, Some(99_100));
+        assert_eq!(reply.output_tokens, Some(400));
+    }
 
     #[test]
     fn missing_usage_data_yields_no_token_counts() {

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

@@ -543,6 +543,15 @@ pub fn apply_code_edits(
     }
     let mut applied = Vec::new();
     for (edit, preview) in edits.iter().zip(prepared) {
+        let pending = crate::system::workspace_history::begin_edit(&root, &preview.path).map_err(
+            |message| CodeInspectionError::Write {
+                path: preview.path.clone(),
+                source: std::io::Error::other(message),
+            },
+        )?;
+        if sha256(&read_optional_content(&preview.path)?) != preview.before_sha256 {
+            return Err(CodeInspectionError::StaleProposal(preview.path.clone()));
+        }
         if let Some(parent) = preview.path.parent() {
             fs::create_dir_all(parent).map_err(|source| CodeInspectionError::Write {
                 path: parent.to_path_buf(),
@@ -550,6 +559,12 @@ pub fn apply_code_edits(
             })?;
         }
         write_atomic(&preview.path, &edit.content)?;
+        pending
+            .commit()
+            .map_err(|message| CodeInspectionError::Write {
+                path: preview.path.clone(),
+                source: std::io::Error::other(message),
+            })?;
         applied.push(AppliedCodeEdit {
             path: preview.path,
             created: !preview.existed,