Struct StepFunProvider 

pub struct StepFunProvider { /* private fields */ }

Implementations

impl StepFunProvider

pub fn new(api_key: String) -> Self

pub fn with_model(api_key: String, model: String) -> Self

pub fn new_with_client( api_key: String, model: String, http_client: Client, base_url: String, _timeouts: TimeoutsConfig, ) -> Self

pub fn from_config( api_key: Option<String>, model: Option<String>, base_url: Option<String>, _prompt_cache: Option<PromptCachingConfig>, timeouts: Option<TimeoutsConfig>, _anthropic: Option<AnthropicConfig>, model_behavior: Option<ModelConfig>, ) -> Self

Trait Implementations

impl LLMClient for StepFunProvider

fn generate<'life0, 'life1, 'async_trait>( &'life0 mut self, prompt: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<LLMResponse, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn model_id(&self) -> &str

impl LLMProvider for StepFunProvider

fn name(&self) -> &str

Provider name (e.g., “gemini”, “openai”, “anthropic”)

fn supports_streaming(&self) -> bool

Whether the provider has native streaming support

fn supports_tools(&self, _model: &str) -> bool

Whether the provider supports structured tool calling for the given model

fn supports_structured_output(&self, _model: &str) -> bool

Whether the provider supports structured output (JSON schema guarantees)

fn supports_vision(&self, _model: &str) -> bool

Whether the provider supports vision (image analysis) for given model

fn supports_reasoning(&self, model: &str) -> bool

Whether the provider surfaces structured reasoning traces for the given model

fn supports_reasoning_effort(&self, model: &str) -> bool

Whether the provider accepts configurable reasoning effort for the model

fn effective_context_size(&self, model: &str) -> usize

Get the effective context window size for a model

fn generate<'life0, 'async_trait>( &'life0 self, request: LLMRequest, ) -> Pin<Box<dyn Future<Output = Result<LLMResponse, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Generate completion

fn stream<'life0, 'async_trait>( &'life0 self, request: LLMRequest, ) -> Pin<Box<dyn Future<Output = Result<LLMStream, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stream completion (optional)

fn supported_models(&self) -> Vec<String>

Get supported models

fn validate_request(&self, request: &LLMRequest) -> Result<(), LLMError>

Validate request for this provider

fn backend_kind(&self) -> BackendKind

The canonical backend kind for this provider.

fn supports_non_streaming(&self, _model: &str) -> bool

Whether the provider can service non-streaming generation requests for the model.

fn supports_parallel_tool_config(&self, _model: &str) -> bool

Whether the provider understands parallel tool configuration payloads

fn supports_context_caching(&self, _model: &str) -> bool

Whether the provider supports prompt/context caching

fn supports_responses_compaction(&self, _model: &str) -> bool

Whether the provider supports Responses API server-side compaction.

fn supports_context_edits(&self, _model: &str) -> bool

Whether the provider supports provider-native context editing such as tool-result clearing.

fn supports_manual_openai_compaction(&self, _model: &str) -> bool

Whether the provider supports the interactive manual /compact command path.

fn manual_openai_compaction_unavailable_message(&self, model: &str) -> String

Explain why the interactive manual /compact command path is unavailable.

fn compact_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _model: &'life1 str, _history: &'life2 [Message], ) -> Pin<Box<dyn Future<Output = Result<Vec<Message>, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Compact conversation history using provider-native Responses /compact support when available.

fn compact_history_with_options<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _model: &'life1 str, _history: &'life2 [Message], _options: &'life3 ResponsesCompactionOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<Message>, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Compact conversation history with standalone Responses compaction options.

fn stream_normalized<'life0, 'async_trait>( &'life0 self, request: LLMRequest, ) -> Pin<Box<dyn Future<Output = Result<LLMNormalizedStream, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Normalized streaming contract layered on top of the legacy provider stream.

fn start_copilot_prompt_session<'a>( &'a self, _request: LLMRequest, _tools: &'a [ToolDefinition], ) -> Option<CopilotPromptSessionFuture<'a>>

Provider-specific streaming path that can service interactive runtime requests while the stream is active. Copilot uses this to bridge ACP tool calls and permission prompts back into VT Code’s turn runtime.

fn get_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<BalanceInfo>, LLMError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch account balance for this provider, if supported.