Enum ProviderConfig 

pub enum ProviderConfig {
    OpenAI {
        api_key: Option<String>,
        api_endpoint: Option<String>,
    },
    Anthropic {
        api_key: Option<String>,
        api_endpoint: Option<String>,
        access_token: Option<String>,
    },
    Gemini {
        api_key: Option<String>,
        api_endpoint: Option<String>,
    },
    Custom {
        api_key: Option<String>,
        api_endpoint: String,
    },
    Stakpak {
        api_key: String,
        api_endpoint: Option<String>,
    },
    Bedrock {
        region: String,
        profile_name: Option<String>,
    },
}

Unified provider configuration enum

All provider configurations are stored in a HashMap<String, ProviderConfig> where the key is the provider name and becomes the model prefix for routing.

Provider Key = Model Prefix

The key used in the HashMap becomes the prefix used in model names:

• Config key: providers.offline
• Model usage: offline/llama3
• Routing: finds offline provider, sends llama3 to API

Example TOML

[profiles.myprofile.providers.openai]
type = "openai"
api_key = "sk-..."

[profiles.myprofile.providers.anthropic]
type = "anthropic"
api_key = "sk-ant-..."
access_token = "oauth-token"

[profiles.myprofile.providers.offline]
type = "custom"
api_endpoint = "http://localhost:11434/v1"

Variants

OpenAI

OpenAI provider configuration

Fields

api_key: Option<String>

api_endpoint: Option<String>

Anthropic

Anthropic provider configuration

Fields

api_key: Option<String>

api_endpoint: Option<String>

access_token: Option<String>

OAuth access token (for Claude subscription)

Gemini

Google Gemini provider configuration

Fields

api_key: Option<String>

api_endpoint: Option<String>

Custom

Custom OpenAI-compatible provider (Ollama, vLLM, etc.)

The provider key in the config becomes the model prefix. For example, if configured as providers.offline, use models as:

• offline/llama3 - passes llama3 to the API
• offline/anthropic/claude-opus - passes anthropic/claude-opus to the API

Example TOML

[profiles.myprofile.providers.offline]
type = "custom"
api_endpoint = "http://localhost:11434/v1"

# Then use models as:
smart_model = "offline/llama3"
eco_model = "offline/phi3"

Fields

api_key: Option<String>

api_endpoint: String

API endpoint URL (required for custom providers) Use the base URL as required by your provider (e.g., “http://localhost:11434/v1”)

Stakpak

Stakpak provider configuration

Routes inference through Stakpak’s unified API, which provides:

• Access to multiple LLM providers via a single endpoint
• Usage tracking and billing
• Session management and checkpoints

Example TOML

[profiles.myprofile.providers.stakpak]
type = "stakpak"
api_key = "your-stakpak-api-key"
api_endpoint = "https://apiv2.stakpak.dev"  # optional, this is the default

# Then use models as:
smart_model = "stakpak/anthropic/claude-sonnet-4-5-20250929"

Fields

api_key: String

Stakpak API key (required)

api_endpoint: Option<String>

API endpoint URL (default: https://apiv2.stakpak.dev)

Bedrock

AWS Bedrock provider configuration

Uses AWS credential chain for authentication (no API key needed). Supports env vars, shared credentials, SSO, and instance roles.

Example TOML

[profiles.myprofile.providers.amazon-bedrock]
type = "amazon-bedrock"
region = "us-east-1"
profile_name = "my-aws-profile"  # optional

# Then use models as (friendly aliases work):
model = "amazon-bedrock/claude-sonnet-4-5"

Fields

region: String

AWS region (e.g., “us-east-1”)

profile_name: Option<String>

Optional AWS named profile (from ~/.aws/config)

Implementations

impl ProviderConfig

pub fn provider_type(&self) -> &'static str

Get the provider type name

pub fn api_key(&self) -> Option<&str>

Get the API key if set

pub fn api_endpoint(&self) -> Option<&str>

Get the API endpoint if set

pub fn access_token(&self) -> Option<&str>

Get the access token (Anthropic only)

pub fn openai(api_key: Option<String>) -> Self

Create an OpenAI provider config

pub fn anthropic(api_key: Option<String>, access_token: Option<String>) -> Self

Create an Anthropic provider config

pub fn gemini(api_key: Option<String>) -> Self

Create a Gemini provider config

pub fn custom(api_endpoint: String, api_key: Option<String>) -> Self

Create a custom provider config

pub fn stakpak(api_key: String, api_endpoint: Option<String>) -> Self

Create a Stakpak provider config

pub fn bedrock(region: String, profile_name: Option<String>) -> Self

Create a Bedrock provider config

pub fn region(&self) -> Option<&str>

Get the AWS region (Bedrock only)

pub fn profile_name(&self) -> Option<&str>

Get the AWS profile name (Bedrock only)

Trait Implementations

impl Clone for ProviderConfig

fn clone(&self) -> ProviderConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProviderConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProviderConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProviderConfig

fn eq(&self, other: &ProviderConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProviderConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProviderConfig