tiycore 0.2.3

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! OpenCode Go provider (adaptive multi-protocol proxy based on model ID).
//!
//! OpenCode Go is a multi-protocol proxy that supports:
//! - OpenAI Completions protocol for GLM, Kimi, and Mimo models
//! - Anthropic Messages protocol for MiniMax models
//!
//! Adaptive routing logic:
//! - If the model ID contains "minimax" (case-insensitive),
//!   routes to Anthropic Messages protocol
//! - Otherwise, routes to OpenAI Completions protocol
//!
//! Default base URL: `https://opencode.ai/zen/go/v1`
//! API key environment variable: `OPENCODE_GO_API_KEY`

use crate::protocol::LLMProtocol;
use crate::stream::AssistantMessageEventStream;
use crate::types::*;
use async_trait::async_trait;

/// Default base URL for OpenCode Go.
const DEFAULT_BASE_URL: &str = "https://opencode.ai/zen/go/v1";

/// Protocol routing decision for a model.
enum ProtocolRoute {
    OpenAICompletions,
    Anthropic,
}

/// OpenCode Go provider (multi-protocol proxy).
pub struct OpenCodeGoProvider {
    default_api_key: Option<String>,
}

impl OpenCodeGoProvider {
    /// Create a new OpenCode Go 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()),
        }
    }

    /// 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("OPENCODE_GO_API_KEY").ok()
    }

    /// Determine protocol route based on model ID.
    fn detect_route(model_id: &str) -> ProtocolRoute {
        let lower = model_id.to_lowercase();
        if lower.contains("minimax") {
            ProtocolRoute::Anthropic
        } else {
            ProtocolRoute::OpenAICompletions
        }
    }
}

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

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

    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());
        }

        match Self::detect_route(&m.id) {
            ProtocolRoute::Anthropic => {
                m.api = Some(Api::AnthropicMessages);
                let provider = crate::protocol::anthropic::AnthropicProtocol::new();
                provider.stream(&m, context, opts)
            }
            ProtocolRoute::OpenAICompletions => {
                m.api = Some(Api::OpenAICompletions);
                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());
        }

        match Self::detect_route(&m.id) {
            ProtocolRoute::Anthropic => {
                m.api = Some(Api::AnthropicMessages);
                let provider = crate::protocol::anthropic::AnthropicProtocol::new();
                provider.stream_simple(&m, context, opts)
            }
            ProtocolRoute::OpenAICompletions => {
                m.api = Some(Api::OpenAICompletions);
                let provider =
                    crate::protocol::openai_completions::OpenAICompletionsProtocol::new();
                provider.stream_simple(&m, context, opts)
            }
        }
    }
}