vtcode_core/llm/providers/
stepfun.rs1use async_stream::try_stream;
2use async_trait::async_trait;
3use reqwest::Client as HttpClient;
4use serde_json::{Map, Value};
5
6use crate::config::TimeoutsConfig;
7use crate::config::constants::{env_vars, models, urls};
8use crate::config::core::{AnthropicConfig, ModelConfig, PromptCachingConfig};
9use crate::config::types::ReasoningEffortLevel;
10use crate::llm::error_display;
11use crate::llm::provider::{
12 LLMError, LLMProvider, LLMRequest, LLMResponse, LLMStream, LLMStreamEvent,
13};
14
15use super::common::{
16 ensure_model, impl_llm_client, map_finish_reason_common, override_base_url,
17 parse_json_response, parse_response_openai_format, resolve_model,
18 serialize_messages_openai_format, serialize_tools_openai_format, validate_supported_models,
19};
20use super::error_handling::handle_openai_http_error;
21use super::extract_reasoning_trace;
22
23const PROVIDER_NAME: &str = "StepFun";
24const PROVIDER_KEY: &str = "stepfun";
25const PRIMARY_API_KEY_ENV: &str = "STEPFUN_API_KEY";
26const LEGACY_API_KEY_ENV: &str = "STEP_API_KEY";
27
28pub struct StepFunProvider {
29 api_key: String,
30 http_client: HttpClient,
31 base_url: String,
32 model: String,
33 model_behavior: Option<ModelConfig>,
34}
35
36impl StepFunProvider {
37 pub fn new(api_key: String) -> Self {
38 Self::with_model_internal(
39 api_key,
40 models::stepfun::DEFAULT_MODEL.to_string(),
41 None,
42 None,
43 None,
44 )
45 }
46
47 pub fn with_model(api_key: String, model: String) -> Self {
48 Self::with_model_internal(api_key, model, None, None, None)
49 }
50
51 pub fn new_with_client(
52 api_key: String,
53 model: String,
54 http_client: reqwest::Client,
55 base_url: String,
56 _timeouts: TimeoutsConfig,
57 ) -> Self {
58 Self {
59 api_key,
60 http_client,
61 base_url,
62 model,
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(|key| !key.trim().is_empty())
78 .or_else(|| std::env::var(PRIMARY_API_KEY_ENV).ok())
79 .or_else(|| std::env::var(LEGACY_API_KEY_ENV).ok())
80 .unwrap_or_default();
81
82 Self::with_model_internal(
83 api_key_value,
84 resolve_model(model, models::stepfun::DEFAULT_MODEL),
85 base_url,
86 timeouts,
87 model_behavior,
88 )
89 }
90
91 fn with_model_internal(
92 api_key: String,
93 model: String,
94 base_url: Option<String>,
95 timeouts: Option<TimeoutsConfig>,
96 model_behavior: Option<ModelConfig>,
97 ) -> Self {
98 use crate::llm::http_client::HttpClientFactory;
99
100 let timeouts = timeouts.unwrap_or_default();
101
102 Self {
103 api_key,
104 http_client: HttpClientFactory::for_llm(&timeouts),
105 base_url: override_base_url(
106 urls::STEPFUN_API_BASE,
107 base_url,
108 Some(env_vars::STEPFUN_BASE_URL),
109 ),
110 model,
111 model_behavior,
112 }
113 }
114
115 fn reasoning_effort_value(effort: ReasoningEffortLevel) -> Option<&'static str> {
116 match effort {
117 ReasoningEffortLevel::None => None,
118 ReasoningEffortLevel::Minimal | ReasoningEffortLevel::Low => Some("low"),
119 ReasoningEffortLevel::Medium => Some("medium"),
120 ReasoningEffortLevel::High
121 | ReasoningEffortLevel::XHigh
122 | ReasoningEffortLevel::Max => Some("high"),
123 }
124 }
125
126 fn is_reasoning_enabled(request: &LLMRequest) -> bool {
127 request
128 .reasoning_effort
129 .is_some_and(|effort| effort != ReasoningEffortLevel::None)
130 }
131
132 fn convert_to_stepfun_format(&self, request: &LLMRequest) -> Result<Value, LLMError> {
133 let mut payload = Map::with_capacity(10);
134 payload.insert("model".to_owned(), Value::String(request.model.clone()));
135
136 let mut messages = serialize_messages_openai_format(request, PROVIDER_KEY)?;
137 if let Some(system_prompt) = &request.system_prompt {
138 let trimmed = system_prompt.trim();
139 if !trimmed.is_empty() {
140 messages.insert(
141 0,
142 serde_json::json!({ "role": "system", "content": trimmed }),
143 );
144 }
145 }
146 payload.insert("messages".to_owned(), Value::Array(messages));
147
148 if let Some(max_tokens) = request.max_tokens {
149 payload.insert(
150 "max_tokens".to_owned(),
151 Value::Number(serde_json::Number::from(max_tokens as u64)),
152 );
153 }
154
155 if !Self::is_reasoning_enabled(request) {
156 if let Some(temperature) = request.temperature {
157 payload.insert(
158 "temperature".to_owned(),
159 Value::Number(super::common::float_to_json_number(temperature)?),
160 );
161 }
162
163 if let Some(top_p) = request.top_p {
164 payload.insert(
165 "top_p".to_owned(),
166 Value::Number(super::common::float_to_json_number(top_p)?),
167 );
168 }
169 }
170
171 if request.stream {
172 payload.insert("stream".to_owned(), Value::Bool(true));
173 }
174
175 if let Some(tools) = &request.tools
176 && let Some(serialized_tools) = serialize_tools_openai_format(tools)
177 {
178 payload.insert("tools".to_owned(), Value::Array(serialized_tools));
179 }
180
181 if let Some(choice) = &request.tool_choice {
182 payload.insert(
183 "tool_choice".to_owned(),
184 choice.to_provider_format(PROVIDER_KEY),
185 );
186 }
187
188 if let Some(effort) = request.reasoning_effort
189 && let Some(mapped) = Self::reasoning_effort_value(effort)
190 {
191 payload.insert(
192 "reasoning_effort".to_owned(),
193 Value::String(mapped.to_string()),
194 );
195 }
196
197 Ok(Value::Object(payload))
198 }
199}
200
201#[async_trait]
202impl LLMProvider for StepFunProvider {
203 fn name(&self) -> &str {
204 PROVIDER_KEY
205 }
206
207 fn supports_streaming(&self) -> bool {
208 true
209 }
210
211 fn supports_tools(&self, _model: &str) -> bool {
212 true
213 }
214
215 fn supports_structured_output(&self, _model: &str) -> bool {
216 true
217 }
218
219 fn supports_vision(&self, _model: &str) -> bool {
220 true
221 }
222
223 fn supports_reasoning(&self, model: &str) -> bool {
224 let requested = if model.trim().is_empty() {
225 &self.model
226 } else {
227 model
228 };
229
230 self.model_behavior
231 .as_ref()
232 .and_then(|behavior| behavior.model_supports_reasoning)
233 .unwrap_or(false)
234 || models::stepfun::REASONING_MODELS.contains(&requested)
235 }
236
237 fn supports_reasoning_effort(&self, model: &str) -> bool {
238 let requested = if model.trim().is_empty() {
239 &self.model
240 } else {
241 model
242 };
243
244 self.model_behavior
245 .as_ref()
246 .and_then(|behavior| behavior.model_supports_reasoning_effort)
247 .unwrap_or(false)
248 || models::stepfun::REASONING_MODELS.contains(&requested)
249 }
250
251 fn effective_context_size(&self, model: &str) -> usize {
252 let requested = if model.trim().is_empty() {
253 &self.model
254 } else {
255 model
256 };
257
258 match requested {
259 models::stepfun::STEP_3_7_FLASH => 262_144,
260 _ => 262_144,
261 }
262 }
263
264 async fn generate(&self, mut request: LLMRequest) -> Result<LLMResponse, LLMError> {
265 let model = ensure_model(&mut request, &self.model);
266
267 let payload = self.convert_to_stepfun_format(&request)?;
268 let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
269
270 let response = self
271 .http_client
272 .post(&url)
273 .bearer_auth(&self.api_key)
274 .json(&payload)
275 .send()
276 .await
277 .map_err(|error| LLMError::Network {
278 message: error_display::format_llm_error(
279 PROVIDER_NAME,
280 &format!("network error: {error}"),
281 ),
282 metadata: None,
283 })?;
284
285 let response =
286 handle_openai_http_error(response, PROVIDER_NAME, PRIMARY_API_KEY_ENV).await?;
287 let response_json = parse_json_response(response, PROVIDER_NAME).await?;
288
289 let reasoning_extractor = |message: &Value, choice: &Value| {
290 message
291 .get("reasoning")
292 .and_then(extract_reasoning_trace)
293 .or_else(|| choice.get("reasoning").and_then(extract_reasoning_trace))
294 };
295
296 parse_response_openai_format(
297 response_json,
298 PROVIDER_NAME,
299 model,
300 false,
301 Some(reasoning_extractor),
302 )
303 }
304
305 async fn stream(&self, mut request: LLMRequest) -> Result<LLMStream, LLMError> {
306 ensure_model(&mut request, &self.model);
307 self.validate_request(&request)?;
308 request.stream = true;
309 let model = request.model.clone();
310
311 let payload = self.convert_to_stepfun_format(&request)?;
312 let url = format!("{}/chat/completions", self.base_url.trim_end_matches('/'));
313
314 let response = self
315 .http_client
316 .post(&url)
317 .bearer_auth(&self.api_key)
318 .json(&payload)
319 .send()
320 .await
321 .map_err(|error| LLMError::Network {
322 message: error_display::format_llm_error(
323 PROVIDER_NAME,
324 &format!("network error: {error}"),
325 ),
326 metadata: None,
327 })?;
328
329 let response =
330 handle_openai_http_error(response, PROVIDER_NAME, PRIMARY_API_KEY_ENV).await?;
331
332 let bytes_stream = response.bytes_stream();
333 let (event_tx, event_rx) =
334 tokio::sync::mpsc::unbounded_channel::<Result<LLMStreamEvent, LLMError>>();
335 let tx = event_tx.clone();
336
337 let model_clone = model.clone();
338 tokio::spawn(async move {
339 let mut aggregator =
340 crate::llm::providers::shared::StreamAggregator::new(model_clone.clone());
341
342 let result = crate::llm::providers::shared::process_openai_stream(
343 bytes_stream,
344 PROVIDER_NAME,
345 model_clone,
346 |value| {
347 if let Some(choices) =
348 value.get("choices").and_then(|choices| choices.as_array())
349 && let Some(choice) = choices.first()
350 {
351 if let Some(delta) = choice.get("delta") {
352 if let Some(reasoning) = delta.get("reasoning").and_then(|v| v.as_str())
353 && let Some(delta) = aggregator.handle_reasoning(reasoning)
354 {
355 let _ = tx.send(Ok(LLMStreamEvent::Reasoning { delta }));
356 }
357
358 if let Some(content) = delta.get("content").and_then(|v| v.as_str()) {
359 for event in aggregator.handle_content(content) {
360 let _ = tx.send(Ok(event));
361 }
362 }
363
364 if let Some(tool_calls) =
365 delta.get("tool_calls").and_then(|calls| calls.as_array())
366 {
367 aggregator.handle_tool_calls(tool_calls);
368 }
369 }
370
371 if let Some(reason) = choice.get("finish_reason").and_then(|v| v.as_str()) {
372 aggregator.set_finish_reason(map_finish_reason_common(reason));
373 }
374 }
375
376 if let Some(_usage_value) = value.get("usage")
377 && let Some(usage) =
378 crate::llm::providers::common::parse_usage_openai_format(&value, false)
379 {
380 aggregator.set_usage(usage);
381 }
382 Ok(())
383 },
384 )
385 .await;
386
387 match result {
388 Ok(_) => {
389 let response = aggregator.finalize();
390 let _ = tx.send(Ok(LLMStreamEvent::Completed {
391 response: Box::new(response),
392 }));
393 }
394 Err(error) => {
395 let _ = tx.send(Err(error));
396 }
397 }
398 });
399
400 let stream = try_stream! {
401 let mut receiver = event_rx;
402 while let Some(event) = receiver.recv().await {
403 yield event?;
404 }
405 };
406
407 Ok(Box::pin(stream))
408 }
409
410 fn supported_models(&self) -> Vec<String> {
411 models::stepfun::SUPPORTED_MODELS
412 .iter()
413 .map(|model| model.to_string())
414 .collect()
415 }
416
417 fn validate_request(&self, request: &LLMRequest) -> Result<(), LLMError> {
418 validate_supported_models(
419 request,
420 PROVIDER_NAME,
421 PROVIDER_KEY,
422 models::stepfun::SUPPORTED_MODELS,
423 )
424 }
425}
426
427impl_llm_client!(StepFunProvider);
428
429#[cfg(test)]
430mod tests {
431 use super::StepFunProvider;
432 use crate::config::constants::models;
433 use crate::config::types::ReasoningEffortLevel;
434 use crate::llm::provider::{LLMRequest, Message};
435
436 #[test]
437 fn payload_maps_reasoning_effort() {
438 let provider = StepFunProvider::new("test-key".to_string());
439 let payload = provider
440 .convert_to_stepfun_format(&LLMRequest {
441 model: models::stepfun::STEP_3_7_FLASH.to_string(),
442 messages: vec![Message::user("hello".to_string())],
443 reasoning_effort: Some(ReasoningEffortLevel::XHigh),
444 ..Default::default()
445 })
446 .expect("payload should be valid");
447
448 assert_eq!(
449 payload
450 .get("reasoning_effort")
451 .and_then(|value| value.as_str()),
452 Some("high")
453 );
454 assert!(payload.get("temperature").is_none());
455 assert!(payload.get("top_p").is_none());
456 }
457}