Struct OpenCodeGoProvider 

pub struct OpenCodeGoProvider { /* private fields */ }

Implementations

impl OpenCodeGoProvider

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 OpenCodeGoProvider

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 OpenCodeGoProvider

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_non_streaming(&self, _model: &str) -> bool

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

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

Whether the provider surfaces structured reasoning traces for the given model

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_context_caching(&self, model: &str) -> bool

Whether the provider supports prompt/context caching

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

Whether the provider supports vision (image analysis) for given 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_reasoning_effort(&self, _model: &str) -> bool

Whether the provider accepts configurable reasoning effort for the model

fn supported_reasoning_efforts(&self, model: &str) -> &'static [&'static str]

Exact levels accepted by this route; providers may override catalog metadata.

fn sampling_overrides(&self, _model: &str) -> SamplingOverrides

Provider/model-specific sampling parameter overrides.

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

Whether the provider understands parallel tool configuration payloads

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

Whether the provider supports Responses API server-side compaction.

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

Whether the request path can enforce a provider-native allowed_tools subset.

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

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

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

Whether the selected provider/model can carry Anthropic’s native turn-scoped system-message lifecycle field on the wire.

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

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

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

Whether the provider supports threshold-triggered inline compaction via request fields (Anthropic compact_20260112).

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

Explain why the --native-only manual /compact 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.