Struct GeminiProvider 

pub struct GeminiProvider { /* private fields */ }

Implementations

impl GeminiProvider

pub fn supports_caching(model: &str) -> bool

Check if model supports context caching

pub fn supports_code_execution(model: &str) -> bool

Check if model supports code execution

pub fn max_input_tokens(model: &str) -> usize

Get maximum input token limit for a model

pub fn max_output_tokens(model: &str) -> usize

Get maximum output token limit for a model

impl GeminiProvider

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, prompt_cache_enabled: bool, prompt_cache_settings: GeminiPromptCacheSettings, ) -> 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 GeminiProvider

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 GeminiProvider

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

Whether the provider accepts configurable reasoning effort for the model

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

Whether the provider supports prompt/context caching

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

Whether the provider supports structured tool calling for the given model

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

Whether the provider understands parallel tool configuration payloads

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_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 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.