@pheem49/mint 1.16.0 → 1.18.0

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

@@ -1,4155 +0,0 @@
-use futures_util::StreamExt;
-use reqwest::Client;
-use serde::{Deserialize, Serialize};
-use serde_json::{Value, json};
-use thiserror::Error;
-
-use crate::MintConfig;
-
-/// Provider-neutral pieces produced while a model response is still arriving.
-/// Callers never need to know which vendor-specific field carried the data.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ChatStreamEvent {
-    TextDelta {
-        delta: String,
-    },
-    ReasoningDelta {
-        delta: String,
-    },
-    ToolCallDelta {
-        index: usize,
-        name: Option<String>,
-        arguments: Option<String>,
-        input: Option<Value>,
-    },
-}
-
-/// `available_providers()`'s configured-providers list, reordered so
-/// `gemini` is tried first among fallbacks (when it's configured and isn't
-/// already the primary) — the user's explicit preference, ahead of
-/// `available_providers()`'s own anthropic/openai/openrouter/deepseek/
-/// gemini/... ordering (which exists for display purposes, e.g. the
-/// `/models` picker, and is left alone). Everything else keeps its existing
-/// relative order.
-fn fallback_provider_order(config: &MintConfig) -> Vec<String> {
-    let mut providers = config.available_providers();
-    if let Some(pos) = providers.iter().position(|p| p == "gemini") {
-        let gemini = providers.remove(pos);
-        providers.insert(0, gemini);
-    }
-    providers
-}
-
-/// Send a chat request, automatically falling back to other configured providers
-/// if the primary one returns a recoverable error. Tries `gemini` first among
-/// the fallbacks when it's configured (see `fallback_provider_order`), then
-/// the rest in their usual order.
-/// Returns `(response, Option<fallback_provider>)`.
-pub async fn send_chat_with_fallback(
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<(ChatResponse, Option<String>), ChatError> {
-    let primary_error = match send_chat(config, request).await {
-        Ok(r) => return Ok((r, None)),
-        Err(e) if !is_recoverable(&e) => return Err(e),
-        Err(e) => e,
-    };
-    // No point cycling through other cloud providers if the network itself is
-    // unreachable — they all sit behind the same dead link, so every attempt
-    // would just fail the same way after its own connect timeout. Surface
-    // this immediately so the caller can retry-and-wait instead.
-    if matches!(primary_error, ChatError::NetworkUnavailable) {
-        return Err(primary_error);
-    }
-    let fallback_reason = fallback_reason_text(&config.ai_provider, &primary_error);
-    for provider in fallback_provider_order(config) {
-        if provider.as_str() == config.ai_provider.as_str() {
-            continue;
-        }
-        let alt = config_for_provider(config, &provider);
-        if let Ok(mut r) = send_chat(&alt, request).await {
-            r.fallback_provider = Some(config.ai_provider.clone());
-            r.fallback_reason = fallback_reason.clone();
-            return Ok((r, Some(provider)));
-        }
-    }
-    // all fallbacks failed — retry primary to surface original error
-    send_chat(config, request).await.map(|r| (r, None))
-}
-
-/// Short, human-readable explanation for why `send_chat_with_fallback` swapped
-/// away from `provider` — `None` for an ordinary transient failure, so routine
-/// hiccups don't get an extra notice while specific, actionable ones do.
-fn fallback_reason_text(provider: &str, error: &ChatError) -> Option<String> {
-    let provider_name = if provider.starts_with("custom:") {
-        provider.strip_prefix("custom:").unwrap_or(provider)
-    } else {
-        provider
-    };
-    match error {
-        ChatError::InsufficientBalance(_) => Some(format!("{provider_name} ran out of balance")),
-        ChatError::Request(e) => {
-            if let Some(status) = e.status() {
-                if status == reqwest::StatusCode::PAYLOAD_TOO_LARGE {
-                    Some(format!("{provider_name} payload too large (HTTP 413)"))
-                } else if status == reqwest::StatusCode::TOO_MANY_REQUESTS {
-                    Some(format!("{provider_name} rate limit exceeded (HTTP 429)"))
-                } else {
-                    Some(format!("{provider_name} returned HTTP {status}"))
-                }
-            } else {
-                None
-            }
-        }
-        _ => None,
-    }
-}
-
-/// Stream a chat request with automatic provider fallback.
-/// Returns `(response, Option<fallback_provider>)`.
-pub async fn stream_chat_with_fallback<F>(
-    config: &MintConfig,
-    request: &ChatRequest,
-    mut on_chunk: F,
-) -> Result<(ChatResponse, Option<String>), ChatError>
-where
-    F: FnMut(String),
-{
-    let primary_error = match stream_chat(config, request, &mut on_chunk).await {
-        Ok(r) => return Ok((r, None)),
-        Err(e) if !is_recoverable(&e) => return Err(e),
-        Err(e) => {
-            eprintln!("Ollama stream chat failed, falling back: {:?}", e);
-            e
-        }
-    };
-    if matches!(primary_error, ChatError::NetworkUnavailable) {
-        return Err(primary_error);
-    }
-    let fallback_reason = fallback_reason_text(&config.ai_provider, &primary_error);
-    for provider in fallback_provider_order(config) {
-        if provider.as_str() == config.ai_provider.as_str() {
-            continue;
-        }
-        let alt = config_for_provider(config, &provider);
-        if let Ok(mut r) = stream_chat(&alt, request, &mut on_chunk).await {
-            r.fallback_provider = Some(config.ai_provider.clone());
-            r.fallback_reason = fallback_reason.clone();
-            return Ok((r, Some(provider)));
-        }
-    }
-    stream_chat(config, request, &mut on_chunk)
-        .await
-        .map(|r| (r, None))
-}
-
-/// Streaming equivalent of [`send_chat_with_fallback`] that preserves the
-/// complete response (tool calls, usage, stop reason, and reasoning) while
-/// exposing provider-neutral deltas as they arrive.
-pub async fn stream_chat_events_with_fallback<F>(
-    config: &MintConfig,
-    request: &ChatRequest,
-    mut on_event: F,
-) -> Result<(ChatResponse, Option<String>), ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let primary_error = match stream_chat_events(config, request, &mut on_event).await {
-        Ok(r) => return Ok((r, None)),
-        Err(e) if !is_recoverable(&e) => return Err(e),
-        Err(e) => e,
-    };
-    if matches!(primary_error, ChatError::NetworkUnavailable) {
-        return Err(primary_error);
-    }
-    let fallback_reason = fallback_reason_text(&config.ai_provider, &primary_error);
-    for provider in fallback_provider_order(config) {
-        if provider == config.ai_provider {
-            continue;
-        }
-        let alt = config_for_provider(config, &provider);
-        if let Ok(mut response) = stream_chat_events(&alt, request, &mut on_event).await {
-            response.fallback_provider = Some(config.ai_provider.clone());
-            response.fallback_reason = fallback_reason.clone();
-            return Ok((response, Some(provider)));
-        }
-    }
-    stream_chat_events(config, request, &mut on_event)
-        .await
-        .map(|response| (response, None))
-}
-
-/// Whether an error warrants trying another provider.
-fn is_recoverable(e: &ChatError) -> bool {
-    matches!(
-        e,
-        ChatError::MissingApiKey(_)
-            | ChatError::Request(_)
-            | ChatError::MissingResponseText
-            | ChatError::UnsupportedAttachments(_)
-            | ChatError::InsufficientBalance(_)
-            | ChatError::NetworkUnavailable
-    )
-}
-
-/// Clone the config with a different active provider.
-fn config_for_provider(config: &MintConfig, provider: &str) -> MintConfig {
-    MintConfig {
-        ai_provider: provider.to_owned(),
-        ..config.clone()
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Default)]
-#[serde(rename_all = "camelCase")]
-pub struct ChatRequest {
-    pub message: String,
-    #[serde(default)]
-    pub system_instruction: String,
-    #[serde(default)]
-    pub chat_id: Option<String>,
-    #[serde(default)]
-    pub image_data_uri: Option<String>,
-    #[serde(default)]
-    pub audio_data_uri: Option<String>,
-    #[serde(default)]
-    pub video_data_uri: Option<String>,
-    #[serde(default)]
-    pub document_attachment: Option<DocumentAttachment>,
-    #[serde(default)]
-    pub workspace_path: Option<String>,
-    #[serde(default)]
-    pub agent_id: Option<String>,
-    #[serde(default)]
-    pub plan_mode: bool,
-    /// When set, restricts this turn's `mcp_tool`/`mcp_list_tools` calls to this one
-    /// configured MCP server — set by picking a plugin from the composer's `@` mention
-    /// dropdown, rather than leaving server selection to the model's own judgment.
-    #[serde(default)]
-    pub pinned_mcp_server: Option<String>,
-    /// Structured conversation history for native tool-calling. When set, provider
-    /// adapters build the request from this instead of the flat `message` field.
-    #[serde(default)]
-    pub messages: Option<Vec<ChatMessage>>,
-    /// Tool definitions to offer the model via each provider's native
-    /// function/tool-calling API. Ignored when `messages` is `None`.
-    #[serde(default)]
-    pub tools: Option<Vec<ToolSpec>>,
-    /// Optional per-request temperature override. When `None`, falls back to
-    /// `config.resolved_temperature()`.
-    #[serde(default)]
-    pub temperature: Option<f64>,
-    /// Optional per-request thinking/reasoning enabled override.
-    #[serde(default)]
-    pub thinking_enabled: Option<bool>,
-    /// Optional per-request thinking effort override ("low", "medium", "high", "extra_high").
-    #[serde(default)]
-    pub thinking_effort: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub enum ChatRole {
-    System,
-    User,
-    Assistant,
-    Tool,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChatMessage {
-    pub role: ChatRole,
-    pub content: Vec<ContentBlock>,
-}
-
-impl ChatMessage {
-    pub fn text(role: ChatRole, text: impl Into<String>) -> Self {
-        ChatMessage {
-            role,
-            content: vec![ContentBlock::Text { text: text.into() }],
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "camelCase")]
-pub enum ContentBlock {
-    Text {
-        text: String,
-    },
-    ToolUse {
-        id: String,
-        name: String,
-        input: Value,
-        /// See `ToolCall::thought_signature` — carried on `ToolUse` too so it
-        /// survives being replayed back into `native_messages` history on the
-        /// next turn. `None` for every provider but Gemini.
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        thought_signature: Option<String>,
-    },
-    ToolResult {
-        tool_use_id: String,
-        content: String,
-        #[serde(default)]
-        is_error: bool,
-    },
-    Image {
-        data_uri: String,
-    },
-    Audio {
-        data_uri: String,
-    },
-    Video {
-        data_uri: String,
-    },
-}
-
-/// A tool definition offered to the model via native function/tool-calling.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ToolSpec {
-    pub name: String,
-    pub description: String,
-    /// JSON schema (draft-7-ish, as accepted by the provider's tool-parameter format).
-    pub parameters: Value,
-}
-
-/// A tool invocation the model requested via native function/tool-calling.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ToolCall {
-    pub id: String,
-    pub name: String,
-    pub input: Value,
-    /// Gemini 3.x's "thinking" models attach an opaque `thoughtSignature` to
-    /// each `functionCall` part; it must be echoed back verbatim on the next
-    /// turn's replayed `functionCall` or the API rejects the request with a
-    /// 400 (`INVALID_ARGUMENT: Function call is missing a thought_signature`).
-    /// `None` for every other provider.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub thought_signature: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DocumentAttachment {
-    pub filename: String,
-    pub data_uri: String,
-}
-
-const MAX_DOCUMENT_BYTES: usize = 10 * 1024 * 1024;
-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());
-        };
-
-        let (_mime_type, encoded) = document
-            .data_uri
-            .strip_prefix("data:")
-            .and_then(|payload| payload.split_once(";base64,"))
-            .ok_or_else(|| "invalid document attachment data URI".to_string())?;
-
-        // Dispatch by the filename's extension, not the data URI's MIME type:
-        // browsers report an empty or generic `application/octet-stream` type
-        // for many of these formats (.md, .toml, .yaml, ...), so MIME type
-        // isn't a reliable signal here. `extract_document_text` below performs
-        // the real allowlist check and rejects anything it doesn't recognize.
-        let extension = std::path::Path::new(document.filename.trim())
-            .extension()
-            .and_then(|ext| ext.to_str())
-            .map(|ext| ext.to_ascii_lowercase())
-            .filter(|ext| !ext.is_empty())
-            .unwrap_or_else(|| "txt".to_string());
-
-        use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
-        let bytes = BASE64_STANDARD
-            .decode(encoded)
-            .map_err(|error| format!("invalid document attachment encoding: {error}"))?;
-        if bytes.len() > MAX_DOCUMENT_BYTES {
-            return Err("document attachment is too large (> 10 MiB)".into());
-        }
-
-        let directory = crate::config::config_path()
-            .map_err(|error| error.to_string())?
-            .with_file_name("Attachments");
-        std::fs::create_dir_all(&directory).map_err(|error| error.to_string())?;
-
-        let safe_name: String = document
-            .filename
-            .chars()
-            .filter(|c| c.is_ascii_alphanumeric() || matches!(*c, '.' | '-' | '_'))
-            .take(80)
-            .collect();
-        let safe_name = if safe_name.is_empty() {
-            "document".into()
-        } else {
-            safe_name
-        };
-
-        let path = directory.join(format!(
-            "mint-doc-{}-{}.{}",
-            COUNTER.fetch_add(1, std::sync::atomic::Ordering::SeqCst),
-            safe_name,
-            extension
-        ));
-        std::fs::write(&path, bytes).map_err(|error| error.to_string())?;
-
-        let extracted = crate::knowledge::extract_document_text(&path, config)
-            .map_err(|error| error.to_string());
-        let _ = std::fs::remove_file(&path);
-        let extracted = extracted?;
-
-        self.with_document_text(document, extracted)
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChatResponse {
-    pub provider: String,
-    pub model: String,
-    pub text: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fallback_provider: Option<String>,
-    /// Short, human-readable reason `send_chat_with_fallback` swapped providers,
-    /// when the primary's failure was specific enough to explain (insufficient
-    /// balance, no network) — `None` for an ordinary transient error, so a
-    /// ordinary hiccup doesn't get an extra notice while a genuinely actionable
-    /// one does.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fallback_reason: Option<String>,
-    /// Tool calls the model requested via native function/tool-calling, when the
-    /// request set `ChatRequest.tools` and the provider honored it.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_calls: Option<Vec<ToolCall>>,
-    /// Provider-reported reason generation stopped (e.g. `"tool_use"`, `"end_turn"`,
-    /// `"stop"`, `"max_tokens"`), when the provider reports one.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop_reason: Option<String>,
-    /// Total tokens (input + output) the provider billed for this turn, when
-    /// reported. Used to track how close a long-running conversation is to the
-    /// model's context window, rather than estimating client-side. Derived from
-    /// `input_tokens + output_tokens` when both are present.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub total_tokens: Option<u32>,
-    /// Prompt/context tokens the provider processed for this turn (the whole
-    /// resent history + system prompt + tool schemas), when reported — the
-    /// "sent up to the model" half, tracked separately from `output_tokens` so
-    /// the UI can show `↑ context · ↓ generated` instead of one opaque sum.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub input_tokens: Option<u32>,
-    /// Completion tokens the model generated this turn, when reported — the
-    /// "came back down from the model" half. See `input_tokens`.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_tokens: Option<u32>,
-    /// Model reasoning / chain-of-thought tokens, when reported by reasoning models
-    /// (e.g. DeepSeek Reasoner, Claude 3.7 Thinking, Gemini Thinking, or <think> tags).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub thought: Option<String>,
-}
-
-/// Internal, provider-agnostic result of a single non-streaming provider call.
-/// `send_chat` maps this onto the public `ChatResponse`.
-struct ProviderReply {
-    model: String,
-    text: String,
-    thought: Option<String>,
-    tool_calls: Option<Vec<ToolCall>>,
-    stop_reason: Option<String>,
-    /// Prompt/context tokens processed for this call, when the provider reports
-    /// usage. `send_chat` derives `ChatResponse::total_tokens` from this plus
-    /// `output_tokens`.
-    input_tokens: Option<u32>,
-    /// Completion tokens generated for this call, when reported.
-    output_tokens: Option<u32>,
-}
-
-#[derive(Debug, Error)]
-pub enum ChatError {
-    #[error("provider '{0}' is not implemented in the Rust backend yet")]
-    UnsupportedProvider(String),
-    #[error("missing API key for provider '{0}'")]
-    MissingApiKey(String),
-    #[error("provider request failed: {0}")]
-    Request(#[from] reqwest::Error),
-    #[error("provider response did not include assistant text")]
-    MissingResponseText,
-    #[error("provider '{0}' does not support Mint multimodal attachments yet")]
-    UnsupportedAttachments(String),
-    #[error("invalid multimodal data URI")]
-    InvalidAttachment,
-    /// Provider returned `402 Payment Required` — distinguished from the generic
-    /// `Request` case so callers can tell "your account ran out of balance" apart
-    /// from an ordinary transient failure instead of silently swapping providers
-    /// with no explanation.
-    #[error("provider '{0}' rejected the request: insufficient balance")]
-    InsufficientBalance(String),
-    /// The request never reached any server at all (DNS failure, connection
-    /// refused, no route) — as opposed to reaching a server that returned an
-    /// error. Distinguished so a caller can retry-and-wait instead of pointlessly
-    /// cycling through other cloud providers that sit behind the same dead
-    /// network link.
-    #[error("no network connection to reach the provider")]
-    NetworkUnavailable,
-    #[error("provider API error: {0}")]
-    Api(String),
-}
-
-pub async fn send_chat(
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ChatResponse, ChatError> {
-    let client = crate::HTTP_CLIENT.clone();
-    let provider = config.ai_provider.as_str();
-    require_supported_attachments(provider, request)?;
-    let reply = match provider {
-        "gemini" => call_gemini(&client, config, request).await?,
-        "openai" | "local_openai" | "openrouter" | "deepseek" => {
-            call_openai(&client, config, request).await?
-        }
-        "ollama" => call_ollama(&client, config, request).await?,
-        "anthropic" => call_anthropic(&client, config, request).await?,
-        "huggingface" => call_huggingface(&client, config, request).await?,
-        p if p.starts_with("custom:") => call_custom_provider(&client, config, request).await?,
-        other => return Err(ChatError::UnsupportedProvider(other.into())),
-    };
-    Ok(ChatResponse {
-        provider: provider.into(),
-        model: reply.model,
-        text: reply.text,
-        thought: reply.thought,
-        fallback_provider: None,
-        fallback_reason: None,
-        tool_calls: reply.tool_calls,
-        stop_reason: reply.stop_reason,
-        total_tokens: match (reply.input_tokens, reply.output_tokens) {
-            (Some(i), Some(o)) => Some(i + o),
-            (i, o) => i.or(o),
-        },
-        input_tokens: reply.input_tokens,
-        output_tokens: reply.output_tokens,
-    })
-}
-
-pub async fn stream_chat<F>(
-    config: &MintConfig,
-    request: &ChatRequest,
-    mut on_chunk: F,
-) -> Result<ChatResponse, ChatError>
-where
-    F: FnMut(String),
-{
-    stream_chat_events(config, request, |event| {
-        if let ChatStreamEvent::TextDelta { delta } = event {
-            on_chunk(delta);
-        }
-    })
-    .await
-}
-
-pub async fn stream_chat_events<F>(
-    config: &MintConfig,
-    request: &ChatRequest,
-    mut on_event: F,
-) -> Result<ChatResponse, ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let client = crate::HTTP_CLIENT.clone();
-    let provider = config.ai_provider.as_str();
-    require_supported_attachments(provider, request)?;
-    let reply = match provider {
-        "gemini" => stream_gemini_reply(&client, config, request, &mut on_event).await?,
-        "openai" | "local_openai" | "openrouter" | "deepseek" => {
-            stream_openai_reply(&client, config, request, &mut on_event).await?
-        }
-        "ollama" => stream_ollama_reply(&client, config, request, &mut on_event).await?,
-        "anthropic" => stream_anthropic_reply(&client, config, request, &mut on_event).await?,
-        "huggingface" => stream_huggingface_reply(&client, config, request, &mut on_event).await?,
-        p if p.starts_with("custom:") => {
-            stream_custom_provider_reply(&client, config, request, &mut on_event).await?
-        }
-        other => return Err(ChatError::UnsupportedProvider(other.into())),
-    };
-    Ok(ChatResponse {
-        provider: provider.into(),
-        model: reply.model,
-        text: reply.text,
-        thought: reply.thought,
-        fallback_provider: None,
-        fallback_reason: None,
-        tool_calls: reply.tool_calls,
-        stop_reason: reply.stop_reason,
-        total_tokens: match (reply.input_tokens, reply.output_tokens) {
-            (Some(input), Some(output)) => Some(input + output),
-            (input, output) => input.or(output),
-        },
-        input_tokens: reply.input_tokens,
-        output_tokens: reply.output_tokens,
-    })
-}
-
-async fn call_gemini(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ProviderReply, ChatError> {
-    let api_key = provider_key(&config.api_key, "GEMINI_API_KEY");
-    required_key("gemini", &api_key)?;
-    let model = config.gemini_model.clone();
-    let url =
-        format!("https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent");
-
-    let payload = if request.messages.is_some() {
-        let mut p = gemini_native_payload(request)?;
-        let temp = effective_temperature(config, request);
-        let mut gen_cfg = json!({ "temperature": temp });
-        gemini_apply_thinking_config(&mut gen_cfg, config, request, &model);
-        p["generationConfig"] = gen_cfg;
-        p
-    } else {
-        gemini_chat_payload(config, request)?
-    };
-
-    let response: Value = client
-        .post(url)
-        .header("x-goog-api-key", api_key)
-        .json(&payload)
-        .send()
-        .await?
-        .error_for_status()?
-        .json()
-        .await?;
-    parse_gemini_reply(model, &response)
-}
-
-/// Strips JSON Schema keywords that standard tool-parameter schemas use (built
-/// once and shared across OpenAI/Anthropic/Gemini) but that Gemini's function-
-/// calling `Schema` proto rejects outright — e.g. `additionalProperties` on an
-/// object property, as in `avatar_signal`'s `emotions` map, previously caused
-/// every native tool-calling turn to fail with `400 INVALID_ARGUMENT: Unknown
-/// name "additionalProperties"`, silently falling back to a weaker provider on
-/// every single Gemini turn.
-fn gemini_sanitize_schema(schema: &Value) -> Value {
-    match schema {
-        Value::Object(map) => Value::Object(
-            map.iter()
-                .filter(|(key, _)| key.as_str() != "additionalProperties")
-                .map(|(key, value)| (key.clone(), gemini_sanitize_schema(value)))
-                .collect(),
-        ),
-        Value::Array(items) => Value::Array(items.iter().map(gemini_sanitize_schema).collect()),
-        other => other.clone(),
-    }
-}
-
-/// Builds a Gemini `generateContent` payload from structured history, using
-/// native `functionDeclarations`/`functionCall`/`functionResponse` instead of
-/// the legacy `responseSchema` JSON-prompt scheme (see `gemini_chat_payload`).
-fn gemini_native_payload(request: &ChatRequest) -> Result<Value, ChatError> {
-    let messages = request.messages.as_deref().unwrap_or(&[]);
-    let mut payload = json!({
-        "systemInstruction": { "parts": [{ "text": request.system_instruction }] },
-        "contents": gemini_native_contents(messages)?,
-    });
-    if let Some(tools) = &request.tools {
-        payload["tools"] = json!([{
-            "functionDeclarations": tools.iter().map(|tool| json!({
-                "name": tool.name,
-                "description": tool.description,
-                "parameters": gemini_sanitize_schema(&tool.parameters),
-            })).collect::<Vec<_>>()
-        }]);
-    }
-    Ok(payload)
-}
-
-fn gemini_native_contents(messages: &[ChatMessage]) -> Result<Vec<Value>, ChatError> {
-    // Gemini's `functionResponse` part is matched by function *name*, not by a
-    // call id like Anthropic/OpenAI. Build an id -> name lookup from the
-    // `ToolUse` blocks already in history so `ToolResult` blocks (which only
-    // carry `tool_use_id`) can be translated correctly.
-    let mut tool_names: std::collections::HashMap<&str, &str> = std::collections::HashMap::new();
-    for message in messages {
-        for block in &message.content {
-            if let ContentBlock::ToolUse { id, name, .. } = block {
-                tool_names.insert(id.as_str(), name.as_str());
-            }
-        }
-    }
-    messages
-        .iter()
-        .filter(|message| message.role != ChatRole::System)
-        .map(|message| {
-            let role = match message.role {
-                ChatRole::Assistant => "model",
-                _ => "user",
-            };
-            let parts = message
-                .content
-                .iter()
-                .map(|block| gemini_native_part(block, &tool_names))
-                .collect::<Result<Vec<_>, _>>()?;
-            Ok(json!({ "role": role, "parts": parts }))
-        })
-        .collect()
-}
-
-fn gemini_native_part(
-    block: &ContentBlock,
-    tool_names: &std::collections::HashMap<&str, &str>,
-) -> Result<Value, ChatError> {
-    Ok(match block {
-        ContentBlock::Text { text } => json!({ "text": text }),
-        ContentBlock::ToolUse {
-            name,
-            input,
-            thought_signature,
-            ..
-        } => {
-            // A `thoughtSignature` captured off the model's own `functionCall`
-            // part must be echoed back verbatim here — a sibling key of
-            // `functionCall`, not nested inside it — or Gemini 3.x rejects the
-            // request outright (400 INVALID_ARGUMENT: "Function call is
-            // missing a thought_signature"), which without this looked like a
-            // recoverable provider error and silently triggered a fallback to
-            // a different (much weaker) provider on every second tool-calling
-            // turn. See `ToolCall::thought_signature`.
-            let mut part = json!({ "functionCall": { "name": name, "args": input } });
-            if let Some(signature) = thought_signature {
-                part["thoughtSignature"] = json!(signature);
-            }
-            part
-        }
-        ContentBlock::ToolResult {
-            tool_use_id,
-            content,
-            ..
-        } => {
-            let name = tool_names
-                .get(tool_use_id.as_str())
-                .copied()
-                .unwrap_or(tool_use_id.as_str());
-            json!({ "functionResponse": { "name": name, "response": { "result": content } } })
-        }
-        ContentBlock::Image { data_uri } => {
-            let (mime_type, data) = split_data_uri(data_uri, "image/")?;
-            json!({ "inlineData": { "mimeType": mime_type, "data": data } })
-        }
-        ContentBlock::Audio { data_uri } => {
-            let (mime_type, data) = split_data_uri(data_uri, "audio/")?;
-            json!({ "inlineData": { "mimeType": mime_type, "data": data } })
-        }
-        ContentBlock::Video { data_uri } => {
-            let (mime_type, data) = split_data_uri(data_uri, "video/")?;
-            json!({ "inlineData": { "mimeType": mime_type, "data": data } })
-        }
-    })
-}
-
-/// Extracts `<think>...</think>` chain-of-thought blocks emitted by reasoning models
-/// (e.g. DeepSeek-R1, QwQ) when embedded directly into plain text content.
-/// Returns `(Option<thought>, remaining_text)`.
-fn extract_think_tag(text: &str) -> (Option<String>, String) {
-    if let Some(start) = text.find("<think>") {
-        if let Some(end) = text[start + 7..].find("</think>") {
-            let thought = text[start + 7..start + 7 + end].trim().to_string();
-            let mut remaining = text[..start].to_string();
-            remaining.push_str(&text[start + 7 + end + 8..]);
-            let cleaned = remaining.trim().to_string();
-            (
-                if thought.is_empty() {
-                    None
-                } else {
-                    Some(thought)
-                },
-                cleaned,
-            )
-        } else {
-            let thought = text[start + 7..].trim().to_string();
-            let cleaned = text[..start].trim().to_string();
-            (
-                if thought.is_empty() {
-                    None
-                } else {
-                    Some(thought)
-                },
-                cleaned,
-            )
-        }
-    } else {
-        (None, text.to_string())
-    }
-}
-
-/// Parses a Gemini `generateContent` response, collecting text parts and any
-/// `functionCall` parts into tool calls. Gemini doesn't assign call ids, so a
-/// stable per-response index (`call_0`, `call_1`, ...) is synthesized; this is
-/// safe because `gemini_native_part` resolves `functionResponse` back to the
-/// function *name*, not the id.
-fn parse_gemini_reply(model: String, response: &Value) -> Result<ProviderReply, ChatError> {
-    let parts = response["candidates"][0]["content"]["parts"]
-        .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 (index, part) in parts.iter().enumerate() {
-        let is_thought = part
-            .get("thought")
-            .and_then(Value::as_bool)
-            .unwrap_or(false);
-        if let Some(t) = part["text"].as_str() {
-            if is_thought {
-                thought_parts.push(t);
-            } else {
-                text.push_str(t);
-            }
-        }
-        if let Some(call) = part.get("functionCall") {
-            tool_calls.push(ToolCall {
-                id: format!("call_{index}"),
-                name: call["name"].as_str().unwrap_or_default().to_string(),
-                input: call["args"].clone(),
-                // Sibling of `functionCall` within the same `part`, not nested
-                // inside it — see the module-level doc on `ToolCall::thought_signature`.
-                thought_signature: part
-                    .get("thoughtSignature")
-                    .and_then(Value::as_str)
-                    .map(str::to_owned),
-            });
-        }
-    }
-    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["candidates"][0]["finishReason"]
-                    .as_str()
-                    .map(str::to_owned),
-                input_tokens: response["usageMetadata"]["promptTokenCount"]
-                    .as_u64()
-                    .map(|n| n as u32),
-                output_tokens: response["usageMetadata"]["candidatesTokenCount"]
-                    .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["candidates"][0]["finishReason"]
-            .as_str()
-            .map(str::to_owned),
-        input_tokens: response["usageMetadata"]["promptTokenCount"]
-            .as_u64()
-            .map(|n| n as u32),
-        output_tokens: response["usageMetadata"]["candidatesTokenCount"]
-            .as_u64()
-            .map(|n| n as u32),
-    })
-}
-
-async fn call_openai(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ProviderReply, ChatError> {
-    let local = config.ai_provider == "local_openai";
-    let openrouter = config.ai_provider == "openrouter";
-    let deepseek = config.ai_provider == "deepseek";
-    let api_key = if openrouter {
-        provider_key(&config.openrouter_api_key, "OPENROUTER_API_KEY")
-    } else if deepseek {
-        provider_key(&config.deepseek_api_key, "DEEPSEEK_API_KEY")
-    } else {
-        provider_key(&config.openai_api_key, "OPENAI_API_KEY")
-    };
-    if openrouter {
-        required_key("openrouter", &api_key)?;
-    } else if deepseek {
-        required_key("deepseek", &api_key)?;
-    } else if !local {
-        required_key("openai", &api_key)?;
-    }
-    let base_url = if openrouter {
-        "https://openrouter.ai/api/v1"
-    } else if deepseek {
-        "https://api.deepseek.com"
-    } else if local {
-        config.local_api_base_url.trim_end_matches('/')
-    } else {
-        "https://api.openai.com/v1"
-    };
-    let model = if openrouter {
-        config.openrouter_model.clone()
-    } else if deepseek {
-        config.deepseek_model.clone()
-    } else if local {
-        config.local_model_name.clone()
-    } else {
-        config.openai_model.clone()
-    };
-    let response: Value = send_openai_style_request(
-        client
-            .post(format!("{base_url}/chat/completions"))
-            .bearer_auth(if local { "not-needed" } else { &api_key })
-            .json(&openai_chat_payload(config, &model, request, false)?),
-        &config.ai_provider,
-    )
-    .await?;
-    parse_openai_style_reply(model, &response)
-}
-
-/// Sends a built request, classifying the failure modes `.error_for_status()`
-/// would otherwise flatten into one opaque `reqwest::Error`: a connect-level
-/// failure (DNS, refused, no route — never reached the server at all) becomes
-/// `NetworkUnavailable`, and an HTTP `402 Payment Required` becomes
-/// `InsufficientBalance(provider)`. Shared by every OpenAI Chat
-/// Completions-shaped provider (`call_openai`, `call_huggingface`).
-async fn send_openai_style_request(
-    request: reqwest::RequestBuilder,
-    provider: &str,
-) -> Result<Value, ChatError> {
-    let response = request.send().await.map_err(|e| {
-        if e.is_connect() {
-            ChatError::NetworkUnavailable
-        } else {
-            ChatError::Request(e)
-        }
-    })?;
-    if response.status() == reqwest::StatusCode::PAYMENT_REQUIRED {
-        return Err(ChatError::InsufficientBalance(provider.to_string()));
-    }
-    if !response.status().is_success() {
-        let status = response.status();
-        let body = response.text().await.unwrap_or_default();
-        return Err(ChatError::Api(format!("HTTP {status}: {body}")));
-    }
-    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
-/// by nothing else — Ollama's native `/api/chat` response is shaped differently
-/// and has its own parser below.
-fn parse_openai_style_reply(model: String, response: &Value) -> Result<ProviderReply, ChatError> {
-    let message = &response["choices"][0]["message"];
-    let raw_text = message["content"].as_str().unwrap_or_default().to_string();
-    let direct_thought = message["reasoning_content"]
-        .as_str()
-        .or_else(|| message["reasoning"].as_str())
-        .or_else(|| message["thought"].as_str())
-        .or_else(|| message["thinking"].as_str())
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty());
-
-    let (thought, text) = if direct_thought.is_none() {
-        extract_think_tag(&raw_text)
-    } else {
-        (direct_thought, raw_text)
-    };
-
-    let tool_calls: Vec<ToolCall> = message["tool_calls"]
-        .as_array()
-        .map(|calls| {
-            calls
-                .iter()
-                .filter_map(|call| {
-                    let name = call["function"]["name"].as_str()?.to_string();
-                    let input = decode_tool_arguments(&call["function"]["arguments"]);
-                    Some(ToolCall {
-                        id: call["id"].as_str().unwrap_or_default().to_string(),
-                        name,
-                        input,
-                        thought_signature: None,
-                    })
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    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["choices"][0]["finish_reason"]
-                    .as_str()
-                    .map(str::to_owned),
-                input_tokens: response["usage"]["prompt_tokens"]
-                    .as_u64()
-                    .map(|n| n as u32),
-                output_tokens: response["usage"]["completion_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["choices"][0]["finish_reason"]
-            .as_str()
-            .map(str::to_owned),
-        input_tokens: response["usage"]["prompt_tokens"]
-            .as_u64()
-            .map(|n| n as u32),
-        output_tokens: response["usage"]["completion_tokens"]
-            .as_u64()
-            .map(|n| n as u32),
-    })
-}
-
-async fn call_ollama(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ProviderReply, ChatError> {
-    let host = if config.ollama_host.trim().is_empty() {
-        "http://localhost:11434"
-    } else {
-        config.ollama_host.trim_end_matches('/')
-    };
-    let model = config.ollama_model.clone();
-    let native = request.messages.is_some()
-        && config.tool_calling_mode() == crate::config::ToolCallingMode::Native;
-    let mut body = if native {
-        let mut payload = json!({
-            "model": model,
-            "stream": false,
-            "messages": ollama_request_messages(request),
-        });
-        if let Some(tools) = &request.tools {
-            payload["tools"] = json!(
-                tools
-                    .iter()
-                    .map(|tool| json!({
-                        "type": "function",
-                        "function": {
-                            "name": tool.name,
-                            "description": tool.description,
-                            "parameters": tool.parameters,
-                        }
-                    }))
-                    .collect::<Vec<_>>()
-            );
-        }
-        payload
-    } else {
-        let mut user_message = json!({ "role": "user", "content": request.message });
-        if let Some(images) = ollama_images(request) {
-            user_message["images"] = json!(images);
-        }
-        json!({
-            "model": model,
-            "stream": false,
-            "messages": [
-                { "role": "system", "content": request.system_instruction },
-                user_message
-            ]
-        })
-    };
-    // Force the context window Mint plans against (`context_window_tokens`)
-    // instead of leaving Ollama on its tiny ~4K default, which silently
-    // truncates anything longer.
-    let temp = effective_temperature(config, request);
-    body["options"] = json!({
-        "num_ctx": config.ollama_num_ctx,
-        "temperature": temp,
-    });
-    let (thinking_enabled, _) = effective_thinking(config, request, &model);
-    if MintConfig::is_thinking_supported_for_model("ollama", &model) {
-        body["think"] = json!(thinking_enabled);
-    }
-    let response: Value = client
-        .post(format!("{host}/api/chat"))
-        .json(&body)
-        .send()
-        .await?
-        .error_for_status()?
-        .json()
-        .await?;
-    parse_ollama_reply(model, &response)
-}
-
-/// Converts structured history into Ollama's native `/api/chat` message shape.
-/// 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 {
-        match message.role {
-            ChatRole::System => {
-                result.push(json!({ "role": "system", "content": message_text(message) }));
-            }
-            ChatRole::User => {
-                let mut entry = json!({ "role": "user", "content": message_text(message) });
-                let images: Vec<String> = message
-                    .content
-                    .iter()
-                    .filter_map(|block| match block {
-                        ContentBlock::Image { data_uri } => split_data_uri(data_uri, "image/")
-                            .ok()
-                            .map(|(_, data)| data),
-                        _ => None,
-                    })
-                    .collect();
-                if !images.is_empty() {
-                    entry["images"] = json!(images);
-                }
-                result.push(entry);
-            }
-            ChatRole::Assistant => {
-                let text = message_text(message);
-                let tool_calls: Vec<Value> = message
-                    .content
-                    .iter()
-                    .filter_map(|block| match block {
-                        ContentBlock::ToolUse { name, input, .. } => {
-                            Some(json!({ "function": { "name": name, "arguments": input } }))
-                        }
-                        _ => None,
-                    })
-                    .collect();
-                let mut entry = json!({ "role": "assistant", "content": text });
-                if !tool_calls.is_empty() {
-                    entry["tool_calls"] = json!(tool_calls);
-                }
-                result.push(entry);
-            }
-            ChatRole::Tool => {
-                // Ollama's `/api/chat` `tool` role message has no image field —
-                // like OpenAI, an `Image` block riding along with a tool result
-                // (e.g. a browser screenshot) is emitted as a follow-up `user`
-                // message using the same `images` field regular user turns use.
-                let mut pending_images: Vec<String> = Vec::new();
-                for block in &message.content {
-                    match block {
-                        ContentBlock::ToolResult { content, .. } => {
-                            result.push(json!({ "role": "tool", "content": content }));
-                        }
-                        ContentBlock::Image { data_uri } => {
-                            if let Ok((_, data)) = split_data_uri(data_uri, "image/") {
-                                pending_images.push(data);
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-                if !pending_images.is_empty() {
-                    result.push(json!({
-                        "role": "user",
-                        "content": "",
-                        "images": pending_images,
-                    }));
-                }
-            }
-        }
-    }
-    result
-}
-
-/// Parses Ollama's native `/api/chat` response (`{"message": {...}}`), which is
-/// shaped differently from the OpenAI Chat Completions envelope
-/// (`{"choices": [{"message": {...}}]}`) that `parse_openai_style_reply` handles.
-fn parse_ollama_reply(model: String, response: &Value) -> Result<ProviderReply, ChatError> {
-    let message = &response["message"];
-    let raw_text = message["content"].as_str().unwrap_or_default().to_string();
-    let direct_thought = message["thinking"]
-        .as_str()
-        .or_else(|| message["reasoning_content"].as_str())
-        .map(|s| s.trim().to_string())
-        .filter(|s| !s.is_empty());
-
-    let (thought, text) = if direct_thought.is_none() {
-        extract_think_tag(&raw_text)
-    } else {
-        (direct_thought, raw_text)
-    };
-
-    let tool_calls: Vec<ToolCall> = message["tool_calls"]
-        .as_array()
-        .map(|calls| {
-            calls
-                .iter()
-                .enumerate()
-                .filter_map(|(index, call)| {
-                    let name = call["function"]["name"].as_str()?.to_string();
-                    let arguments = &call["function"]["arguments"];
-                    let input = decode_tool_arguments(arguments);
-                    let id = call["id"]
-                        .as_str()
-                        .map(str::to_owned)
-                        .unwrap_or_else(|| format!("call_{index}"));
-                    Some(ToolCall {
-                        id,
-                        name,
-                        input,
-                        thought_signature: None,
-                    })
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    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: None,
-                input_tokens: response["prompt_eval_count"].as_u64().map(|n| n as u32),
-                output_tokens: response["eval_count"].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: None,
-        input_tokens: response["prompt_eval_count"].as_u64().map(|n| n as u32),
-        output_tokens: response["eval_count"].as_u64().map(|n| n as u32),
-    })
-}
-
-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)
-}
-
-/// Builds the Anthropic Messages API payload. When `request.messages` is set,
-/// uses the structured history and (if present) `request.tools` for native
-/// tool-calling; otherwise falls back to the single flat `message` field exactly
-/// as before (legacy JSON-prompt callers are unaffected).
-fn anthropic_chat_payload(
-    config: &MintConfig,
-    model: &str,
-    request: &ChatRequest,
-    stream: bool,
-) -> Result<Value, ChatError> {
-    let system = anthropic_system_blocks(&request.system_instruction);
-    let (thinking_enabled, thinking_effort) = effective_thinking(config, request, model);
-    let is_thinking_supported = MintConfig::is_thinking_supported_for_model("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,
-                    });
-                    // The tool catalog is identical on every step of an agent
-                    // run — marking the last tool definition as a cache
-                    // breakpoint caches the whole system+tools prefix (Anthropic
-                    // caches everything up to and including a marked block), so
-                    // repeated steps hit cache instead of reprocessing it.
-                    if i == last_idx {
-                        value["cache_control"] = json!({ "type": "ephemeral" });
-                    }
-                    value
-                })
-                .collect::<Vec<_>>()
-        );
-    }
-    Ok(payload)
-}
-
-/// Anthropic requires `system` to be an array of text blocks (not a bare
-/// string) to attach a `cache_control` breakpoint to it. The system prompt is
-/// identical on every step of an agent run, so marking it cacheable turns
-/// repeated multi-step turns into a cache hit instead of a full reprocess
-/// each time. Falls back to the old bare-string shape when there's no system
-/// prompt at all, since an empty cacheable block isn't useful.
-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" },
-    }])
-}
-
-fn anthropic_messages(messages: &[ChatMessage]) -> Result<Vec<Value>, ChatError> {
-    let non_system: Vec<&ChatMessage> = messages
-        .iter()
-        .filter(|message| message.role != ChatRole::System)
-        .collect();
-
-    // Anthropic allows up to 4 cache breakpoints. Breakpoints 1 and 2 are system
-    // instruction and the last tool definition. For multi-turn agent runs, marking
-    // the penultimate turn allows the entire preceding conversation history (steps 1..N-1)
-    // to be served from prompt cache with zero reprocessing tokens.
-    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()
-}
-
-/// Builds an Anthropic `content` value for the plain (non-native-messages)
-/// chat path: bare text when there's no image, otherwise a `text` + `image`
-/// parts array. Mirrors `anthropic_content_block`, which handles the same
-/// shape for the native-tool-calling `messages` path. `image_data_uri` may
-/// contain multiple space-separated data URIs, matching Gemini's `gemini_parts`.
-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))
-}
-
-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 },
-            })
-        }
-        // Anthropic's Messages API has no inline audio/video content block; this
-        // is unreachable in practice because `require_supported_attachments`
-        // rejects audio/video for "anthropic" before a request gets this far.
-        ContentBlock::Audio { .. } | ContentBlock::Video { .. } => {
-            return Err(ChatError::UnsupportedAttachments("anthropic".into()));
-        }
-    })
-}
-
-/// Parses an Anthropic Messages API response, collecting all `text` and
-/// `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();
-    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),
-    })
-}
-
-async fn call_huggingface(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ProviderReply, ChatError> {
-    let api_key = provider_key(&config.hf_api_key, "HF_TOKEN");
-    required_key("huggingface", &api_key)?;
-    let model = config.hf_model.clone();
-    // Hugging Face's router is an OpenAI Chat Completions-compatible
-    // endpoint, so it can (and must) take the same native `messages`/`tools`
-    // payload `call_openai` builds — this used to hand-roll a bare
-    // `{system, user: request.message}` request instead, which ignored the
-    // agent loop's full tool-call history and `tools` catalog. `message` is
-    // deliberately left empty (see the step-loop in `orchestration/mod.rs`)
-    // whenever `messages` carries the real conversation, so any mid-task
-    // fallback onto this provider was silently losing all task context —
-    // the model would see an empty user turn and reply with generic
-    // small talk, which the agent loop then treated as the final answer.
-    let response: Value = send_openai_style_request(
-        client
-            .post("https://router.huggingface.co/v1/chat/completions")
-            .bearer_auth(api_key)
-            .json(&openai_chat_payload(config, &model, request, false)?),
-        "huggingface",
-    )
-    .await?;
-    parse_openai_style_reply(model, &response)
-}
-
-async fn stream_gemini_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.api_key, "GEMINI_API_KEY");
-    required_key("gemini", &api_key)?;
-    let model = config.gemini_model.clone();
-    let payload = if request.messages.is_some() {
-        gemini_native_payload(request)?
-    } else {
-        gemini_chat_payload(config, request)?
-    };
-    let response = client
-        .post(format!(
-            "https://generativelanguage.googleapis.com/v1beta/models/{model}:streamGenerateContent?alt=sse"
-        ))
-        .header("x-goog-api-key", api_key)
-        .json(&payload)
-        .send()
-        .await?
-        .error_for_status()?;
-    collect_stream_reply(response, StreamFormat::Gemini, model, on_event).await
-}
-
-async fn stream_openai_reply<F>(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-    on_event: &mut F,
-) -> Result<ProviderReply, ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let local = config.ai_provider == "local_openai";
-    let openrouter = config.ai_provider == "openrouter";
-    let deepseek = config.ai_provider == "deepseek";
-    let api_key = if openrouter {
-        provider_key(&config.openrouter_api_key, "OPENROUTER_API_KEY")
-    } else if deepseek {
-        provider_key(&config.deepseek_api_key, "DEEPSEEK_API_KEY")
-    } else {
-        provider_key(&config.openai_api_key, "OPENAI_API_KEY")
-    };
-    if openrouter {
-        required_key("openrouter", &api_key)?;
-    } else if deepseek {
-        required_key("deepseek", &api_key)?;
-    } else if !local {
-        required_key("openai", &api_key)?;
-    }
-    let base_url = if openrouter {
-        "https://openrouter.ai/api/v1"
-    } else if deepseek {
-        "https://api.deepseek.com"
-    } else if local {
-        config.local_api_base_url.trim_end_matches('/')
-    } else {
-        "https://api.openai.com/v1"
-    };
-    let model = if openrouter {
-        config.openrouter_model.clone()
-    } else if deepseek {
-        config.deepseek_model.clone()
-    } else if local {
-        config.local_model_name.clone()
-    } else {
-        config.openai_model.clone()
-    };
-    let response = client
-        .post(format!("{base_url}/chat/completions"))
-        .bearer_auth(if local { "not-needed" } else { &api_key })
-        .json(&openai_chat_payload(config, &model, request, true)?)
-        .send()
-        .await?;
-    if !response.status().is_success() {
-        let status = response.status();
-        let body = response.text().await.unwrap_or_default();
-        return Err(ChatError::Api(format!("HTTP {status}: {body}")));
-    }
-    collect_stream_reply(response, StreamFormat::OpenAi, model, on_event).await
-}
-
-fn ollama_stream_payload(
-    config: &MintConfig,
-    request: &ChatRequest,
-    model: &str,
-) -> Result<Value, ChatError> {
-    let native = request.messages.is_some()
-        && config.tool_calling_mode() == crate::config::ToolCallingMode::Native;
-    let mut payload = if native {
-        let mut value = json!({
-            "model": model,
-            "stream": true,
-            "messages": ollama_request_messages(request),
-        });
-        if let Some(tools) = &request.tools {
-            value["tools"] = json!(
-                tools
-                    .iter()
-                    .map(|tool| json!({
-                        "type": "function",
-                        "function": {
-                            "name": tool.name,
-                            "description": tool.description,
-                            "parameters": tool.parameters,
-                        }
-                    }))
-                    .collect::<Vec<_>>()
-            );
-        }
-        value
-    } else {
-        let mut user = json!({ "role": "user", "content": request.message });
-        if let Some(images) = ollama_images(request) {
-            user["images"] = json!(images);
-        }
-        json!({
-            "model": model,
-            "stream": true,
-            "messages": [
-                { "role": "system", "content": request.system_instruction },
-                user
-            ]
-        })
-    };
-    payload["options"] = json!({
-        "num_ctx": config.ollama_num_ctx,
-        "temperature": effective_temperature(config, request),
-    });
-    let (thinking_enabled, _) = effective_thinking(config, request, model);
-    if MintConfig::is_thinking_supported_for_model("ollama", model) {
-        payload["think"] = json!(thinking_enabled);
-    }
-    Ok(payload)
-}
-
-async fn stream_ollama_reply<F>(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-    on_event: &mut F,
-) -> Result<ProviderReply, ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let host = if config.ollama_host.trim().is_empty() {
-        "http://localhost:11434"
-    } else {
-        config.ollama_host.trim_end_matches('/')
-    };
-    let model = config.ollama_model.clone();
-    let response = client
-        .post(format!("{host}/api/chat"))
-        .json(&ollama_stream_payload(config, request, &model)?)
-        .send()
-        .await?
-        .error_for_status()?;
-    collect_stream_reply(response, StreamFormat::Ollama, model, on_event).await
-}
-
-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 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(&anthropic_chat_payload(config, &model, request, true)?)
-        .send()
-        .await?
-        .error_for_status()?;
-    collect_stream_reply(response, StreamFormat::Anthropic, model, on_event).await
-}
-
-async fn stream_huggingface_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.hf_api_key, "HF_TOKEN");
-    required_key("huggingface", &api_key)?;
-    let model = config.hf_model.clone();
-    let response = client
-        .post("https://router.huggingface.co/v1/chat/completions")
-        .bearer_auth(api_key)
-        .json(&openai_chat_payload(config, &model, request, true)?)
-        .send()
-        .await?
-        .error_for_status()?;
-    collect_stream_reply(response, StreamFormat::OpenAi, model, on_event).await
-}
-
-async fn stream_custom_provider_reply<F>(
-    client: &Client,
-    config: &MintConfig,
-    request: &ChatRequest,
-    on_event: &mut F,
-) -> Result<ProviderReply, ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let provider = config
-        .resolve_custom_provider(&config.ai_provider)
-        .ok_or_else(|| ChatError::UnsupportedProvider(config.ai_provider.clone()))?;
-    let model = resolve_custom_model(config);
-    let mut builder = client
-        .post(format!(
-            "{}/chat/completions",
-            provider.base_url.trim_end_matches('/')
-        ))
-        .json(&openai_chat_payload(config, &model, request, true)?);
-    if !provider.api_key.is_empty() {
-        builder = builder.bearer_auth(&provider.api_key);
-    }
-    for header in &provider.headers {
-        if !header.name.is_empty() {
-            builder = builder.header(header.name.as_str(), header.value.as_str());
-        }
-    }
-    let response = builder.send().await?.error_for_status()?;
-    collect_stream_reply(response, StreamFormat::OpenAi, model, on_event).await
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum StreamFormat {
-    Gemini,
-    OpenAi,
-    Ollama,
-    Anthropic,
-}
-
-#[derive(Default)]
-struct StreamToolCall {
-    id: String,
-    name: String,
-    arguments: String,
-    input: Option<Value>,
-    thought_signature: Option<String>,
-}
-
-#[derive(Default)]
-struct StreamReplyAccumulator {
-    text: String,
-    thought: String,
-    tag_buffer: String,
-    inside_think_tag: bool,
-    tool_calls: Vec<StreamToolCall>,
-    stop_reason: Option<String>,
-    input_tokens: Option<u32>,
-    output_tokens: Option<u32>,
-    anthropic_blocks: std::collections::HashMap<usize, usize>,
-}
-
-impl StreamReplyAccumulator {
-    fn tool_at(&mut self, index: usize) -> &mut StreamToolCall {
-        while self.tool_calls.len() <= index {
-            self.tool_calls.push(StreamToolCall::default());
-        }
-        &mut self.tool_calls[index]
-    }
-
-    fn emit_text<F>(&mut self, delta: &str, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        if !delta.is_empty() {
-            on_event(ChatStreamEvent::TextDelta {
-                delta: delta.to_owned(),
-            });
-        }
-    }
-
-    /// Route inline `<think>` content without assuming tag boundaries line up
-    /// with provider chunks. A possible partial tag is retained until the next
-    /// chunk; ordinary text is emitted immediately.
-    fn push_text<F>(&mut self, delta: &str, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        if delta.is_empty() {
-            return;
-        }
-        self.text.push_str(delta);
-        self.tag_buffer.push_str(delta);
-        loop {
-            let tag = if self.inside_think_tag {
-                "</think>"
-            } else {
-                "<think>"
-            };
-            if let Some(index) = self.tag_buffer.find(tag) {
-                let before = self.tag_buffer[..index].to_owned();
-                self.tag_buffer.drain(..index + tag.len());
-                if self.inside_think_tag {
-                    self.push_reasoning(&before, on_event);
-                } else {
-                    self.emit_text(&before, on_event);
-                }
-                self.inside_think_tag = !self.inside_think_tag;
-                continue;
-            }
-
-            let retain_from = self
-                .tag_buffer
-                .rfind('<')
-                .and_then(|index| tag.starts_with(&self.tag_buffer[index..]).then_some(index));
-            let emit_end = retain_from.unwrap_or(self.tag_buffer.len());
-            if emit_end > 0 {
-                let ready = self.tag_buffer[..emit_end].to_owned();
-                self.tag_buffer.drain(..emit_end);
-                if self.inside_think_tag {
-                    self.push_reasoning(&ready, on_event);
-                } else {
-                    self.emit_text(&ready, on_event);
-                }
-            }
-            break;
-        }
-    }
-
-    fn flush_tag_buffer<F>(&mut self, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        if self.tag_buffer.is_empty() {
-            return;
-        }
-        let remaining = std::mem::take(&mut self.tag_buffer);
-        if self.inside_think_tag {
-            self.push_reasoning(&remaining, on_event);
-        } else {
-            self.emit_text(&remaining, on_event);
-        }
-    }
-
-    fn push_reasoning<F>(&mut self, delta: &str, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        if !delta.is_empty() {
-            self.thought.push_str(delta);
-            on_event(ChatStreamEvent::ReasoningDelta {
-                delta: delta.to_owned(),
-            });
-        }
-    }
-
-    fn consume<F>(&mut self, format: StreamFormat, value: &Value, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        match format {
-            StreamFormat::OpenAi => self.consume_openai(value, on_event),
-            StreamFormat::Gemini => self.consume_gemini(value, on_event),
-            StreamFormat::Ollama => self.consume_ollama(value, on_event),
-            StreamFormat::Anthropic => self.consume_anthropic(value, on_event),
-        }
-    }
-
-    fn consume_openai<F>(&mut self, value: &Value, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        let choice = &value["choices"][0];
-        let delta = &choice["delta"];
-        if let Some(text) = delta["content"].as_str() {
-            self.push_text(text, on_event);
-        }
-        if let Some(reasoning) = delta["reasoning_content"]
-            .as_str()
-            .or_else(|| delta["reasoning"].as_str())
-            .or_else(|| delta["thinking"].as_str())
-        {
-            self.push_reasoning(reasoning, on_event);
-        }
-        if let Some(details) = delta["reasoning_details"].as_array() {
-            for detail in details {
-                if let Some(reasoning) = detail["text"].as_str() {
-                    self.push_reasoning(reasoning, on_event);
-                }
-            }
-        }
-        if let Some(calls) = delta["tool_calls"].as_array() {
-            for (fallback_index, call) in calls.iter().enumerate() {
-                let index = call["index"]
-                    .as_u64()
-                    .map(|n| n as usize)
-                    .unwrap_or(fallback_index);
-                let name_delta = call["function"]["name"].as_str().map(str::to_owned);
-                let arguments = call["function"]["arguments"].as_str().map(str::to_owned);
-                let current_name = {
-                    let tool = self.tool_at(index);
-                    if let Some(id) = call["id"].as_str() {
-                        tool.id.push_str(id);
-                    }
-                    if let Some(name) = &name_delta {
-                        tool.name.push_str(name);
-                    }
-                    if let Some(arguments) = &arguments {
-                        tool.arguments.push_str(arguments);
-                    }
-                    tool.name.clone()
-                };
-                if name_delta.is_some() || arguments.is_some() {
-                    on_event(ChatStreamEvent::ToolCallDelta {
-                        index,
-                        name: name_delta.map(|_| current_name),
-                        arguments,
-                        input: None,
-                    });
-                }
-            }
-        }
-        if let Some(reason) = choice["finish_reason"].as_str() {
-            self.stop_reason = Some(reason.to_owned());
-        }
-        self.input_tokens = value["usage"]["prompt_tokens"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.input_tokens);
-        self.output_tokens = value["usage"]["completion_tokens"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.output_tokens);
-    }
-
-    fn consume_gemini<F>(&mut self, value: &Value, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        if let Some(parts) = value["candidates"][0]["content"]["parts"].as_array() {
-            for (index, part) in parts.iter().enumerate() {
-                if let Some(text) = part["text"].as_str() {
-                    if part["thought"].as_bool().unwrap_or(false) {
-                        self.push_reasoning(text, on_event);
-                    } else {
-                        self.push_text(text, on_event);
-                    }
-                }
-                if let Some(call) = part.get("functionCall") {
-                    let tool = self.tool_at(index);
-                    tool.id = format!("call_{index}");
-                    tool.name = call["name"].as_str().unwrap_or_default().to_owned();
-                    tool.input = Some(call["args"].clone());
-                    tool.thought_signature = part["thoughtSignature"].as_str().map(str::to_owned);
-                    on_event(ChatStreamEvent::ToolCallDelta {
-                        index,
-                        name: call["name"].as_str().map(str::to_owned),
-                        arguments: None,
-                        input: Some(call["args"].clone()),
-                    });
-                }
-            }
-        }
-        self.stop_reason = value["candidates"][0]["finishReason"]
-            .as_str()
-            .map(str::to_owned)
-            .or_else(|| self.stop_reason.take());
-        self.input_tokens = value["usageMetadata"]["promptTokenCount"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.input_tokens);
-        self.output_tokens = value["usageMetadata"]["candidatesTokenCount"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.output_tokens);
-    }
-
-    fn consume_ollama<F>(&mut self, value: &Value, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        let message = &value["message"];
-        if let Some(text) = message["content"].as_str() {
-            self.push_text(text, on_event);
-        }
-        if let Some(reasoning) = message["thinking"]
-            .as_str()
-            .or_else(|| message["reasoning_content"].as_str())
-        {
-            self.push_reasoning(reasoning, on_event);
-        }
-        if let Some(calls) = message["tool_calls"].as_array() {
-            for (index, call) in calls.iter().enumerate() {
-                let tool = self.tool_at(index);
-                tool.id = call["id"]
-                    .as_str()
-                    .map(str::to_owned)
-                    .unwrap_or_else(|| format!("call_{index}"));
-                tool.name = call["function"]["name"]
-                    .as_str()
-                    .unwrap_or_default()
-                    .to_owned();
-                tool.input = Some(call["function"]["arguments"].clone());
-                on_event(ChatStreamEvent::ToolCallDelta {
-                    index,
-                    name: call["function"]["name"].as_str().map(str::to_owned),
-                    arguments: None,
-                    input: Some(call["function"]["arguments"].clone()),
-                });
-            }
-        }
-        self.input_tokens = value["prompt_eval_count"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.input_tokens);
-        self.output_tokens = value["eval_count"]
-            .as_u64()
-            .map(|n| n as u32)
-            .or(self.output_tokens);
-        if value["done"].as_bool().unwrap_or(false) {
-            self.stop_reason = value["done_reason"]
-                .as_str()
-                .map(str::to_owned)
-                .or_else(|| Some("stop".to_owned()));
-        }
-    }
-
-    fn consume_anthropic<F>(&mut self, value: &Value, on_event: &mut F)
-    where
-        F: FnMut(ChatStreamEvent),
-    {
-        match value["type"].as_str() {
-            Some("message_start") => {
-                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;
-                let block = &value["content_block"];
-                if block["type"].as_str() == Some("tool_use") {
-                    let tool_index = self.tool_calls.len();
-                    let tool = self.tool_at(tool_index);
-                    tool.id = block["id"].as_str().unwrap_or_default().to_owned();
-                    tool.name = block["name"].as_str().unwrap_or_default().to_owned();
-                    self.anthropic_blocks.insert(block_index, tool_index);
-                    on_event(ChatStreamEvent::ToolCallDelta {
-                        index: tool_index,
-                        name: block["name"].as_str().map(str::to_owned),
-                        arguments: None,
-                        input: None,
-                    });
-                }
-            }
-            Some("content_block_delta") => {
-                let delta = &value["delta"];
-                match delta["type"].as_str() {
-                    Some("text_delta") => {
-                        if let Some(text) = delta["text"].as_str() {
-                            self.push_text(text, on_event);
-                        }
-                    }
-                    Some("thinking_delta") => {
-                        if let Some(thinking) = delta["thinking"].as_str() {
-                            self.push_reasoning(thinking, on_event);
-                        }
-                    }
-                    Some("input_json_delta") => {
-                        let block_index = value["index"].as_u64().unwrap_or(0) as usize;
-                        if let Some(tool_index) = self.anthropic_blocks.get(&block_index).copied()
-                            && let Some(json) = delta["partial_json"].as_str()
-                        {
-                            self.tool_at(tool_index).arguments.push_str(json);
-                            on_event(ChatStreamEvent::ToolCallDelta {
-                                index: tool_index,
-                                name: None,
-                                arguments: Some(json.to_owned()),
-                                input: None,
-                            });
-                        }
-                    }
-                    _ => {}
-                }
-            }
-            Some("message_delta") => {
-                self.stop_reason = value["delta"]["stop_reason"]
-                    .as_str()
-                    .map(str::to_owned)
-                    .or_else(|| self.stop_reason.take());
-                self.output_tokens = value["usage"]["output_tokens"]
-                    .as_u64()
-                    .map(|n| n as u32)
-                    .or(self.output_tokens);
-            }
-            _ => {}
-        }
-    }
-
-    fn finish(self, model: String) -> Result<ProviderReply, ChatError> {
-        let (tag_thought, clean_text) = extract_think_tag(&self.text);
-        let thought = if self.thought.trim().is_empty() {
-            tag_thought
-        } else {
-            Some(self.thought.trim().to_owned())
-        };
-        let calls: Vec<ToolCall> = self
-            .tool_calls
-            .into_iter()
-            .filter(|tool| !tool.name.is_empty())
-            .map(|tool| {
-                let input = tool
-                    .input
-                    .unwrap_or_else(|| decode_tool_arguments(&Value::String(tool.arguments)));
-                ToolCall {
-                    id: tool.id,
-                    name: tool.name,
-                    input,
-                    thought_signature: tool.thought_signature,
-                }
-            })
-            .collect();
-        if clean_text.is_empty() && calls.is_empty() && thought.is_none() {
-            return Err(ChatError::MissingResponseText);
-        }
-        Ok(ProviderReply {
-            model,
-            text: if clean_text.is_empty() && calls.is_empty() {
-                thought.clone().unwrap_or_default()
-            } else {
-                clean_text
-            },
-            thought,
-            tool_calls: (!calls.is_empty()).then_some(calls),
-            stop_reason: self.stop_reason,
-            input_tokens: self.input_tokens,
-            output_tokens: self.output_tokens,
-        })
-    }
-}
-
-async fn collect_stream_reply<F>(
-    response: reqwest::Response,
-    format: StreamFormat,
-    model: String,
-    on_event: &mut F,
-) -> Result<ProviderReply, ChatError>
-where
-    F: FnMut(ChatStreamEvent),
-{
-    let mut bytes = response.bytes_stream();
-    let mut buffer = String::new();
-    let mut accumulator = StreamReplyAccumulator::default();
-    while let Some(chunk) = bytes.next().await {
-        buffer.push_str(&String::from_utf8_lossy(&chunk?));
-        while let Some(index) = buffer.find('\n') {
-            let line = buffer[..index].trim().to_owned();
-            buffer.drain(..=index);
-            if let Some(value) = parse_stream_value(format, &line) {
-                accumulator.consume(format, &value, on_event);
-            }
-        }
-    }
-    if let Some(value) = parse_stream_value(format, buffer.trim()) {
-        accumulator.consume(format, &value, on_event);
-    }
-    accumulator.flush_tag_buffer(on_event);
-    accumulator.finish(model)
-}
-
-fn parse_stream_value(format: StreamFormat, line: &str) -> Option<Value> {
-    let payload = match format {
-        StreamFormat::Ollama => line,
-        _ => line.strip_prefix("data:")?.trim(),
-    };
-    if payload.is_empty() || payload == "[DONE]" {
-        return None;
-    }
-    serde_json::from_str(payload).ok()
-}
-
-fn required_key(provider: &str, key: &str) -> Result<(), ChatError> {
-    if key.trim().is_empty() {
-        Err(ChatError::MissingApiKey(provider.into()))
-    } else {
-        Ok(())
-    }
-}
-
-/// Resolve which model to use for the current custom provider.
-///
-/// Checks `config.extra["customModelSelections"]` first (set by the UI when the
-/// user picks a specific model from the multi-model dropdown), then falls back to
-/// the first model defined in the `CustomProvider`.
-fn resolve_custom_model(config: &crate::MintConfig) -> String {
-    let provider_id = config
-        .ai_provider
-        .strip_prefix("custom:")
-        .unwrap_or(&config.ai_provider);
-
-    // Check if a per-provider model selection was persisted in extra config.
-    if let Some(selections) = config
-        .extra
-        .get("customModelSelections")
-        .and_then(|v| v.as_object())
-        && let Some(model) = selections.get(provider_id).and_then(|v| v.as_str())
-        && !model.is_empty()
-    {
-        return model.to_owned();
-    }
-
-    // Fall back to the first model in the provider definition.
-    config
-        .resolve_custom_provider(&config.ai_provider)
-        .and_then(|cp| cp.models.first())
-        .map(|m| m.model_id.clone())
-        .unwrap_or_default()
-}
-
-async fn call_custom_provider(
-    client: &Client,
-    config: &crate::MintConfig,
-    request: &ChatRequest,
-) -> Result<ProviderReply, ChatError> {
-    let provider = config
-        .resolve_custom_provider(&config.ai_provider)
-        .ok_or_else(|| ChatError::UnsupportedProvider(config.ai_provider.clone()))?;
-
-    let base_url = provider.base_url.trim_end_matches('/');
-    let model = resolve_custom_model(config);
-    let payload = openai_chat_payload(config, &model, request, false)?;
-
-    let mut builder = client
-        .post(format!("{base_url}/chat/completions"))
-        .json(&payload);
-
-    if !provider.api_key.is_empty() {
-        builder = builder.bearer_auth(&provider.api_key);
-    }
-    for h in &provider.headers {
-        if !h.name.is_empty() {
-            builder = builder.header(h.name.as_str(), h.value.as_str());
-        }
-    }
-
-    let response: serde_json::Value = builder.send().await?.error_for_status()?.json().await?;
-
-    parse_openai_style_reply(model, &response)
-}
-
-fn provider_key(configured: &str, environment_variable: &str) -> String {
-    if configured.trim().is_empty() {
-        std::env::var(environment_variable).unwrap_or_default()
-    } else {
-        configured.into()
-    }
-}
-
-fn require_supported_attachments(provider: &str, request: &ChatRequest) -> Result<(), ChatError> {
-    let has_image = request
-        .image_data_uri
-        .as_ref()
-        .is_some_and(|s| !s.trim().is_empty());
-    let has_audio = request
-        .audio_data_uri
-        .as_ref()
-        .is_some_and(|s| !s.trim().is_empty());
-    let has_video = request
-        .video_data_uri
-        .as_ref()
-        .is_some_and(|s| !s.trim().is_empty());
-
-    match provider {
-        "gemini" => Ok(()),
-        "ollama" if has_audio || has_video => {
-            Err(ChatError::UnsupportedAttachments(provider.into()))
-        }
-        "ollama" => Ok(()),
-        // The real OpenAI API supports audio input natively (`input_audio` content
-        // parts, see `openai_audio_part`) — video still isn't implemented for it.
-        "openai" if has_video => Err(ChatError::UnsupportedAttachments(provider.into())),
-        "openai" => Ok(()),
-        // These all build their payload via `openai_chat_payload`/`anthropic_chat_payload`,
-        // which support image attachments (see `openai_message_content`/
-        // `anthropic_message_content`). Unlike literal `"openai"` above, these are
-        // separate services/proxies that aren't confirmed to speak the same
-        // `input_audio` schema, so audio/video stay unsupported for them.
-        "local_openai" | "openrouter" | "deepseek" | "huggingface" | "anthropic"
-            if has_audio || has_video =>
-        {
-            Err(ChatError::UnsupportedAttachments(provider.into()))
-        }
-        "local_openai" | "openrouter" | "deepseek" | "huggingface" | "anthropic" => Ok(()),
-        // Custom providers route through `call_custom_provider`, which also uses
-        // `openai_chat_payload`, so images are supported the same way; audio/video
-        // are not implemented for them yet.
-        p if p.starts_with("custom:") && (has_audio || has_video) => {
-            Err(ChatError::UnsupportedAttachments(provider.into()))
-        }
-        p if p.starts_with("custom:") => Ok(()),
-        _ if has_image || has_audio || has_video => {
-            Err(ChatError::UnsupportedAttachments(provider.into()))
-        }
-        _ => Ok(()),
-    }
-}
-
-/// Extract base64 image data from the request for Ollama's `images` field.
-/// Ollama expects a plain array of base64 strings (without the data URI prefix).
-fn ollama_images(request: &ChatRequest) -> Option<Vec<String>> {
-    let image_data = request.image_data_uri.as_ref()?;
-    let images: Vec<String> = image_data
-        .split_whitespace()
-        .filter_map(|img| {
-            img.strip_prefix("data:")
-                .and_then(|payload| payload.split_once(";base64,"))
-                .filter(|(mime, data)| mime.starts_with("image/") && !data.is_empty())
-                .map(|(_, data)| data.to_owned())
-        })
-        .collect();
-    if images.is_empty() {
-        None
-    } else {
-        Some(images)
-    }
-}
-
-fn wants_agent_json(request: &ChatRequest) -> bool {
-    let instruction = request.system_instruction.as_str();
-    instruction.contains("Return only JSON")
-        || (instruction.contains("Return exactly one JSON object per response")
-            && instruction.contains("Input formats:")
-            && instruction.contains("- finish:"))
-}
-
-fn gemini_chat_payload(config: &MintConfig, request: &ChatRequest) -> Result<Value, ChatError> {
-    let temp = effective_temperature(config, request);
-    let mut payload = json!({
-        "systemInstruction": { "parts": [{ "text": request.system_instruction }] },
-        "contents": [{ "role": "user", "parts": gemini_parts(request)? }]
-    });
-    let mut gen_cfg = if wants_agent_json(request) {
-        let mut cfg = gemini_agent_generation_config(config);
-        cfg["temperature"] = json!(temp);
-        cfg
-    } else {
-        json!({ "temperature": temp })
-    };
-    gemini_apply_thinking_config(&mut gen_cfg, config, request, &config.gemini_model);
-    payload["generationConfig"] = gen_cfg;
-    Ok(payload)
-}
-
-fn gemini_agent_generation_config(config: &MintConfig) -> Value {
-    let mut allowed_actions = vec![
-        "list_files",
-        "read_file",
-        "search_code",
-        "symbols",
-        "find_definition",
-        "find_references",
-        "semantic_index",
-        "semantic_search",
-        "knowledge_search",
-        "web_search",
-        "weather",
-        "stock",
-        "calculation",
-        "browser_open",
-        "memory_recall",
-        "git_status",
-        "git_diff",
-        "git_log",
-        "git_branch",
-        "create_plan",
-        "update_plan",
-        "request_user_approval",
-        "ask_user",
-        "detect_project",
-        "list_tests",
-        "read_diagnostics",
-        "view_image",
-        "note_write",
-        "run_plugin",
-        "mcp_tool",
-        "run_shell",
-        "verify",
-        "run_tests",
-        "run_typecheck",
-        "run_linter",
-        "apply_patch",
-        "write_file",
-    ];
-    allowed_actions.retain(|action| !config.disabled_tools.contains(&action.to_string()));
-    allowed_actions.push("finish");
-
-    json!({
-        "responseMimeType": "application/json",
-        "responseSchema": {
-            "type": "OBJECT",
-            "properties": {
-                "thought": { "type": "STRING" },
-                "action": {
-                    "type": "STRING",
-                    "enum": allowed_actions
-                },
-                "input": {
-                    "type": "OBJECT",
-                    "properties": {
-                        "path": { "type": "STRING", "description": "The target file or directory path (required for list_files, read_file, write_file, apply_patch, symbols, semantic_index, semantic_search)" },
-                        "query": { "type": "STRING", "description": "The search query string (required for search_code, semantic_search, knowledge_search, web_search, stock, memory_recall)" },
-                        "city": { "type": "STRING", "description": "The target city or location name (required for weather)" },
-                        "expression": { "type": "STRING", "description": "The math expression or percentage calculation (required for calculation)" },
-                        "url": { "type": "STRING", "description": "The target website URL to open (required for browser_open)" },
-                        "command": { "type": "STRING", "description": "The local read-only or test shell command to run (required for run_shell)" },
-                        "commands": {
-                            "type": "ARRAY",
-                            "items": { "type": "STRING" },
-                            "description": "List of verification commands (required for verify)"
-                        },
-                        "steps": {
-                            "type": "ARRAY",
-                            "items": { "type": "STRING" },
-                            "description": "Plan steps (for create_plan/update_plan)"
-                        },
-                        "fileContent": { "type": "STRING", "description": "The complete new content of a new file (required for write_file, note_write)" },
-                        "summary": { "type": "STRING", "description": "The final detailed answer, explanation, or response to the user's query (required for finish)" },
-                        "verification": { "type": "STRING", "description": "The description of checks to run before finishing" },
-                        "title": { "type": "STRING", "description": "Short approval or plan title" },
-                        "status": { "type": "STRING", "description": "Plan item status or project status" },
-                        "startLine": { "type": "INTEGER", "description": "First line to read (1-indexed, for read_file)" },
-                        "endLine": { "type": "INTEGER", "description": "Last line to read. Defaults to startLine + 239 (for read_file)" },
-                        "limit": { "type": "INTEGER", "description": "Max number of items/lines/files to return" },
-                        "server": { "type": "STRING", "description": "MCP server name (for mcp_tool)" },
-                        "tool": { "type": "STRING", "description": "MCP tool name (for mcp_tool)" },
-                        "notePath": { "type": "STRING", "description": "The file path for note writing (for note_write)" },
-                        "name": { "type": "STRING", "description": "Plugin name (for run_plugin)" },
-                        "instruction": { "type": "STRING", "description": "Instruction to run the plugin (for run_plugin)" },
-                        "patch": {
-                            "type": "OBJECT",
-                            "properties": {
-                                "path": { "type": "STRING", "description": "The target file path (required for apply_patch)" },
-                                "hunks": {
-                                    "type": "ARRAY",
-                                    "items": {
-                                        "type": "OBJECT",
-                                        "properties": {
-                                            "oldText": { "type": "STRING", "description": "The exact block of code to replace" },
-                                            "newText": { "type": "STRING", "description": "The replacement block of code" }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        "arguments": { "type": "OBJECT", "description": "MCP tool arguments (for mcp_tool)" }
-                    },
-                    "required": ["path", "query", "command", "fileContent", "summary"]
-                }
-            },
-            "required": ["thought", "action", "input"]
-        }
-    })
-}
-
-/// Resolves the effective sampling temperature for this request, prioritizing
-/// `request.temperature` if present, otherwise falling back to `config.resolved_temperature()`.
-pub(crate) fn effective_temperature(config: &MintConfig, request: &ChatRequest) -> f64 {
-    request
-        .temperature
-        .unwrap_or_else(|| config.resolved_temperature())
-}
-
-/// Resolves (enabled, effort) for this request and model, prioritizing request overrides.
-pub(crate) fn effective_thinking(
-    config: &MintConfig,
-    request: &ChatRequest,
-    model: &str,
-) -> (bool, String) {
-    let enabled = request
-        .thinking_enabled
-        .unwrap_or_else(|| config.resolved_thinking_enabled_for_model(&config.ai_provider, model));
-    let effort = request
-        .thinking_effort
-        .as_deref()
-        .map(str::to_ascii_lowercase)
-        .unwrap_or_else(|| config.resolved_thinking_effort_for_model(model).to_string());
-    (enabled, effort)
-}
-
-pub(crate) fn gemini_apply_thinking_config(
-    gen_cfg: &mut Value,
-    config: &MintConfig,
-    request: &ChatRequest,
-    model: &str,
-) {
-    if !MintConfig::is_thinking_supported_for_model("gemini", model) {
-        return;
-    }
-    let (enabled, effort) = effective_thinking(config, request, model);
-    if !enabled {
-        gen_cfg["thinkingConfig"] = json!({ "thinkingBudget": 0 });
-    } else {
-        let budget = match effort.as_str() {
-            "low" => 1024,
-            "medium" => 4096,
-            "high" => 16384,
-            "extra_high" => 32768,
-            _ => 4096,
-        };
-        gen_cfg["thinkingConfig"] = json!({ "thinkingBudget": budget });
-    }
-}
-
-fn openai_chat_payload(
-    config: &MintConfig,
-    model: &str,
-    request: &ChatRequest,
-    stream: bool,
-) -> Result<Value, ChatError> {
-    let messages = if let Some(messages) = &request.messages {
-        let mut built = Vec::new();
-        if !request.system_instruction.is_empty()
-            && !messages.iter().any(|m| m.role == ChatRole::System)
-        {
-            built.push(json!({ "role": "system", "content": request.system_instruction }));
-        }
-        built.extend(openai_native_messages(messages)?);
-        built
-    } else {
-        vec![
-            json!({ "role": "system", "content": request.system_instruction }),
-            json!({
-                "role": "user",
-                "content": openai_message_content(
-                    &request.message,
-                    request.image_data_uri.as_deref(),
-                    request.audio_data_uri.as_deref(),
-                )?,
-            }),
-        ]
-    };
-    // Left unset, several OpenAI-compatible providers (DeepSeek in
-    // particular) default to a much lower output cap than the model can
-    // actually produce, which silently truncates long structured answers
-    // (a code block followed by a couple of markdown tables is enough to
-    // hit it) — matches the explicit cap already used for Anthropic in
-    // `anthropic_chat_payload`/`stream_anthropic`.
-    // For Groq endpoints, free tiers enforce a tight 6,000–8,000 TPM limit
-    // where a static 8192 max_tokens triggers immediate HTTP 413 / rate limit errors.
-    let max_tokens = {
-        let is_groq = config
-            .resolve_custom_provider(&config.ai_provider)
-            .map(|cp| cp.base_url.contains("groq.com"))
-            .unwrap_or(false);
-        if is_groq {
-            if request.tools.is_some() { 2048 } else { 4096 }
-        } else {
-            8192
-        }
-    };
-    let mut payload = json!({
-        "model": model,
-        "stream": stream,
-        "messages": messages,
-        "max_tokens": max_tokens,
-    });
-    if stream {
-        payload["stream_options"] = json!({ "include_usage": true });
-    }
-    // OpenAI reasoning models (o1, o3, etc.) reject explicit temperature parameter.
-    let is_reasoning_model = model.starts_with("o1") || model.starts_with("o3");
-    let (thinking_enabled, thinking_effort) = effective_thinking(config, request, model);
-    if is_reasoning_model {
-        if thinking_enabled {
-            let effort_str = match thinking_effort.as_str() {
-                "low" => "low",
-                "medium" => "medium",
-                "high" | "extra_high" => "high",
-                _ => "medium",
-            };
-            payload["reasoning_effort"] = json!(effort_str);
-        } else {
-            payload["reasoning_effort"] = json!("low");
-        }
-    } else {
-        payload["temperature"] = json!(effective_temperature(config, request));
-    }
-    if wants_agent_json(request) {
-        payload["response_format"] = json!({ "type": "json_object" });
-    }
-    if let Some(tools) = &request.tools {
-        payload["tools"] = json!(
-            tools
-                .iter()
-                .map(|tool| json!({
-                    "type": "function",
-                    "function": {
-                        "name": tool.name,
-                        "description": tool.description,
-                        "parameters": tool.parameters,
-                    }
-                }))
-                .collect::<Vec<_>>()
-        );
-    }
-    Ok(payload)
-}
-
-/// Converts structured history into OpenAI Chat Completions message objects,
-/// including assistant `tool_calls` and `role: "tool"` tool-result messages.
-fn openai_native_messages(messages: &[ChatMessage]) -> Result<Vec<Value>, ChatError> {
-    let mut result = Vec::new();
-    for message in messages {
-        match message.role {
-            ChatRole::System => {
-                result.push(json!({ "role": "system", "content": message_text(message) }));
-            }
-            ChatRole::User => {
-                result.push(json!({ "role": "user", "content": openai_user_content(message)? }));
-            }
-            ChatRole::Assistant => {
-                let text = message_text(message);
-                let tool_calls: Vec<Value> = message
-                    .content
-                    .iter()
-                    .filter_map(|block| match block {
-                        ContentBlock::ToolUse {
-                            id, name, input, ..
-                        } => Some(json!({
-                            "id": id,
-                            "type": "function",
-                            "function": { "name": name, "arguments": input.to_string() }
-                        })),
-                        _ => None,
-                    })
-                    .collect();
-                let mut entry = json!({ "role": "assistant" });
-                entry["content"] = if text.is_empty() {
-                    Value::Null
-                } else {
-                    json!(text)
-                };
-                if !tool_calls.is_empty() {
-                    entry["tool_calls"] = json!(tool_calls);
-                }
-                result.push(entry);
-            }
-            ChatRole::Tool => {
-                // OpenAI's Chat Completions `tool` role only accepts a plain
-                // string `content` — an image can't be attached to it directly.
-                // Any `Image` block riding along with a tool result (e.g. a
-                // browser screenshot) is instead emitted as a follow-up `user`
-                // message, the same pattern OpenAI's own vision examples use to
-                // let a tool result be "shown" to the model.
-                let mut pending_images: Vec<&str> = Vec::new();
-                for block in &message.content {
-                    match block {
-                        ContentBlock::ToolResult {
-                            tool_use_id,
-                            content,
-                            ..
-                        } => {
-                            result.push(json!({
-                                "role": "tool",
-                                "tool_call_id": tool_use_id,
-                                "content": content,
-                            }));
-                        }
-                        ContentBlock::Image { data_uri } => pending_images.push(data_uri),
-                        _ => {}
-                    }
-                }
-                if !pending_images.is_empty() {
-                    let parts: Vec<Value> = pending_images
-                        .iter()
-                        .map(|data_uri| {
-                            json!({ "type": "image_url", "image_url": { "url": data_uri } })
-                        })
-                        .collect();
-                    result.push(json!({ "role": "user", "content": parts }));
-                }
-            }
-        }
-    }
-    Ok(result)
-}
-
-/// Concatenates all `Text` blocks in a message (tool-use/result/image blocks
-/// contribute nothing).
-fn message_text(message: &ChatMessage) -> String {
-    message
-        .content
-        .iter()
-        .filter_map(|block| match block {
-            ContentBlock::Text { text } => Some(text.as_str()),
-            _ => None,
-        })
-        .collect::<Vec<_>>()
-        .join("")
-}
-
-/// Builds an OpenAI `content` value for the plain (non-native-messages) chat
-/// path: bare text when there's no image/audio, otherwise a `text` +
-/// `image_url`/`input_audio` parts array. Mirrors `openai_user_content`,
-/// which handles the same shape for the native-tool-calling `messages` path.
-/// `image_data_uri`/`audio_data_uri` may each contain multiple
-/// space-separated data URIs, matching Gemini's `gemini_parts`.
-fn openai_message_content(
-    text: &str,
-    image_data_uri: Option<&str>,
-    audio_data_uri: Option<&str>,
-) -> Result<Value, ChatError> {
-    if image_data_uri.is_none() && audio_data_uri.is_none() {
-        return Ok(json!(text));
-    }
-    let mut parts = vec![json!({ "type": "text", "text": text })];
-    for img in image_data_uri.into_iter().flat_map(str::split_whitespace) {
-        parts.push(json!({ "type": "image_url", "image_url": { "url": img } }));
-    }
-    for aud in audio_data_uri.into_iter().flat_map(str::split_whitespace) {
-        parts.push(openai_audio_part(aud)?);
-    }
-    Ok(json!(parts))
-}
-
-fn openai_user_content(message: &ChatMessage) -> Result<Value, ChatError> {
-    if let [ContentBlock::Text { text }] = message.content.as_slice() {
-        return Ok(json!(text));
-    }
-    let parts: Vec<Value> = message
-        .content
-        .iter()
-        .map(|block| -> Result<Value, ChatError> {
-            Ok(match block {
-                ContentBlock::Text { text } => json!({ "type": "text", "text": text }),
-                ContentBlock::Image { data_uri } => {
-                    json!({ "type": "image_url", "image_url": { "url": data_uri } })
-                }
-                ContentBlock::Audio { data_uri } => openai_audio_part(data_uri)?,
-                // OpenAI Chat Completions has no inline video content part in this
-                // format; unreachable in practice because
-                // `require_supported_attachments` rejects video for these
-                // providers before a request gets this far. `Value::Null` here
-                // is a "skip this block" sentinel, filtered out below.
-                ContentBlock::ToolUse { .. }
-                | ContentBlock::ToolResult { .. }
-                | ContentBlock::Video { .. } => Value::Null,
-            })
-        })
-        .filter_map(|part| match part {
-            Ok(Value::Null) => None,
-            other => Some(other),
-        })
-        .collect::<Result<_, _>>()?;
-    Ok(json!(parts))
-}
-
-/// Builds an OpenAI `input_audio` content part. Unlike `image_url`, which
-/// takes the whole `data:` URI as-is, OpenAI's audio input wants the base64
-/// payload and format split apart, so the URI has to be parsed here instead
-/// of just passed through.
-fn openai_audio_part(data_uri: &str) -> Result<Value, ChatError> {
-    let (mime_type, data) = split_data_uri(data_uri, "audio/")?;
-    Ok(json!({
-        "type": "input_audio",
-        "input_audio": { "data": data, "format": openai_audio_format(&mime_type) }
-    }))
-}
-
-/// OpenAI's `input_audio.format` only accepts `"wav"` or `"mp3"` — anything
-/// else (webm, ogg, m4a, …) is mapped to `"mp3"` as the closest-effort
-/// fallback rather than rejected outright; the API itself is the final judge
-/// of whether the actual bytes decode.
-fn openai_audio_format(mime_type: &str) -> &'static str {
-    if mime_type.contains("wav") {
-        "wav"
-    } else {
-        "mp3"
-    }
-}
-
-/// Splits a `data:<mime>;base64,<data>` URI into `(mime_type, base64_data)`,
-/// validating the mime type starts with `expected_prefix` (e.g. `"image/"`).
-fn split_data_uri(data_uri: &str, expected_prefix: &str) -> Result<(String, String), ChatError> {
-    data_uri
-        .strip_prefix("data:")
-        .and_then(|payload| payload.split_once(";base64,"))
-        .filter(|(mime, data)| mime.starts_with(expected_prefix) && !data.is_empty())
-        .map(|(mime, data)| (mime.to_owned(), data.to_owned()))
-        .ok_or(ChatError::InvalidAttachment)
-}
-
-fn gemini_parts(request: &ChatRequest) -> Result<Vec<Value>, ChatError> {
-    let mut parts = vec![json!({ "text": request.message })];
-    if let Some(ref image_data) = request.image_data_uri {
-        for img in image_data.split_whitespace() {
-            let payload = img
-                .strip_prefix("data:")
-                .and_then(|payload| payload.split_once(";base64,"))
-                .filter(|(mime_type, data)| mime_type.starts_with("image/") && !data.is_empty())
-                .ok_or(ChatError::InvalidAttachment)?;
-            parts.push(json!({
-                "inlineData": {
-                    "mimeType": payload.0,
-                    "data": payload.1
-                }
-            }));
-        }
-    }
-    if let Some(ref audio_data) = request.audio_data_uri {
-        for aud in audio_data.split_whitespace() {
-            let payload = aud
-                .strip_prefix("data:")
-                .and_then(|payload| payload.split_once(";base64,"))
-                .filter(|(mime_type, data)| mime_type.starts_with("audio/") && !data.is_empty())
-                .ok_or(ChatError::InvalidAttachment)?;
-            parts.push(json!({
-                "inlineData": {
-                    "mimeType": payload.0,
-                    "data": payload.1
-                }
-            }));
-        }
-    }
-    if let Some(ref video_data) = request.video_data_uri {
-        for vid in video_data.split_whitespace() {
-            let payload = vid
-                .strip_prefix("data:")
-                .and_then(|payload| payload.split_once(";base64,"))
-                .filter(|(mime_type, data)| mime_type.starts_with("video/") && !data.is_empty())
-                .ok_or(ChatError::InvalidAttachment)?;
-            parts.push(json!({
-                "inlineData": {
-                    "mimeType": payload.0,
-                    "data": payload.1
-                }
-            }));
-        }
-    }
-    Ok(parts)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn rejects_missing_api_key() {
-        let error = required_key("gemini", "").unwrap_err();
-        assert!(matches!(error, ChatError::MissingApiKey(provider) if provider == "gemini"));
-    }
-
-    #[test]
-    fn rejects_video_attachments_for_non_gemini_providers() {
-        let request = ChatRequest {
-            message: "describe this video".into(),
-            system_instruction: String::new(),
-            chat_id: None,
-            image_data_uri: None,
-            audio_data_uri: None,
-            video_data_uri: Some("data:video/mp4;base64,AAAA".into()),
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-            plan_mode: false,
-            pinned_mcp_server: None,
-            messages: None,
-            tools: None,
-            temperature: None,
-            ..Default::default()
-        };
-
-        let error = require_supported_attachments("openai", &request).unwrap_err();
-        assert!(
-            matches!(error, ChatError::UnsupportedAttachments(provider) if provider == "openai")
-        );
-    }
-
-    #[test]
-    fn parses_stream_provider_formats() {
-        let openai = parse_stream_value(
-            StreamFormat::OpenAi,
-            r#"data: {"choices":[{"delta":{"content":"hello"}}]}"#,
-        )
-        .unwrap();
-        assert_eq!(openai["choices"][0]["delta"]["content"], "hello");
-        let ollama =
-            parse_stream_value(StreamFormat::Ollama, r#"{"message":{"content":"hi"}}"#).unwrap();
-        assert_eq!(ollama["message"]["content"], "hi");
-        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();
-        let mut events = Vec::new();
-        accumulator.consume_openai(
-            &json!({
-                "choices": [{"delta": {"reasoning_content": "inspect "}}]
-            }),
-            &mut |event| events.push(event),
-        );
-        accumulator.consume_openai(&json!({
-            "choices": [{"delta": {"reasoning_content": "files", "tool_calls": [{
-                "index": 0, "id": "call_1", "function": {"name": "read_file", "arguments": "{\"path\":"}
-            }]}}]
-        }), &mut |event| events.push(event));
-        accumulator.consume_openai(
-            &json!({
-                "choices": [{"delta": {"tool_calls": [{
-                    "index": 0, "function": {"arguments": "\"README.md\"}"}
-                }]}, "finish_reason": "tool_calls"}],
-                "usage": {"prompt_tokens": 10, "completion_tokens": 5}
-            }),
-            &mut |event| events.push(event),
-        );
-        accumulator.flush_tag_buffer(&mut |event| events.push(event));
-        let reply = accumulator.finish("test".into()).unwrap();
-        assert_eq!(reply.thought.as_deref(), Some("inspect files"));
-        assert_eq!(reply.stop_reason.as_deref(), Some("tool_calls"));
-        assert_eq!(reply.input_tokens, Some(10));
-        assert_eq!(reply.tool_calls.unwrap()[0].input["path"], "README.md");
-        assert_eq!(
-            events
-                .iter()
-                .filter(|event| matches!(event, ChatStreamEvent::ReasoningDelta { .. }))
-                .count(),
-            2
-        );
-        assert_eq!(
-            events
-                .iter()
-                .filter(|event| matches!(event, ChatStreamEvent::ToolCallDelta { .. }))
-                .count(),
-            2
-        );
-    }
-
-    #[test]
-    fn streams_think_tags_split_across_chunks() {
-        let mut accumulator = StreamReplyAccumulator::default();
-        let mut events = Vec::new();
-        for chunk in ["ก่อน<thi", "nk>คิด", "อยู่</th", "ink>หลัง"] {
-            accumulator.push_text(chunk, &mut |event| events.push(event));
-        }
-        accumulator.flush_tag_buffer(&mut |event| events.push(event));
-        let reply = accumulator.finish("test".into()).unwrap();
-        assert_eq!(reply.text, "ก่อนหลัง");
-        assert_eq!(reply.thought.as_deref(), Some("คิดอยู่"));
-        let streamed_reasoning: String = events
-            .iter()
-            .filter_map(|event| match event {
-                ChatStreamEvent::ReasoningDelta { delta } => Some(delta.as_str()),
-                _ => None,
-            })
-            .collect();
-        assert_eq!(streamed_reasoning, "คิดอยู่");
-    }
-
-    #[test]
-    fn builds_gemini_multimodal_parts() {
-        let parts = gemini_parts(&ChatRequest {
-            message: "describe".into(),
-            system_instruction: String::new(),
-            chat_id: None,
-            image_data_uri: Some("data:image/png;base64,aGk= data:image/jpeg;base64,Ynl5".into()),
-            audio_data_uri: None,
-            video_data_uri: None,
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-            plan_mode: false,
-            pinned_mcp_server: None,
-            messages: None,
-            tools: None,
-            temperature: None,
-            ..Default::default()
-        })
-        .unwrap();
-        assert_eq!(parts.len(), 3);
-        assert_eq!(parts[1]["inlineData"]["mimeType"], "image/png");
-        assert_eq!(parts[2]["inlineData"]["mimeType"], "image/jpeg");
-    }
-
-    fn sample_tool() -> ToolSpec {
-        ToolSpec {
-            name: "read_file".into(),
-            description: "Reads a file".into(),
-            parameters: json!({
-                "type": "object",
-                "properties": { "path": { "type": "string" } },
-                "required": ["path"]
-            }),
-        }
-    }
-
-    fn native_request(messages: Vec<ChatMessage>, tools: Option<Vec<ToolSpec>>) -> ChatRequest {
-        ChatRequest {
-            message: String::new(),
-            system_instruction: "You are Mint.".into(),
-            chat_id: None,
-            image_data_uri: None,
-            audio_data_uri: None,
-            video_data_uri: None,
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-            plan_mode: false,
-            pinned_mcp_server: None,
-            messages: Some(messages),
-            tools,
-            temperature: None,
-            ..Default::default()
-        }
-    }
-
-    #[test]
-    fn anthropic_native_payload_includes_tools_and_tool_result_messages() {
-        let messages = vec![
-            ChatMessage::text(ChatRole::User, "read main.rs"),
-            ChatMessage {
-                role: ChatRole::Assistant,
-                content: vec![ContentBlock::ToolUse {
-                    id: "call_1".into(),
-                    name: "read_file".into(),
-                    input: json!({ "path": "main.rs" }),
-                    thought_signature: None,
-                }],
-            },
-            ChatMessage {
-                role: ChatRole::Tool,
-                content: vec![ContentBlock::ToolResult {
-                    tool_use_id: "call_1".into(),
-                    content: "fn main() {}".into(),
-                    is_error: false,
-                }],
-            },
-        ];
-        let request = native_request(messages, Some(vec![sample_tool()]));
-        let cfg = MintConfig::default();
-        let payload = anthropic_chat_payload(&cfg, "claude-x", &request, false).unwrap();
-
-        assert_eq!(payload["system"][0]["text"], "You are Mint.");
-        assert_eq!(payload["tools"][0]["name"], "read_file");
-        assert_eq!(payload["tools"][0]["input_schema"]["type"], "object");
-        let msgs = payload["messages"].as_array().unwrap();
-        assert_eq!(msgs.len(), 3);
-        assert_eq!(msgs[1]["role"], "assistant");
-        assert_eq!(msgs[1]["content"][0]["type"], "tool_use");
-        assert_eq!(msgs[2]["role"], "user");
-        assert_eq!(msgs[2]["content"][0]["type"], "tool_result");
-        assert_eq!(msgs[2]["content"][0]["tool_use_id"], "call_1");
-    }
-
-    #[test]
-    fn anthropic_payload_marks_the_system_prompt_as_cacheable() {
-        let request = native_request(vec![ChatMessage::text(ChatRole::User, "hi")], None);
-        let cfg = MintConfig::default();
-        let payload = anthropic_chat_payload(&cfg, "claude-x", &request, false).unwrap();
-
-        assert_eq!(payload["system"][0]["type"], "text");
-        assert_eq!(payload["system"][0]["text"], "You are Mint.");
-        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);
-        request.system_instruction = String::new();
-        let cfg = MintConfig::default();
-        let payload = anthropic_chat_payload(&cfg, "claude-x", &request, false).unwrap();
-
-        // Falls back to the plain-string shape rather than an empty cacheable
-        // block, matching the pre-caching behavior exactly for this case.
-        assert_eq!(payload["system"], "");
-    }
-
-    #[test]
-    fn anthropic_payload_marks_only_the_last_tool_as_the_cache_breakpoint() {
-        let second_tool = ToolSpec {
-            name: "write_file".into(),
-            description: "Writes a file".into(),
-            parameters: json!({ "type": "object" }),
-        };
-        let request = native_request(
-            vec![ChatMessage::text(ChatRole::User, "hi")],
-            Some(vec![sample_tool(), second_tool]),
-        );
-        let cfg = MintConfig::default();
-        let payload = anthropic_chat_payload(&cfg, "claude-x", &request, false).unwrap();
-
-        let tools = payload["tools"].as_array().unwrap();
-        assert_eq!(tools.len(), 2);
-        assert!(tools[0].get("cache_control").is_none());
-        assert_eq!(tools[1]["cache_control"]["type"], "ephemeral");
-    }
-
-    #[test]
-    fn anthropic_attaches_cache_control_to_penultimate_turn() {
-        let request = native_request(
-            vec![
-                ChatMessage::text(ChatRole::User, "step 1 user"),
-                ChatMessage::text(ChatRole::Assistant, "step 1 assistant"),
-                ChatMessage::text(ChatRole::User, "step 2 user"),
-            ],
-            None,
-        );
-        let cfg = MintConfig::default();
-        let payload = anthropic_chat_payload(&cfg, "claude-x", &request, false).unwrap();
-        let messages = payload["messages"].as_array().unwrap();
-        assert_eq!(messages.len(), 3);
-        assert!(messages[0]["content"][0].get("cache_control").is_none());
-        assert_eq!(
-            messages[1]["content"][0]["cache_control"]["type"],
-            "ephemeral"
-        );
-        assert!(messages[2]["content"][0].get("cache_control").is_none());
-    }
-
-    #[test]
-    fn parses_anthropic_reply_with_text_and_tool_use_blocks() {
-        let response = json!({
-            "stop_reason": "tool_use",
-            "content": [
-                { "type": "text", "text": "Let me check that file." },
-                { "type": "tool_use", "id": "toolu_1", "name": "read_file", "input": { "path": "main.rs" } }
-            ]
-        });
-        let reply = parse_anthropic_reply("claude-x".into(), &response).unwrap();
-        assert_eq!(reply.text, "Let me check that file.");
-        let calls = reply.tool_calls.unwrap();
-        assert_eq!(calls.len(), 1);
-        assert_eq!(calls[0].name, "read_file");
-        assert_eq!(calls[0].input["path"], "main.rs");
-        assert_eq!(reply.stop_reason.as_deref(), Some("tool_use"));
-    }
-
-    #[test]
-    fn parses_anthropic_reply_with_tool_use_only_and_no_text() {
-        let response = json!({
-            "content": [
-                { "type": "tool_use", "id": "toolu_1", "name": "run_shell", "input": { "command": "ls" } }
-            ]
-        });
-        let reply = parse_anthropic_reply("claude-x".into(), &response).unwrap();
-        assert_eq!(reply.text, "");
-        assert_eq!(reply.tool_calls.unwrap().len(), 1);
-    }
-
-    #[test]
-    fn openai_native_payload_encodes_tool_calls_and_results() {
-        let messages = vec![
-            ChatMessage::text(ChatRole::User, "list files"),
-            ChatMessage {
-                role: ChatRole::Assistant,
-                content: vec![ContentBlock::ToolUse {
-                    id: "call_1".into(),
-                    name: "list_files".into(),
-                    input: json!({ "path": "." }),
-                    thought_signature: None,
-                }],
-            },
-            ChatMessage {
-                role: ChatRole::Tool,
-                content: vec![ContentBlock::ToolResult {
-                    tool_use_id: "call_1".into(),
-                    content: "Cargo.toml\nsrc/".into(),
-                    is_error: false,
-                }],
-            },
-        ];
-        let request = native_request(messages, Some(vec![sample_tool()]));
-        let cfg = MintConfig::default();
-        let payload = openai_chat_payload(&cfg, "gpt-x", &request, false).unwrap();
-
-        assert_eq!(payload["tools"][0]["type"], "function");
-        assert_eq!(payload["tools"][0]["function"]["name"], "read_file");
-        let msgs = payload["messages"].as_array().unwrap();
-        // system + user + assistant(tool_calls) + tool
-        assert_eq!(msgs.len(), 4);
-        assert_eq!(msgs[2]["role"], "assistant");
-        assert_eq!(msgs[2]["tool_calls"][0]["function"]["name"], "list_files");
-        assert_eq!(msgs[3]["role"], "tool");
-        assert_eq!(msgs[3]["tool_call_id"], "call_1");
-    }
-
-    #[test]
-    fn openai_native_payload_forwards_a_screenshot_riding_a_tool_result_as_a_user_turn() {
-        // OpenAI's Chat Completions `tool` role only accepts string content, so an
-        // `Image` block attached to a tool result (e.g. `browser_screenshot`) must
-        // surface as a follow-up `user` message instead of being dropped.
-        let messages = vec![ChatMessage {
-            role: ChatRole::Tool,
-            content: vec![
-                ContentBlock::ToolResult {
-                    tool_use_id: "call_1".into(),
-                    content: "[Screenshot captured — see attached image]".into(),
-                    is_error: false,
-                },
-                ContentBlock::Image {
-                    data_uri: "data:image/png;base64,QUJD".into(),
-                },
-            ],
-        }];
-        let built = openai_native_messages(&messages).unwrap();
-        assert_eq!(built.len(), 2);
-        assert_eq!(built[0]["role"], "tool");
-        assert_eq!(built[0]["tool_call_id"], "call_1");
-        assert_eq!(built[1]["role"], "user");
-        assert_eq!(built[1]["content"][0]["type"], "image_url");
-        assert_eq!(
-            built[1]["content"][0]["image_url"]["url"],
-            "data:image/png;base64,QUJD"
-        );
-    }
-
-    #[test]
-    fn openai_allows_audio_attachments() {
-        let request = ChatRequest {
-            message: "transcribe this".into(),
-            system_instruction: String::new(),
-            chat_id: None,
-            image_data_uri: None,
-            audio_data_uri: Some("data:audio/wav;base64,QUJD".into()),
-            video_data_uri: None,
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-            plan_mode: false,
-            pinned_mcp_server: None,
-            messages: None,
-            tools: None,
-            temperature: None,
-            ..Default::default()
-        };
-        assert!(require_supported_attachments("openai", &request).is_ok());
-    }
-
-    #[test]
-    fn non_openai_openai_family_providers_still_reject_audio() {
-        // Only the real OpenAI API is confirmed to speak the `input_audio`
-        // schema — proxies/other services built on the same wire format
-        // (local_openai, openrouter, deepseek, huggingface) and Anthropic
-        // (no audio modality at all) must stay rejected.
-        let request = ChatRequest {
-            message: "transcribe this".into(),
-            system_instruction: String::new(),
-            chat_id: None,
-            image_data_uri: None,
-            audio_data_uri: Some("data:audio/wav;base64,QUJD".into()),
-            video_data_uri: None,
-            document_attachment: None,
-            workspace_path: None,
-            agent_id: None,
-            plan_mode: false,
-            pinned_mcp_server: None,
-            messages: None,
-            tools: None,
-            temperature: None,
-            ..Default::default()
-        };
-        for provider in [
-            "local_openai",
-            "openrouter",
-            "deepseek",
-            "huggingface",
-            "anthropic",
-        ] {
-            let error = require_supported_attachments(provider, &request).unwrap_err();
-            assert!(
-                matches!(&error, ChatError::UnsupportedAttachments(p) if p == provider),
-                "expected {provider} to reject audio, got {error:?}"
-            );
-        }
-    }
-
-    #[test]
-    fn openai_audio_part_splits_the_data_uri_and_maps_wav_format() {
-        let part = openai_audio_part("data:audio/wav;base64,QUJD").unwrap();
-        assert_eq!(part["type"], "input_audio");
-        assert_eq!(part["input_audio"]["data"], "QUJD");
-        assert_eq!(part["input_audio"]["format"], "wav");
-    }
-
-    #[test]
-    fn openai_audio_part_defaults_unrecognized_formats_to_mp3() {
-        let part = openai_audio_part("data:audio/webm;base64,QUJD").unwrap();
-        assert_eq!(part["input_audio"]["format"], "mp3");
-    }
-
-    #[test]
-    fn openai_audio_part_rejects_a_malformed_data_uri() {
-        assert!(openai_audio_part("not-a-data-uri").is_err());
-    }
-
-    #[test]
-    fn openai_message_content_embeds_audio_alongside_text() {
-        let content =
-            openai_message_content("what is this?", None, Some("data:audio/mp3;base64,QUJD"))
-                .unwrap();
-        let parts = content.as_array().unwrap();
-        assert_eq!(parts[0]["type"], "text");
-        assert_eq!(parts[1]["type"], "input_audio");
-        assert_eq!(parts[1]["input_audio"]["data"], "QUJD");
-    }
-
-    #[test]
-    fn openai_user_content_encodes_an_audio_content_block() {
-        let message = ChatMessage {
-            role: ChatRole::User,
-            content: vec![
-                ContentBlock::Text {
-                    text: "what is this?".into(),
-                },
-                ContentBlock::Audio {
-                    data_uri: "data:audio/wav;base64,QUJD".into(),
-                },
-            ],
-        };
-        let content = openai_user_content(&message).unwrap();
-        let parts = content.as_array().unwrap();
-        assert_eq!(parts.len(), 2);
-        assert_eq!(parts[1]["type"], "input_audio");
-        assert_eq!(parts[1]["input_audio"]["format"], "wav");
-    }
-
-    #[test]
-    fn parses_openai_style_reply_with_tool_calls() {
-        let response = json!({
-            "choices": [{
-                "finish_reason": "tool_calls",
-                "message": {
-                    "content": null,
-                    "tool_calls": [{
-                        "id": "call_1",
-                        "function": { "name": "read_file", "arguments": "{\"path\":\"main.rs\"}" }
-                    }]
-                }
-            }]
-        });
-        let reply = parse_openai_style_reply("gpt-x".into(), &response).unwrap();
-        assert_eq!(reply.text, "");
-        let calls = reply.tool_calls.unwrap();
-        assert_eq!(calls[0].name, "read_file");
-        assert_eq!(calls[0].input["path"], "main.rs");
-        assert_eq!(reply.stop_reason.as_deref(), Some("tool_calls"));
-    }
-
-    #[test]
-    fn gemini_sanitize_schema_strips_additional_properties_at_any_depth() {
-        let schema = json!({
-            "type": "object",
-            "properties": {
-                "emotions": {
-                    "type": "object",
-                    "additionalProperties": { "type": "string" }
-                },
-                "nested": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "additionalProperties": true
-                    }
-                }
-            }
-        });
-        let sanitized = gemini_sanitize_schema(&schema);
-        assert!(
-            sanitized["properties"]["emotions"]
-                .get("additionalProperties")
-                .is_none()
-        );
-        assert!(
-            sanitized["properties"]["nested"]["items"]
-                .get("additionalProperties")
-                .is_none()
-        );
-        // Everything else is preserved untouched.
-        assert_eq!(sanitized["properties"]["emotions"]["type"], "object");
-    }
-
-    #[test]
-    fn gemini_native_payload_strips_additional_properties_from_tool_schemas() {
-        let tool = ToolSpec {
-            name: "avatar_signal".into(),
-            description: "set avatar state".into(),
-            parameters: json!({
-                "type": "object",
-                "properties": {
-                    "emotions": {
-                        "type": "object",
-                        "additionalProperties": { "type": "string" }
-                    }
-                }
-            }),
-        };
-        let request = native_request(
-            vec![ChatMessage::text(ChatRole::User, "hi")],
-            Some(vec![tool]),
-        );
-        let payload = gemini_native_payload(&request).unwrap();
-        assert!(
-            payload["tools"][0]["functionDeclarations"][0]["parameters"]["properties"]["emotions"]
-                .get("additionalProperties")
-                .is_none()
-        );
-    }
-
-    #[test]
-    fn gemini_native_payload_uses_function_declarations_and_resolves_tool_result_names() {
-        let messages = vec![
-            ChatMessage::text(ChatRole::User, "check weather"),
-            ChatMessage {
-                role: ChatRole::Assistant,
-                content: vec![ContentBlock::ToolUse {
-                    id: "call_0".into(),
-                    name: "weather".into(),
-                    input: json!({ "city": "Bangkok" }),
-                    thought_signature: None,
-                }],
-            },
-            ChatMessage {
-                role: ChatRole::Tool,
-                content: vec![ContentBlock::ToolResult {
-                    tool_use_id: "call_0".into(),
-                    content: "32C, sunny".into(),
-                    is_error: false,
-                }],
-            },
-        ];
-        let request = native_request(messages, Some(vec![sample_tool()]));
-        let payload = gemini_native_payload(&request).unwrap();
-
-        assert_eq!(
-            payload["tools"][0]["functionDeclarations"][0]["name"],
-            "read_file"
-        );
-        let contents = payload["contents"].as_array().unwrap();
-        assert_eq!(contents[1]["role"], "model");
-        assert_eq!(contents[1]["parts"][0]["functionCall"]["name"], "weather");
-        assert_eq!(contents[2]["role"], "user");
-        // Resolved back to the function name "weather", not the call id "call_0".
-        assert_eq!(
-            contents[2]["parts"][0]["functionResponse"]["name"],
-            "weather"
-        );
-    }
-
-    #[test]
-    fn gemini_native_payload_replays_the_thought_signature_on_the_next_turn() {
-        // Gemini 3.x rejects a replayed `functionCall` that's missing the
-        // `thoughtSignature` the model originally attached to it (400
-        // INVALID_ARGUMENT) — without this, every second tool-calling turn
-        // failed and silently fell back to a different, weaker provider.
-        let messages = vec![
-            ChatMessage::text(ChatRole::User, "check weather"),
-            ChatMessage {
-                role: ChatRole::Assistant,
-                content: vec![ContentBlock::ToolUse {
-                    id: "call_0".into(),
-                    name: "weather".into(),
-                    input: json!({ "city": "Bangkok" }),
-                    thought_signature: Some("opaque-signature-abc".into()),
-                }],
-            },
-        ];
-        let request = native_request(messages, Some(vec![sample_tool()]));
-        let payload = gemini_native_payload(&request).unwrap();
-
-        let contents = payload["contents"].as_array().unwrap();
-        assert_eq!(
-            contents[1]["parts"][0]["thoughtSignature"],
-            "opaque-signature-abc"
-        );
-        // Sibling of `functionCall`, not nested inside it.
-        assert_eq!(contents[1]["parts"][0]["functionCall"]["name"], "weather");
-    }
-
-    #[test]
-    fn gemini_native_payload_omits_thought_signature_when_absent() {
-        let messages = vec![ChatMessage {
-            role: ChatRole::Assistant,
-            content: vec![ContentBlock::ToolUse {
-                id: "call_0".into(),
-                name: "weather".into(),
-                input: json!({ "city": "Bangkok" }),
-                thought_signature: None,
-            }],
-        }];
-        let request = native_request(messages, Some(vec![sample_tool()]));
-        let payload = gemini_native_payload(&request).unwrap();
-
-        let contents = payload["contents"].as_array().unwrap();
-        assert!(contents[0]["parts"][0].get("thoughtSignature").is_none());
-    }
-
-    #[test]
-    fn parses_gemini_reply_with_function_call_parts() {
-        let response = json!({
-            "candidates": [{
-                "finishReason": "STOP",
-                "content": {
-                    "parts": [
-                        { "text": "Checking the weather now." },
-                        { "functionCall": { "name": "weather", "args": { "city": "Bangkok" } } }
-                    ]
-                }
-            }]
-        });
-        let reply = parse_gemini_reply("gemini-x".into(), &response).unwrap();
-        assert_eq!(reply.text, "Checking the weather now.");
-        let calls = reply.tool_calls.unwrap();
-        assert_eq!(calls[0].name, "weather");
-        assert_eq!(calls[0].input["city"], "Bangkok");
-    }
-
-    #[test]
-    fn parses_gemini_reply_captures_the_thought_signature_off_the_function_call_part() {
-        let response = json!({
-            "candidates": [{
-                "finishReason": "STOP",
-                "content": {
-                    "parts": [{
-                        "functionCall": { "name": "weather", "args": { "city": "Bangkok" } },
-                        "thoughtSignature": "opaque-signature-abc"
-                    }]
-                }
-            }]
-        });
-        let reply = parse_gemini_reply("gemini-x".into(), &response).unwrap();
-        let calls = reply.tool_calls.unwrap();
-        assert_eq!(
-            calls[0].thought_signature.as_deref(),
-            Some("opaque-signature-abc")
-        );
-    }
-
-    #[test]
-    fn ollama_native_messages_send_tool_call_arguments_as_object_not_string() {
-        let messages = vec![
-            ChatMessage::text(ChatRole::User, "list files"),
-            ChatMessage {
-                role: ChatRole::Assistant,
-                content: vec![ContentBlock::ToolUse {
-                    id: "call_1".into(),
-                    name: "list_files".into(),
-                    input: json!({ "path": "." }),
-                    thought_signature: None,
-                }],
-            },
-        ];
-        let built = ollama_native_messages(&messages);
-        assert_eq!(built[1]["tool_calls"][0]["function"]["name"], "list_files");
-        // Ollama expects `arguments` as a JSON object, unlike OpenAI's stringified form.
-        assert!(built[1]["tool_calls"][0]["function"]["arguments"].is_object());
-    }
-
-    #[test]
-    fn ollama_native_messages_forward_a_screenshot_riding_a_tool_result_as_a_user_turn() {
-        // Ollama's `/api/chat` `tool` role message has no image field, so an
-        // `Image` block attached to a tool result (e.g. `browser_screenshot`)
-        // must surface as a follow-up `user` message with the `images` field.
-        let messages = vec![ChatMessage {
-            role: ChatRole::Tool,
-            content: vec![
-                ContentBlock::ToolResult {
-                    tool_use_id: "call_1".into(),
-                    content: "[Screenshot captured — see attached image]".into(),
-                    is_error: false,
-                },
-                ContentBlock::Image {
-                    data_uri: "data:image/png;base64,QUJD".into(),
-                },
-            ],
-        }];
-        let built = ollama_native_messages(&messages);
-        assert_eq!(built.len(), 2);
-        assert_eq!(built[0]["role"], "tool");
-        assert_eq!(built[1]["role"], "user");
-        assert_eq!(built[1]["images"][0], "QUJD");
-    }
-
-    #[test]
-    fn parses_ollama_reply_from_native_message_envelope() {
-        let response = json!({
-            "message": {
-                "content": "",
-                "tool_calls": [{
-                    "function": { "name": "list_files", "arguments": { "path": "." } }
-                }]
-            }
-        });
-        let reply = parse_ollama_reply("llama3.1".into(), &response).unwrap();
-        assert_eq!(reply.tool_calls.unwrap()[0].name, "list_files");
-    }
-
-    #[test]
-    fn extracts_input_and_output_tokens_from_each_provider_usage_shape() {
-        let anthropic = parse_anthropic_reply(
-            "claude-x".into(),
-            &json!({
-                "content": [{ "type": "text", "text": "hi" }],
-                "usage": { "input_tokens": 100, "output_tokens": 20 }
-            }),
-        )
-        .unwrap();
-        assert_eq!(
-            (anthropic.input_tokens, anthropic.output_tokens),
-            (Some(100), Some(20))
-        );
-
-        let openai = parse_openai_style_reply(
-            "gpt-x".into(),
-            &json!({
-                "choices": [{ "message": { "content": "hi" } }],
-                "usage": { "prompt_tokens": 130, "completion_tokens": 20, "total_tokens": 150 }
-            }),
-        )
-        .unwrap();
-        assert_eq!(
-            (openai.input_tokens, openai.output_tokens),
-            (Some(130), Some(20))
-        );
-
-        let gemini = parse_gemini_reply(
-            "gemini-x".into(),
-            &json!({
-                "candidates": [{ "content": { "parts": [{ "text": "hi" }] } }],
-                "usageMetadata": {
-                    "promptTokenCount": 160,
-                    "candidatesTokenCount": 40,
-                    "totalTokenCount": 200
-                }
-            }),
-        )
-        .unwrap();
-        assert_eq!(
-            (gemini.input_tokens, gemini.output_tokens),
-            (Some(160), Some(40))
-        );
-
-        let ollama = parse_ollama_reply(
-            "llama3.1".into(),
-            &json!({
-                "message": { "content": "hi" },
-                "prompt_eval_count": 80,
-                "eval_count": 40
-            }),
-        )
-        .unwrap();
-        assert_eq!(
-            (ollama.input_tokens, ollama.output_tokens),
-            (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() {
-        let reply = parse_openai_style_reply(
-            "gpt-x".into(),
-            &json!({ "choices": [{ "message": { "content": "hi" } }] }),
-        )
-        .unwrap();
-        assert_eq!((reply.input_tokens, reply.output_tokens), (None, None));
-    }
-
-    #[tokio::test]
-    async fn send_openai_style_request_classifies_a_connect_failure_as_network_unavailable() {
-        let client = Client::new();
-        // Port 1 is reserved and nothing listens on it, so this fails fast
-        // with a connection error rather than timing out.
-        let result = send_openai_style_request(
-            client.post("http://127.0.0.1:1/chat/completions"),
-            "deepseek",
-        )
-        .await;
-        assert!(
-            matches!(result, Err(ChatError::NetworkUnavailable)),
-            "expected NetworkUnavailable, got {result:?}"
-        );
-    }
-
-    #[tokio::test]
-    async fn send_openai_style_request_classifies_402_as_insufficient_balance() {
-        use tokio::io::{AsyncReadExt, AsyncWriteExt};
-        use tokio::net::TcpListener;
-
-        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
-        let addr = listener.local_addr().unwrap();
-        tokio::spawn(async move {
-            let (mut socket, _) = listener.accept().await.unwrap();
-            let mut buf = [0u8; 1024];
-            let _ = socket.read(&mut buf).await;
-            let body = "{}";
-            let response = format!(
-                "HTTP/1.1 402 Payment Required\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
-                body.len()
-            );
-            let _ = socket.write_all(response.as_bytes()).await;
-            let _ = socket.shutdown().await;
-        });
-
-        let client = Client::new();
-        let result = send_openai_style_request(
-            client.post(format!("http://{addr}/chat/completions")),
-            "deepseek",
-        )
-        .await;
-        assert!(
-            matches!(&result, Err(ChatError::InsufficientBalance(p)) if p == "deepseek"),
-            "expected InsufficientBalance(\"deepseek\"), got {result:?}"
-        );
-    }
-
-    #[test]
-    fn fallback_provider_order_moves_gemini_to_the_front() {
-        let config = MintConfig {
-            anthropic_api_key: "a".into(),
-            openai_api_key: "b".into(),
-            deepseek_api_key: "c".into(),
-            api_key: "d".into(), // gemini
-            hf_api_key: "e".into(),
-            ..MintConfig::default()
-        };
-        let order = fallback_provider_order(&config);
-        assert_eq!(order[0], "gemini");
-        // Everyone else keeps their existing relative order from
-        // `available_providers()` — only gemini moves.
-        let without_gemini: Vec<&String> = order.iter().skip(1).collect();
-        assert_eq!(
-            without_gemini,
-            vec!["anthropic", "openai", "deepseek", "huggingface", "ollama"]
-        );
-    }
-
-    #[test]
-    fn fallback_provider_order_is_unchanged_without_gemini_configured() {
-        let config = MintConfig {
-            deepseek_api_key: "c".into(),
-            hf_api_key: "e".into(),
-            ..MintConfig::default()
-        };
-        assert_eq!(
-            fallback_provider_order(&config),
-            config.available_providers()
-        );
-    }
-
-    #[test]
-    fn openai_payload_includes_smart_temperature_for_deepseek_and_omits_for_o1() {
-        let request = native_request(vec![ChatMessage::text(ChatRole::User, "hi")], None);
-
-        // DeepSeek smart default is 0.6
-        let ds_config = MintConfig {
-            ai_provider: "deepseek".into(),
-            deepseek_model: "deepseek-chat".into(),
-            ..MintConfig::default()
-        };
-        let ds_payload = openai_chat_payload(&ds_config, "deepseek-chat", &request, false).unwrap();
-        assert_eq!(ds_payload["temperature"], 0.6);
-
-        // Standard OpenAI model default is 0.2
-        let openai_config = MintConfig {
-            ai_provider: "openai".into(),
-            openai_model: "gpt-4o".into(),
-            ..MintConfig::default()
-        };
-        let openai_payload =
-            openai_chat_payload(&openai_config, "gpt-4o", &request, false).unwrap();
-        assert_eq!(openai_payload["temperature"], 0.2);
-
-        // Reasoning models (o1, o3) omit temperature parameter
-        let o1_payload =
-            openai_chat_payload(&openai_config, "o1-preview", &request, false).unwrap();
-        assert!(o1_payload.get("temperature").is_none());
-
-        let o3_payload = openai_chat_payload(&openai_config, "o3-mini", &request, false).unwrap();
-        assert!(o3_payload.get("temperature").is_none());
-
-        // Explicit request temperature override
-        let mut override_req = request.clone();
-        override_req.temperature = Some(0.75);
-        let override_payload =
-            openai_chat_payload(&ds_config, "deepseek-chat", &override_req, false).unwrap();
-        assert_eq!(override_payload["temperature"], 0.75);
-    }
-
-    #[test]
-    fn anthropic_payload_includes_effective_temperature() {
-        let request = native_request(vec![ChatMessage::text(ChatRole::User, "hi")], None);
-        let config = MintConfig {
-            ai_provider: "anthropic".into(),
-            anthropic_model: "claude-sonnet-5".into(),
-            thinking_enabled: false,
-            ..MintConfig::default()
-        };
-        let payload = anthropic_chat_payload(&config, "claude-sonnet-5", &request, false).unwrap();
-        assert_eq!(payload["temperature"], 0.2);
-    }
-
-    #[test]
-    fn parse_openai_style_reply_extracts_deepseek_reasoning_content() {
-        let response = json!({
-            "choices": [{
-                "message": {
-                    "role": "assistant",
-                    "content": "",
-                    "reasoning_content": "Evaluating 15 + 6 * (8 - 3) - 14 / 2 step by step...",
-                    "tool_calls": [{
-                        "id": "call_calc_1",
-                        "type": "function",
-                        "function": {
-                            "name": "calculation",
-                            "arguments": "{\"expression\":\"15 + 6 * (8 - 3) - 14 / 2\"}"
-                        }
-                    }]
-                },
-                "finish_reason": "tool_calls"
-            }]
-        });
-        let reply = parse_openai_style_reply("deepseek-reasoner".into(), &response).unwrap();
-        assert_eq!(reply.text, "");
-        assert_eq!(
-            reply.thought.as_deref(),
-            Some("Evaluating 15 + 6 * (8 - 3) - 14 / 2 step by step...")
-        );
-        let calls = reply.tool_calls.unwrap();
-        assert_eq!(calls.len(), 1);
-        assert_eq!(calls[0].name, "calculation");
-    }
-
-    #[test]
-    fn parse_openai_style_reply_extracts_openrouter_reasoning() {
-        let response = json!({
-            "choices": [{
-                "message": {
-                    "role": "assistant",
-                    "content": "The answer is 38.",
-                    "reasoning": "First parentheses: 8 - 3 = 5..."
-                },
-                "finish_reason": "stop"
-            }]
-        });
-        let reply = parse_openai_style_reply("deepseek/deepseek-r1".into(), &response).unwrap();
-        assert_eq!(reply.text, "The answer is 38.");
-        assert_eq!(
-            reply.thought.as_deref(),
-            Some("First parentheses: 8 - 3 = 5...")
-        );
-    }
-
-    #[test]
-    fn parse_openai_style_reply_extracts_think_tags() {
-        let response = json!({
-            "choices": [{
-                "message": {
-                    "role": "assistant",
-                    "content": "<think>\nLet me solve this problem.\n</think>\nThe result is 42."
-                },
-                "finish_reason": "stop"
-            }]
-        });
-        let reply = parse_openai_style_reply("qwq-32b".into(), &response).unwrap();
-        assert_eq!(reply.text, "The result is 42.");
-        assert_eq!(reply.thought.as_deref(), Some("Let me solve this problem."));
-    }
-
-    #[test]
-    fn parse_gemini_reply_extracts_thought_parts() {
-        let response = json!({
-            "candidates": [{
-                "content": {
-                    "parts": [
-                        { "text": "Thinking through the formula...", "thought": true },
-                        { "text": "The answer is 38." }
-                    ]
-                },
-                "finishReason": "STOP"
-            }]
-        });
-        let reply = parse_gemini_reply("gemini-2.0-flash-thinking".into(), &response).unwrap();
-        assert_eq!(reply.text, "The answer is 38.");
-        assert_eq!(
-            reply.thought.as_deref(),
-            Some("Thinking through the formula...")
-        );
-    }
-
-    #[test]
-    fn parse_anthropic_reply_extracts_thinking_blocks() {
-        let response = json!({
-            "content": [
-                { "type": "thinking", "thinking": "Let's break down the arithmetic..." },
-                { "type": "text", "text": "The result is 38." }
-            ],
-            "stop_reason": "end_turn"
-        });
-        let reply = parse_anthropic_reply("claude-3-7-sonnet".into(), &response).unwrap();
-        assert_eq!(reply.text, "The result is 38.");
-        assert_eq!(
-            reply.thought.as_deref(),
-            Some("Let's break down the arithmetic...")
-        );
-    }
-
-    #[test]
-    fn parse_ollama_reply_extracts_thinking_field() {
-        let response = json!({
-            "message": {
-                "role": "assistant",
-                "content": "Result is 38.",
-                "thinking": "Ollama internal thinking trace..."
-            }
-        });
-        let reply = parse_ollama_reply("deepseek-r1:8b".into(), &response).unwrap();
-        assert_eq!(reply.text, "Result is 38.");
-        assert_eq!(
-            reply.thought.as_deref(),
-            Some("Ollama internal thinking trace...")
-        );
-    }
-}