tiycore 0.2.9

Unified LLM API and stateful Agent runtime in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Xiaomi MiMo provider (reuses OpenAI Completions protocol).
//!
//! Xiaomi MiMo uses the OpenAI Chat Completions API at:
//! - `https://api.xiaomimimo.com/v1`
//!
//! This provider delegates to `OpenAICompletionsProtocol` with a default base URL.
//!
//! Compat customizations:
//! - `xhigh` thinking level is downgraded to `high` (Xiaomi MiMo does not support xhigh).

use crate::protocol::LLMProtocol;
use crate::stream::AssistantMessageEventStream;
use crate::types::*;
use async_trait::async_trait;
use std::collections::HashMap;

/// Default base URL for Xiaomi MiMo API.
const DEFAULT_BASE_URL: &str = "https://api.xiaomimimo.com/v1";

/// Xiaomi MiMo provider (OpenAI-compatible).
pub struct XiaomiMIMOProvider {
    default_api_key: Option<String>,
}

impl XiaomiMIMOProvider {
    /// Create a new Xiaomi MiMo provider.
    pub fn new() -> Self {
        Self {
            default_api_key: None,
        }
    }

    /// Create a provider with a default API key.
    pub fn with_api_key(api_key: impl Into<String>) -> Self {
        Self {
            default_api_key: Some(api_key.into()),
        }
    }

    /// Get provider-specific compat settings.
    pub fn default_compat() -> OpenAICompletionsCompat {
        let mut effort_map = HashMap::new();
        effort_map.insert("xhigh".to_string(), "high".to_string());
        OpenAICompletionsCompat {
            thinking: CompatThinking {
                effort_map,
                ..Default::default()
            },
            ..Default::default()
        }
    }

    /// Resolve API key from options, self, or environment.
    fn resolve_api_key(&self, options: &StreamOptions) -> Option<String> {
        if let Some(ref key) = options.api_key {
            return Some(key.clone());
        }
        if let Some(ref key) = self.default_api_key {
            return Some(key.clone());
        }
        std::env::var("XIAOMI_MIMO_API_KEY").ok()
    }
}

impl Default for XiaomiMIMOProvider {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait]
impl LLMProtocol for XiaomiMIMOProvider {
    fn provider_type(&self) -> Provider {
        Provider::XiaomiMIMO
    }

    fn stream(
        &self,
        model: &Model,
        context: &Context,
        options: StreamOptions,
    ) -> AssistantMessageEventStream {
        let mut opts = options;
        if opts.api_key.is_none() {
            opts.api_key = self.resolve_api_key(&opts);
        }

        let mut m = model.clone();

        // Set default base_url if not provided
        if m.base_url.is_none() && opts.base_url.is_none() {
            m.base_url = Some(DEFAULT_BASE_URL.to_string());
        }

        // Inject compat with xhigh→high downgrade if not already set
        if m.compat.is_none() {
            m.compat = Some(Self::default_compat());
        }

        let provider = crate::protocol::openai_completions::OpenAICompletionsProtocol::new();
        provider.stream(&m, context, opts)
    }

    fn stream_simple(
        &self,
        model: &Model,
        context: &Context,
        options: SimpleStreamOptions,
    ) -> AssistantMessageEventStream {
        let mut opts = options;
        if opts.base.api_key.is_none() {
            opts.base.api_key = self.resolve_api_key(&opts.base);
        }

        let mut m = model.clone();

        // Set default base_url if not provided
        if m.base_url.is_none() && opts.base.base_url.is_none() {
            m.base_url = Some(DEFAULT_BASE_URL.to_string());
        }

        // Inject compat with xhigh→high downgrade if not already set
        if m.compat.is_none() {
            m.compat = Some(Self::default_compat());
        }

        let provider = crate::protocol::openai_completions::OpenAICompletionsProtocol::new();
        provider.stream_simple(&m, context, opts)
    }
}