vtcode_core/llm/providers/
mimo.rs

1use async_trait::async_trait;
2use reqwest::Client as HttpClient;
3use serde_json::{Map, Value};
4
5use crate::config::TimeoutsConfig;
6use crate::config::constants::{env_vars, models, urls};
7use crate::config::core::{AnthropicConfig, ModelConfig, PromptCachingConfig};
8use crate::llm::error_display;
9use crate::llm::provider::{LLMError, LLMProvider, LLMRequest, LLMResponse, LLMStream};
10
11use super::{
12    common::{
13        ensure_model, extract_prompt_cache_settings_default, impl_llm_client, override_base_url,
14        parse_json_response, parse_response_openai_format, resolve_model,
15        serialize_messages_openai_format, serialize_tools_openai_format,
16        spawn_openai_compatible_stream, validate_supported_models,
17    },
18    error_handling::handle_openai_http_error,
19    extract_reasoning_trace,
20};
21
22const PROVIDER_NAME: &str = "Xiaomi MiMo";
23const PROVIDER_KEY: &str = "mimo";
24
25pub struct MiMoProvider {
26    api_key: String,
27    http_client: HttpClient,
28    base_url: String,
29    model: String,
30    prompt_cache_enabled: bool,
31    model_behavior: Option<ModelConfig>,
32}
33
34impl MiMoProvider {
35    pub fn new(api_key: String) -> Self {
36        Self::with_model_internal(
37            api_key,
38            models::mimo::DEFAULT_MODEL.to_string(),
39            None,
40            None,
41            TimeoutsConfig::default(),
42            None,
43        )
44    }
45
46    pub fn with_model(api_key: String, model: String) -> Self {
47        Self::with_model_internal(api_key, model, None, None, TimeoutsConfig::default(), None)
48    }
49
50    pub fn new_with_client(
51        api_key: String,
52        model: String,
53        http_client: reqwest::Client,
54        base_url: String,
55        _timeouts: TimeoutsConfig,
56    ) -> Self {
57        Self {
58            api_key,
59            http_client,
60            base_url,
61            model,
62            prompt_cache_enabled: false,
63            model_behavior: None,
64        }
65    }
66
67    pub fn from_config(
68        api_key: Option<String>,
69        model: Option<String>,
70        base_url: Option<String>,
71        prompt_cache: Option<PromptCachingConfig>,
72        timeouts: Option<TimeoutsConfig>,
73        _anthropic: Option<AnthropicConfig>,
74        model_behavior: Option<ModelConfig>,
75    ) -> Self {
76        let api_key_value = api_key.unwrap_or_default();
77
78        Self::with_model_internal(
79            api_key_value,
80            resolve_model(model, models::mimo::DEFAULT_MODEL),
81            prompt_cache,
82            base_url,
83            timeouts.unwrap_or_default(),
84            model_behavior,
85        )
86    }
87
88    fn with_model_internal(
89        api_key: String,
90        model: String,
91        prompt_cache: Option<PromptCachingConfig>,
92        base_url: Option<String>,
93        timeouts: TimeoutsConfig,
94        model_behavior: Option<ModelConfig>,
95    ) -> Self {
96        use crate::llm::http_client::HttpClientFactory;
97
98        let (prompt_cache_enabled, _) =
99            extract_prompt_cache_settings_default(prompt_cache, PROVIDER_KEY);
100
101        Self {
102            api_key,
103            http_client: HttpClientFactory::for_llm(&timeouts),
104            base_url: override_base_url(
105                urls::MIMO_API_BASE,
106                base_url,
107                Some(env_vars::MIMO_BASE_URL),
108            ),
109            model,
110            prompt_cache_enabled,
111            model_behavior,
112        }
113    }
114
115    #[must_use]
116    #[inline]
117    fn is_thinking_enabled(request: &LLMRequest) -> bool {
118        request
119            .reasoning_effort
120            .is_some_and(|e| e != crate::config::types::ReasoningEffortLevel::None)
121    }
122
123    fn convert_to_mimo_format(&self, request: &LLMRequest) -> Result<Value, LLMError> {
124        let mut payload = Map::with_capacity(12);
125
126        payload.insert("model".to_owned(), Value::String(request.model.clone()));
127
128        let mut messages = self.serialize_messages(request)?;
129
130        if let Some(system_prompt) = &request.system_prompt {
131            let trimmed = system_prompt.trim();
132            if !trimmed.is_empty() {
133                messages.insert(0, serde_json::json!({"role": "system", "content": trimmed}));
134            }
135        }
136
137        payload.insert("messages".to_owned(), Value::Array(messages));
138
139        if let Some(max_tokens) = request.max_tokens {
140            payload.insert(
141                "max_completion_tokens".to_owned(),
142                Value::Number(serde_json::Number::from(max_tokens as u64)),
143            );
144        }
145
146        let thinking_enabled = Self::is_thinking_enabled(request);
147
148        if !thinking_enabled {
149            if let Some(temperature) = request.temperature {
150                payload.insert(
151                    "temperature".to_owned(),
152                    Value::Number(super::common::float_to_json_number(temperature)?),
153                );
154            }
155
156            if let Some(top_p) = request.top_p {
157                payload.insert(
158                    "top_p".to_owned(),
159                    Value::Number(super::common::float_to_json_number(top_p)?),
160                );
161            }
162        }
163
164        if request.stream {
165            payload.insert("stream".to_string(), Value::Bool(true));
166            payload.insert(
167                "stream_options".to_string(),
168                serde_json::json!({"include_usage": true}),
169            );
170        }
171
172        if let Some(tools) = &request.tools
173            && let Some(serialized_tools) = serialize_tools_openai_format(tools)
174        {
175            payload.insert("tools".to_string(), Value::Array(serialized_tools));
176        }
177
178        if let Some(choice) = &request.tool_choice {
179            payload.insert(
180                "tool_choice".to_string(),
181                choice.to_provider_format(PROVIDER_KEY),
182            );
183        }
184
185        if let Some(effort) = request.reasoning_effort {
186            if effort == crate::config::types::ReasoningEffortLevel::None {
187                payload.insert(
188                    "thinking".to_owned(),
189                    serde_json::json!({"type": "disabled"}),
190                );
191            } else {
192                payload.insert(
193                    "thinking".to_owned(),
194                    serde_json::json!({"type": "enabled"}),
195                );
196            }
197        }
198
199        if let Some(meta) = &request.metadata
200            && let Some(user_id) = meta.get("user_id").and_then(|v| v.as_str())
201        {
202            payload.insert("user_id".to_owned(), Value::String(user_id.to_owned()));
203        }
204
205        Ok(Value::Object(payload))
206    }
207
208    async fn send_request(&self, payload: &Value) -> Result<reqwest::Response, LLMError> {
209        let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
210
211        self.http_client
212            .post(&url)
213            .header("api-key", &self.api_key)
214            .json(payload)
215            .send()
216            .await
217            .map_err(|e| LLMError::Network {
218                message: error_display::format_llm_error(
219                    PROVIDER_NAME,
220                    &format!("network error: {}", e),
221                ),
222                metadata: None,
223            })
224    }
225
226    fn serialize_messages(&self, request: &LLMRequest) -> Result<Vec<Value>, LLMError> {
227        serialize_messages_openai_format(request, PROVIDER_KEY)
228    }
229
230    fn parse_response(&self, response_json: Value, model: String) -> Result<LLMResponse, LLMError> {
231        let reasoning_extractor = |message: &Value, choice: &Value| {
232            message
233                .get("reasoning_content")
234                .and_then(extract_reasoning_trace)
235                .or_else(|| {
236                    choice
237                        .get("reasoning_content")
238                        .and_then(extract_reasoning_trace)
239                })
240        };
241
242        parse_response_openai_format(
243            response_json,
244            PROVIDER_NAME,
245            model,
246            self.prompt_cache_enabled,
247            Some(reasoning_extractor),
248        )
249    }
250}
251
252#[async_trait]
253impl LLMProvider for MiMoProvider {
254    fn name(&self) -> &str {
255        PROVIDER_KEY
256    }
257
258    fn supports_streaming(&self) -> bool {
259        true
260    }
261
262    fn supports_tools(&self, _model: &str) -> bool {
263        true
264    }
265
266    fn supports_structured_output(&self, _model: &str) -> bool {
267        true
268    }
269
270    fn supports_vision(&self, model: &str) -> bool {
271        model == models::mimo::MIMO_V2_5
272    }
273
274    fn supports_reasoning(&self, model: &str) -> bool {
275        let requested = if model.trim().is_empty() {
276            &self.model
277        } else {
278            model
279        };
280
281        self.model_behavior
282            .as_ref()
283            .and_then(|b| b.model_supports_reasoning)
284            .unwrap_or(false)
285            || requested == models::mimo::MIMO_V2_5_PRO
286            || requested == models::mimo::MIMO_V2_5
287    }
288
289    fn supports_reasoning_effort(&self, _model: &str) -> bool {
290        self.model_behavior
291            .as_ref()
292            .and_then(|b| b.model_supports_reasoning_effort)
293            .unwrap_or(false)
294    }
295
296    fn effective_context_size(&self, model: &str) -> usize {
297        let requested = if model.trim().is_empty() {
298            &self.model
299        } else {
300            model
301        };
302        match requested {
303            models::mimo::MIMO_V2_5_PRO | models::mimo::MIMO_V2_5 => 1_048_576,
304            _ => 128_000,
305        }
306    }
307
308    async fn generate(&self, mut request: LLMRequest) -> Result<LLMResponse, LLMError> {
309        let model = ensure_model(&mut request, &self.model);
310
311        let payload = self.convert_to_mimo_format(&request)?;
312        let response = self.send_request(&payload).await?;
313        let response = handle_openai_http_error(response, PROVIDER_NAME, "MIMO_API_KEY").await?;
314
315        let response_json = parse_json_response(response, PROVIDER_NAME).await?;
316        self.parse_response(response_json, model)
317    }
318
319    async fn stream(&self, mut request: LLMRequest) -> Result<LLMStream, LLMError> {
320        ensure_model(&mut request, &self.model);
321        self.validate_request(&request)?;
322        request.stream = true;
323        let model = request.model.clone();
324
325        let payload = self.convert_to_mimo_format(&request)?;
326        let response = self.send_request(&payload).await?;
327        let response = handle_openai_http_error(response, PROVIDER_NAME, "MIMO_API_KEY").await?;
328
329        Ok(spawn_openai_compatible_stream(
330            response,
331            PROVIDER_NAME,
332            model,
333            Some("reasoning_content"),
334            super::shared::OpenAiDeltaOrder::ReasoningFirst,
335        ))
336    }
337
338    fn supported_models(&self) -> Vec<String> {
339        models::mimo::SUPPORTED_MODELS
340            .iter()
341            .map(|model| model.to_string())
342            .collect()
343    }
344
345    fn validate_request(&self, request: &LLMRequest) -> Result<(), LLMError> {
346        validate_supported_models(
347            request,
348            PROVIDER_NAME,
349            PROVIDER_KEY,
350            models::mimo::SUPPORTED_MODELS,
351        )
352    }
353}
354
355impl_llm_client!(MiMoProvider);
vtcode_core/llm/providers/mimo.rs

vtcode_core/llm/providers/
mimo.rs
