@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-cli/src/terminal_theme.rs

@@ -60,89 +60,171 @@ impl TuiTheme {
     }
 }
 
-pub struct PreviewColors {
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ThemeTokens {
     pub background: Color,
+    pub panel_background: Color,
+    pub user_message_background: Color,
     pub text: Color,
     pub muted: Color,
-    pub keyword: Color,
+    pub subtle: Color,
+    pub accent: Color,
+    pub blue: Color,
+    pub warning: Color,
+    pub error: Color,
     pub added: Color,
     pub removed: Color,
     pub added_background: Color,
     pub removed_background: Color,
+    pub watermark_mark: Color,
+    pub watermark_rim: Color,
+    pub watermark_band: Color,
+    pub watermark_orbit: Color,
+    pub selection_background: Color,
 }
 
-pub fn preview_colors(theme: TuiTheme) -> PreviewColors {
+pub const fn theme_tokens(theme: TuiTheme) -> ThemeTokens {
     match theme {
-        TuiTheme::Auto => PreviewColors {
+        TuiTheme::Auto => ThemeTokens {
             background: Color::Reset,
+            panel_background: Color::Reset,
+            user_message_background: USER_MESSAGE_BACKGROUND,
             text: Color::Reset,
             muted: MUTED,
-            keyword: BLUE,
+            subtle: SUBTLE,
+            accent: ACCENT,
+            blue: BLUE,
+            warning: WARNING,
+            error: Color::Red,
             added: ACCENT,
             removed: Color::Red,
             added_background: Color::Rgb(24, 55, 37),
             removed_background: Color::Rgb(57, 30, 30),
+            watermark_mark: WATERMARK_MARK,
+            watermark_rim: WATERMARK_RIM,
+            watermark_band: WATERMARK_BAND,
+            watermark_orbit: WATERMARK_ORBIT,
+            selection_background: SELECTION_BACKGROUND,
+        },
+        TuiTheme::Dark => ThemeTokens {
+            background: Color::Rgb(27, 30, 29),
+            panel_background: PANEL_BACKGROUND,
+            user_message_background: USER_MESSAGE_BACKGROUND,
+            text: Color::Rgb(226, 234, 228),
+            muted: Color::Rgb(134, 148, 139),
+            subtle: SUBTLE,
+            accent: ACCENT,
+            blue: Color::Rgb(126, 176, 245),
+            warning: WARNING,
+            error: Color::Rgb(238, 126, 126),
+            added: ACCENT,
+            removed: Color::Rgb(238, 126, 126),
+            added_background: Color::Rgb(24, 55, 37),
+            removed_background: Color::Rgb(57, 30, 30),
+            watermark_mark: WATERMARK_MARK,
+            watermark_rim: WATERMARK_RIM,
+            watermark_band: WATERMARK_BAND,
+            watermark_orbit: WATERMARK_ORBIT,
+            selection_background: SELECTION_BACKGROUND,
         },
-        TuiTheme::Light => PreviewColors {
-            background: Color::Rgb(244, 247, 244),
+        TuiTheme::Light => ThemeTokens {
+            background: Color::Rgb(247, 249, 246),
+            panel_background: Color::Rgb(228, 238, 230),
+            user_message_background: Color::Rgb(225, 225, 225),
             text: Color::Rgb(35, 47, 42),
-            muted: Color::Rgb(105, 116, 109),
-            keyword: Color::Rgb(24, 99, 159),
+            muted: Color::Rgb(104, 115, 108),
+            subtle: Color::Rgb(79, 92, 84),
+            accent: Color::Rgb(20, 119, 77),
+            blue: Color::Rgb(31, 94, 165),
+            warning: Color::Rgb(139, 93, 12),
+            error: Color::Rgb(171, 55, 55),
             added: Color::Rgb(21, 111, 62),
             removed: Color::Rgb(171, 55, 55),
             added_background: Color::Rgb(221, 239, 225),
             removed_background: Color::Rgb(248, 229, 229),
+            watermark_mark: Color::Rgb(20, 119, 77),
+            watermark_rim: Color::Rgb(86, 145, 122),
+            watermark_band: Color::Rgb(171, 200, 182),
+            watermark_orbit: Color::Rgb(112, 161, 132),
+            selection_background: Color::Rgb(185, 215, 196),
         },
-        TuiTheme::Dark => PreviewColors {
-            background: Color::Rgb(29, 34, 33),
-            text: Color::Rgb(226, 234, 228),
-            muted: Color::Rgb(134, 148, 139),
-            keyword: Color::Rgb(126, 176, 245),
-            added: Color::Rgb(105, 230, 166),
-            removed: Color::Rgb(238, 126, 126),
-            added_background: Color::Rgb(24, 55, 37),
-            removed_background: Color::Rgb(57, 30, 30),
+    }
+}
+
+pub struct PreviewColors {
+    pub background: Color,
+    pub text: Color,
+    pub muted: Color,
+    pub keyword: Color,
+    pub added: Color,
+    pub removed: Color,
+    pub added_background: Color,
+    pub removed_background: Color,
+}
+
+pub fn preview_colors(theme: TuiTheme) -> PreviewColors {
+    let tokens = theme_tokens(theme);
+    PreviewColors {
+        background: match theme {
+            TuiTheme::Dark => Color::Rgb(29, 34, 33),
+            TuiTheme::Light => Color::Rgb(244, 247, 244),
+            TuiTheme::Auto => tokens.background,
+        },
+        text: tokens.text,
+        muted: match theme {
+            TuiTheme::Light => Color::Rgb(105, 116, 109),
+            _ => tokens.muted,
         },
+        keyword: match theme {
+            TuiTheme::Light => Color::Rgb(24, 99, 159),
+            _ => tokens.blue,
+        },
+        added: tokens.added,
+        removed: tokens.removed,
+        added_background: tokens.added_background,
+        removed_background: tokens.removed_background,
     }
 }
 
 pub fn apply_tui_theme(buffer: &mut Buffer, theme: TuiTheme) {
+    let tokens = theme_tokens(theme);
     for cell in &mut buffer.content {
         match theme {
             TuiTheme::Auto => {
                 if cell.fg == Color::White && cell.bg != USER_MESSAGE_BACKGROUND {
-                    cell.fg = Color::Reset;
+                    cell.fg = tokens.text;
                 }
                 if cell.bg == PANEL_BACKGROUND {
-                    cell.bg = Color::Reset;
+                    cell.bg = tokens.panel_background;
                 }
             }
             TuiTheme::Dark => {
                 if cell.fg == Color::Reset {
-                    cell.fg = Color::Rgb(226, 234, 228);
+                    cell.fg = tokens.text;
                 }
                 if cell.bg == Color::Reset {
-                    cell.bg = Color::Rgb(27, 30, 29);
+                    cell.bg = tokens.background;
                 }
             }
             TuiTheme::Light => {
                 cell.fg = match cell.fg {
-                    Color::Reset | Color::White | Color::Black => Color::Rgb(35, 47, 42),
-                    Color::DarkGray => Color::Rgb(104, 115, 108),
-                    Color::Gray => Color::Rgb(79, 92, 84),
-                    ACCENT | WATERMARK_MARK => Color::Rgb(20, 119, 77),
-                    BLUE => Color::Rgb(31, 94, 165),
-                    WATERMARK_RIM => Color::Rgb(86, 145, 122),
-                    WATERMARK_BAND => Color::Rgb(171, 200, 182),
-                    WATERMARK_ORBIT => Color::Rgb(112, 161, 132),
-                    Color::Yellow => Color::Rgb(139, 93, 12),
+                    Color::Reset | Color::White | Color::Black => tokens.text,
+                    Color::DarkGray => tokens.muted,
+                    Color::Gray => tokens.subtle,
+                    ACCENT | WATERMARK_MARK => tokens.accent,
+                    BLUE => tokens.blue,
+                    CARD_BORDER => Color::Rgb(175, 180, 188),
+                    WATERMARK_RIM => tokens.watermark_rim,
+                    WATERMARK_BAND => tokens.watermark_band,
+                    WATERMARK_ORBIT => tokens.watermark_orbit,
+                    Color::Yellow => tokens.warning,
                     other => other,
                 };
                 cell.bg = match cell.bg {
-                    Color::Reset => Color::Rgb(247, 249, 246),
-                    PANEL_BACKGROUND => Color::Rgb(228, 238, 230),
-                    USER_MESSAGE_BACKGROUND => Color::Rgb(225, 225, 225),
-                    Color::Gray => Color::Rgb(185, 215, 196),
+                    Color::Reset => tokens.background,
+                    PANEL_BACKGROUND => tokens.panel_background,
+                    USER_MESSAGE_BACKGROUND => tokens.user_message_background,
+                    Color::Gray => tokens.selection_background,
                     other => other,
                 };
             }
@@ -164,10 +246,52 @@ pub const SELECTION_TEXT: Color = Color::Black;
 pub const SELECTION_BACKGROUND: Color = Color::Gray;
 pub const PANEL_BACKGROUND: Color = Color::Rgb(38, 48, 45); // #26302D
 pub const USER_MESSAGE_BACKGROUND: Color = Color::Rgb(64, 64, 64); // #404040
+/// Gray card surface and border tokens for framed transcript cards (e.g. Release Notes).
+pub const CARD_BACKGROUND: Color = USER_MESSAGE_BACKGROUND; // Color::Rgb(64, 64, 64) - matches user message bubble
+pub const CARD_BORDER: Color = Color::Rgb(115, 120, 130); // #737882 - clear neutral gray border
 /// Endpoints for the animated white glow used by the TUI thinking status.
 pub const THINKING_GLOW_DIM: (u8, u8, u8) = (100, 100, 110);
 pub const THINKING_GLOW_BRIGHT: (u8, u8, u8) = (255, 255, 255);
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn theme_tokens_and_preview_colors_remain_aligned() {
+        for theme in [TuiTheme::Auto, TuiTheme::Dark, TuiTheme::Light] {
+            let tokens = theme_tokens(theme);
+            let preview = preview_colors(theme);
+            assert_eq!(preview.text, tokens.text);
+            assert_eq!(preview.added, tokens.added);
+            assert_eq!(preview.removed, tokens.removed);
+            assert_eq!(preview.added_background, tokens.added_background);
+            assert_eq!(preview.removed_background, tokens.removed_background);
+        }
+    }
+
+    #[test]
+    fn card_tokens_preserve_gray_background_in_auto_and_adapt_in_light() {
+        use ratatui::layout::Rect;
+
+        // In Auto theme, card background must not get cleared to Reset
+        let mut buf_auto = Buffer::empty(Rect::new(0, 0, 2, 2));
+        buf_auto[(0, 0)].set_bg(CARD_BACKGROUND).set_fg(CARD_BORDER);
+        apply_tui_theme(&mut buf_auto, TuiTheme::Auto);
+        assert_eq!(buf_auto[(0, 0)].bg, CARD_BACKGROUND);
+        assert_eq!(buf_auto[(0, 0)].fg, CARD_BORDER);
+
+        // In Light theme, card background and border adapt to light surface
+        let mut buf_light = Buffer::empty(Rect::new(0, 0, 2, 2));
+        buf_light[(0, 0)]
+            .set_bg(CARD_BACKGROUND)
+            .set_fg(CARD_BORDER);
+        apply_tui_theme(&mut buf_light, TuiTheme::Light);
+        assert_eq!(buf_light[(0, 0)].bg, Color::Rgb(225, 225, 225));
+        assert_eq!(buf_light[(0, 0)].fg, Color::Rgb(175, 180, 188));
+    }
+}
+
 pub const ANSI_RESET: &str = "\x1b[0m";
 pub const ANSI_BOLD: &str = "\x1b[1m";
 pub const ANSI_ACCENT: &str = "\x1b[38;2;105;230;166m";

package/crates/mint-cli/tests/library_intake.rs

@@ -36,6 +36,7 @@ fn cli_agent_and_plain_chat_save_attachments_before_provider_failure() {
         let output = command
             .current_dir(&root)
             .env("MINT_CONFIG_PATH", root.join("config.json"))
+            .env("MINT_CONFIG_DIR", root.join("config/mint"))
             .env("XDG_CONFIG_HOME", root.join("config"))
             .env("XDG_DATA_HOME", root.join("data"))
             .env("XDG_CACHE_HOME", root.join("cache"))

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

@@ -0,0 +1,318 @@
+use reqwest::Client;
+use serde_json::{Value, json};
+
+use super::streaming::{StreamFormat, collect_stream_reply};
+use super::{
+    ProviderReply, effective_system_instruction, effective_temperature, effective_thinking,
+    extract_think_tag, provider_key, required_key, split_data_uri,
+};
+use crate::{
+    ChatError, ChatMessage, ChatRequest, ChatRole, ChatStreamEvent, ContentBlock, MintConfig,
+    ToolCall,
+};
+
+pub(super) async fn call_anthropic(
+    client: &Client,
+    config: &MintConfig,
+    request: &ChatRequest,
+) -> Result<ProviderReply, ChatError> {
+    let api_key = provider_key(&config.anthropic_api_key, "ANTHROPIC_API_KEY");
+    required_key("anthropic", &api_key)?;
+    let model = config.anthropic_model.clone();
+    let payload = anthropic_chat_payload(config, &model, request, false)?;
+    let response: Value = client
+        .post("https://api.anthropic.com/v1/messages")
+        .header("x-api-key", api_key)
+        .header("anthropic-version", "2023-06-01")
+        .header("anthropic-beta", "prompt-caching-2024-07-31")
+        .json(&payload)
+        .send()
+        .await?
+        .error_for_status()?
+        .json()
+        .await?;
+    parse_anthropic_reply(model, &response)
+}
+
+pub(super) async fn stream_anthropic_reply<F>(
+    client: &Client,
+    config: &MintConfig,
+    request: &ChatRequest,
+    on_event: &mut F,
+) -> Result<ProviderReply, ChatError>
+where
+    F: FnMut(ChatStreamEvent),
+{
+    let api_key = provider_key(&config.anthropic_api_key, "ANTHROPIC_API_KEY");
+    required_key("anthropic", &api_key)?;
+    let model = config.anthropic_model.clone();
+    let payload = anthropic_chat_payload(config, &model, request, true)?;
+    let response = client
+        .post("https://api.anthropic.com/v1/messages")
+        .header("x-api-key", api_key)
+        .header("anthropic-version", "2023-06-01")
+        .header("anthropic-beta", "prompt-caching-2024-07-31")
+        .json(&payload)
+        .send()
+        .await?
+        .error_for_status()?;
+    collect_stream_reply(response, StreamFormat::Anthropic, model, on_event).await
+}
+
+pub(super) fn anthropic_chat_payload(
+    config: &MintConfig,
+    model: &str,
+    request: &ChatRequest,
+    stream: bool,
+) -> Result<Value, ChatError> {
+    let system_instruction = effective_system_instruction(config, request, "anthropic", model);
+    let system = anthropic_system_blocks(&system_instruction);
+    let (thinking_enabled, thinking_effort) = effective_thinking(config, request, model);
+    let is_thinking_supported = MintConfig::has_native_thinking_api("anthropic", model);
+    let use_thinking = thinking_enabled && is_thinking_supported;
+
+    let (budget, max_tokens, temp) = if use_thinking {
+        let b = match thinking_effort.as_str() {
+            "low" => 1024,
+            "medium" => 4096,
+            "high" => 16384,
+            "extra_high" => 32768,
+            _ => 4096,
+        };
+        (Some(b), b + 8192, 1.0)
+    } else {
+        (None, 8192, effective_temperature(config, request))
+    };
+
+    let mut payload = if let Some(messages) = &request.messages {
+        json!({
+            "model": model,
+            "max_tokens": max_tokens,
+            "system": system,
+            "messages": anthropic_messages(messages)?,
+            "temperature": temp,
+        })
+    } else {
+        json!({
+            "model": model,
+            "max_tokens": max_tokens,
+            "system": system,
+            "messages": [{
+                "role": "user",
+                "content": anthropic_message_content(&request.message, request.image_data_uri.as_deref())?,
+            }],
+            "temperature": temp,
+        })
+    };
+    if let Some(b) = budget {
+        payload["thinking"] = json!({
+            "type": "enabled",
+            "budget_tokens": b,
+        });
+    }
+    if stream {
+        payload["stream"] = json!(true);
+    }
+    if let Some(tools) = &request.tools {
+        let last_idx = tools.len().saturating_sub(1);
+        payload["tools"] = json!(
+            tools
+                .iter()
+                .enumerate()
+                .map(|(i, tool)| {
+                    let mut value = json!({
+                        "name": tool.name,
+                        "description": tool.description,
+                        "input_schema": tool.parameters,
+                    });
+                    if i == last_idx {
+                        value["cache_control"] = json!({ "type": "ephemeral" });
+                    }
+                    value
+                })
+                .collect::<Vec<_>>()
+        );
+    }
+    Ok(payload)
+}
+
+pub(super) fn anthropic_system_blocks(system_instruction: &str) -> Value {
+    if system_instruction.is_empty() {
+        return json!(system_instruction);
+    }
+    json!([{
+        "type": "text",
+        "text": system_instruction,
+        "cache_control": { "type": "ephemeral" },
+    }])
+}
+
+pub(super) fn anthropic_messages(messages: &[ChatMessage]) -> Result<Vec<Value>, ChatError> {
+    let non_system: Vec<&ChatMessage> = messages
+        .iter()
+        .filter(|message| message.role != ChatRole::System)
+        .collect();
+
+    let cache_idx = if non_system.len() >= 2 {
+        Some(non_system.len() - 2)
+    } else {
+        None
+    };
+
+    non_system
+        .into_iter()
+        .enumerate()
+        .map(|(i, message)| {
+            let role = match message.role {
+                ChatRole::Assistant => "assistant",
+                _ => "user",
+            };
+            let mut content = message
+                .content
+                .iter()
+                .map(anthropic_content_block)
+                .collect::<Result<Vec<_>, _>>()?;
+
+            if Some(i) == cache_idx
+                && let Some(last_block) = content.last_mut()
+            {
+                if let Some(obj) = last_block.as_object_mut() {
+                    obj.insert("cache_control".to_string(), json!({ "type": "ephemeral" }));
+                }
+            }
+
+            Ok(json!({ "role": role, "content": content }))
+        })
+        .collect()
+}
+
+pub(super) fn anthropic_message_content(
+    text: &str,
+    image_data_uri: Option<&str>,
+) -> Result<Value, ChatError> {
+    let Some(image_data) = image_data_uri else {
+        return Ok(json!(text));
+    };
+    let mut parts = vec![json!({ "type": "text", "text": text })];
+    for img in image_data.split_whitespace() {
+        let (mime_type, data) = split_data_uri(img, "image/")?;
+        parts.push(json!({
+            "type": "image",
+            "source": { "type": "base64", "media_type": mime_type, "data": data },
+        }));
+    }
+    Ok(json!(parts))
+}
+
+pub(super) fn anthropic_content_block(block: &ContentBlock) -> Result<Value, ChatError> {
+    Ok(match block {
+        ContentBlock::Text { text } => json!({ "type": "text", "text": text }),
+        ContentBlock::ToolUse {
+            id, name, input, ..
+        } => {
+            json!({ "type": "tool_use", "id": id, "name": name, "input": input })
+        }
+        ContentBlock::ToolResult {
+            tool_use_id,
+            content,
+            is_error,
+        } => json!({
+            "type": "tool_result",
+            "tool_use_id": tool_use_id,
+            "content": content,
+            "is_error": is_error,
+        }),
+        ContentBlock::Image { data_uri } => {
+            let (mime_type, data) = split_data_uri(data_uri, "image/")?;
+            json!({
+                "type": "image",
+                "source": { "type": "base64", "media_type": mime_type, "data": data },
+            })
+        }
+        ContentBlock::Audio { .. } | ContentBlock::Video { .. } => {
+            return Err(ChatError::UnsupportedAttachments("anthropic".into()));
+        }
+    })
+}
+
+pub(crate) 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)
+}
+
+pub(super) 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();
+    let mut thought_parts: Vec<&str> = Vec::new();
+    let mut tool_calls = Vec::new();
+    for block in &blocks {
+        match block["type"].as_str() {
+            Some("text") => {
+                if let Some(t) = block["text"].as_str() {
+                    text.push_str(t);
+                }
+            }
+            Some("thinking") => {
+                if let Some(t) = block["thinking"].as_str() {
+                    thought_parts.push(t);
+                }
+            }
+            Some("tool_use") => {
+                tool_calls.push(ToolCall {
+                    id: block["id"].as_str().unwrap_or_default().into(),
+                    name: block["name"].as_str().unwrap_or_default().into(),
+                    input: block["input"].clone(),
+                    thought_signature: None,
+                });
+            }
+            _ => {}
+        }
+    }
+    let direct_thought = if !thought_parts.is_empty() {
+        Some(thought_parts.join("").trim().to_string()).filter(|s| !s.is_empty())
+    } else {
+        None
+    };
+    let (thought, text) = if direct_thought.is_none() {
+        extract_think_tag(&text)
+    } else {
+        (direct_thought, text)
+    };
+    if text.is_empty() && tool_calls.is_empty() {
+        if let Some(th) = &thought {
+            return Ok(ProviderReply {
+                model,
+                text: th.clone(),
+                thought: Some(th.clone()),
+                tool_calls: None,
+                stop_reason: response["stop_reason"].as_str().map(str::to_owned),
+                input_tokens: anthropic_input_tokens(&response["usage"]),
+                output_tokens: response["usage"]["output_tokens"]
+                    .as_u64()
+                    .map(|n| n as u32),
+            });
+        }
+        return Err(ChatError::MissingResponseText);
+    }
+    Ok(ProviderReply {
+        model,
+        text,
+        thought,
+        tool_calls: (!tool_calls.is_empty()).then_some(tool_calls),
+        stop_reason: response["stop_reason"].as_str().map(str::to_owned),
+        input_tokens: anthropic_input_tokens(&response["usage"]),
+        output_tokens: response["usage"]["output_tokens"]
+            .as_u64()
+            .map(|n| n as u32),
+    })
+}