vtcode_core/llm/providers/
qwen.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 = "Qwen";
23const PROVIDER_KEY: &str = "qwen";
24
25pub struct QwenProvider {
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 QwenProvider {
35    pub fn new(api_key: String) -> Self {
36        Self::with_model_internal(
37            api_key,
38            models::qwen::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
77            .filter(|k| !k.trim().is_empty())
78            .or_else(|| {
79                std::env::var("QWEN_API_KEY")
80                    .ok()
81                    .filter(|k| !k.trim().is_empty())
82            })
83            .or_else(|| {
84                std::env::var("DASHSCOPE_API_KEY")
85                    .ok()
86                    .filter(|k| !k.trim().is_empty())
87            })
88            .unwrap_or_default();
89
90        Self::with_model_internal(
91            api_key_value,
92            resolve_model(model, models::qwen::DEFAULT_MODEL),
93            prompt_cache,
94            base_url,
95            timeouts.unwrap_or_default(),
96            model_behavior,
97        )
98    }
99
100    fn with_model_internal(
101        api_key: String,
102        model: String,
103        prompt_cache: Option<PromptCachingConfig>,
104        base_url: Option<String>,
105        timeouts: TimeoutsConfig,
106        model_behavior: Option<ModelConfig>,
107    ) -> Self {
108        use crate::llm::http_client::HttpClientFactory;
109
110        let (prompt_cache_enabled, _) =
111            extract_prompt_cache_settings_default(prompt_cache, PROVIDER_KEY);
112
113        Self {
114            api_key,
115            http_client: HttpClientFactory::for_llm(&timeouts),
116            base_url: override_base_url(
117                urls::QWEN_API_BASE,
118                base_url,
119                Some(env_vars::QWEN_BASE_URL),
120            ),
121            model,
122            prompt_cache_enabled,
123            model_behavior,
124        }
125    }
126
127    #[must_use]
128    #[inline]
129    fn is_thinking_enabled(request: &LLMRequest) -> bool {
130        request
131            .reasoning_effort
132            .is_some_and(|e| e != crate::config::types::ReasoningEffortLevel::None)
133    }
134
135    fn convert_to_qwen_format(&self, request: &LLMRequest) -> Result<Value, LLMError> {
136        let mut payload = Map::with_capacity(12);
137
138        payload.insert("model".to_owned(), Value::String(request.model.clone()));
139
140        let mut messages = self.serialize_messages(request)?;
141
142        if let Some(system_prompt) = &request.system_prompt {
143            let trimmed = system_prompt.trim();
144            if !trimmed.is_empty() {
145                messages.insert(0, serde_json::json!({"role": "system", "content": trimmed}));
146            }
147        }
148
149        payload.insert("messages".to_owned(), Value::Array(messages));
150
151        if let Some(max_tokens) = request.max_tokens {
152            payload.insert(
153                "max_tokens".to_owned(),
154                Value::Number(serde_json::Number::from(max_tokens as u64)),
155            );
156        }
157
158        let thinking_enabled = Self::is_thinking_enabled(request);
159
160        if !thinking_enabled {
161            if let Some(temperature) = request.temperature {
162                payload.insert(
163                    "temperature".to_owned(),
164                    Value::Number(super::common::float_to_json_number(temperature)?),
165                );
166            }
167
168            if let Some(top_p) = request.top_p {
169                payload.insert(
170                    "top_p".to_owned(),
171                    Value::Number(super::common::float_to_json_number(top_p)?),
172                );
173            }
174        }
175
176        if request.stream {
177            payload.insert("stream".to_string(), Value::Bool(true));
178            payload.insert(
179                "stream_options".to_string(),
180                serde_json::json!({"include_usage": true}),
181            );
182        }
183
184        if let Some(tools) = &request.tools
185            && let Some(serialized_tools) = serialize_tools_openai_format(tools)
186        {
187            payload.insert("tools".to_string(), Value::Array(serialized_tools));
188        }
189
190        if let Some(choice) = &request.tool_choice {
191            payload.insert(
192                "tool_choice".to_string(),
193                choice.to_provider_format(PROVIDER_KEY),
194            );
195        }
196
197        if let Some(effort) = request.reasoning_effort {
198            let enable_thinking = effort != crate::config::types::ReasoningEffortLevel::None;
199            payload.insert("enable_thinking".to_owned(), Value::Bool(enable_thinking));
200        }
201
202        if let Some(meta) = &request.metadata
203            && let Some(user_id) = meta.get("user_id").and_then(|v| v.as_str())
204        {
205            payload.insert("user_id".to_owned(), Value::String(user_id.to_owned()));
206        }
207
208        Ok(Value::Object(payload))
209    }
210
211    async fn send_request(&self, payload: &Value) -> Result<reqwest::Response, LLMError> {
212        let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
213
214        self.http_client
215            .post(&url)
216            .header("Authorization", format!("Bearer {}", self.api_key))
217            .json(payload)
218            .send()
219            .await
220            .map_err(|e| LLMError::Network {
221                message: error_display::format_llm_error(
222                    PROVIDER_NAME,
223                    &format!("network error: {}", e),
224                ),
225                metadata: None,
226            })
227    }
228
229    fn serialize_messages(&self, request: &LLMRequest) -> Result<Vec<Value>, LLMError> {
230        serialize_messages_openai_format(request, PROVIDER_KEY)
231    }
232
233    fn parse_response(&self, response_json: Value, model: String) -> Result<LLMResponse, LLMError> {
234        let reasoning_extractor = |message: &Value, choice: &Value| {
235            message
236                .get("reasoning_content")
237                .and_then(extract_reasoning_trace)
238                .or_else(|| {
239                    choice
240                        .get("reasoning_content")
241                        .and_then(extract_reasoning_trace)
242                })
243        };
244
245        parse_response_openai_format(
246            response_json,
247            PROVIDER_NAME,
248            model,
249            self.prompt_cache_enabled,
250            Some(reasoning_extractor),
251        )
252    }
253}
254
255#[async_trait]
256impl LLMProvider for QwenProvider {
257    fn name(&self) -> &str {
258        PROVIDER_KEY
259    }
260
261    fn supports_streaming(&self) -> bool {
262        true
263    }
264
265    fn supports_tools(&self, _model: &str) -> bool {
266        true
267    }
268
269    fn supports_structured_output(&self, _model: &str) -> bool {
270        true
271    }
272
273    fn supports_vision(&self, _model: &str) -> bool {
274        false
275    }
276
277    fn supports_reasoning(&self, model: &str) -> bool {
278        let requested = if model.trim().is_empty() {
279            &self.model
280        } else {
281            model
282        };
283
284        self.model_behavior
285            .as_ref()
286            .and_then(|b| b.model_supports_reasoning)
287            .unwrap_or(false)
288            || requested == models::qwen::DEEPSEEK_V4_FLASH
289            || requested == models::qwen::DEEPSEEK_V4_PRO
290            || requested == models::qwen::GLM_5_1
291    }
292
293    fn supports_reasoning_effort(&self, _model: &str) -> bool {
294        self.model_behavior
295            .as_ref()
296            .and_then(|b| b.model_supports_reasoning_effort)
297            .unwrap_or(false)
298    }
299
300    fn effective_context_size(&self, model: &str) -> usize {
301        let requested = if model.trim().is_empty() {
302            &self.model
303        } else {
304            model
305        };
306        match requested {
307            models::qwen::DEEPSEEK_V4_FLASH | models::qwen::DEEPSEEK_V4_PRO => 1_048_576,
308            models::qwen::GLM_5_1 => 131_072,
309            _ => 131_072,
310        }
311    }
312
313    async fn generate(&self, mut request: LLMRequest) -> Result<LLMResponse, LLMError> {
314        let model = ensure_model(&mut request, &self.model);
315
316        let payload = self.convert_to_qwen_format(&request)?;
317        let response = self.send_request(&payload).await?;
318        let response = handle_openai_http_error(response, PROVIDER_NAME, "QWEN_API_KEY").await?;
319
320        let response_json = parse_json_response(response, PROVIDER_NAME).await?;
321        self.parse_response(response_json, model)
322    }
323
324    async fn stream(&self, mut request: LLMRequest) -> Result<LLMStream, LLMError> {
325        ensure_model(&mut request, &self.model);
326        self.validate_request(&request)?;
327        request.stream = true;
328        let model = request.model.clone();
329
330        let payload = self.convert_to_qwen_format(&request)?;
331        let response = self.send_request(&payload).await?;
332        let response = handle_openai_http_error(response, PROVIDER_NAME, "QWEN_API_KEY").await?;
333
334        Ok(spawn_openai_compatible_stream(
335            response,
336            PROVIDER_NAME,
337            model,
338            Some("reasoning_content"),
339            super::shared::OpenAiDeltaOrder::ReasoningFirst,
340        ))
341    }
342
343    fn supported_models(&self) -> Vec<String> {
344        models::qwen::SUPPORTED_MODELS
345            .iter()
346            .map(|model| model.to_string())
347            .collect()
348    }
349
350    fn validate_request(&self, request: &LLMRequest) -> Result<(), LLMError> {
351        validate_supported_models(
352            request,
353            PROVIDER_NAME,
354            PROVIDER_KEY,
355            models::qwen::SUPPORTED_MODELS,
356        )
357    }
358}
359
360impl_llm_client!(QwenProvider);
vtcode_core/llm/providers/qwen.rs

vtcode_core/llm/providers/
qwen.rs
