Enum ProviderConfig 

pub enum ProviderConfig {
    OpenAI {
        api_key: Option<String>,
        api_endpoint: Option<String>,
        auth: Option<ProviderAuth>,
    },
    Anthropic {
        api_key: Option<String>,
        api_endpoint: Option<String>,
        access_token: Option<String>,
        auth: Option<ProviderAuth>,
    },
    Gemini {
        api_key: Option<String>,
        api_endpoint: Option<String>,
        auth: Option<ProviderAuth>,
    },
    Custom {
        api_key: Option<String>,
        api_endpoint: String,
        auth: Option<ProviderAuth>,
    },
    Stakpak {
        api_key: Option<String>,
        api_endpoint: Option<String>,
        auth: Option<ProviderAuth>,
    },
    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"

[profiles.myprofile.providers.openai.auth]
type = "api"
key = "sk-..."

[profiles.myprofile.providers.anthropic]
type = "anthropic"

[profiles.myprofile.providers.anthropic.auth]
type = "oauth"
access = "eyJ..."
refresh = "eyJ..."
expires = 1735600000000
name = "Claude Max"

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

Variants

OpenAI

OpenAI provider configuration

Fields

api_key: Option<String>

Legacy API key field (prefer auth field)

api_endpoint: Option<String>

auth: Option<ProviderAuth>

Authentication credentials (preferred over api_key)

Anthropic

Anthropic provider configuration

Fields

api_key: Option<String>

Legacy API key field (prefer auth field)

api_endpoint: Option<String>

access_token: Option<String>

Legacy OAuth access token (prefer auth field with OAuth type)

auth: Option<ProviderAuth>

Authentication credentials (preferred over api_key/access_token)

Gemini

Google Gemini provider configuration

Fields

api_key: Option<String>

Legacy API key field (prefer auth field)

api_endpoint: Option<String>

auth: Option<ProviderAuth>

Authentication credentials (preferred over api_key)

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:
model = "offline/llama3"

Fields

api_key: Option<String>

Legacy API key field (prefer auth field)

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”)

auth: Option<ProviderAuth>

Authentication credentials (preferred over api_key)

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_endpoint = "https://apiv2.stakpak.dev"  # optional, this is the default

[profiles.myprofile.providers.stakpak.auth]
type = "api"
key = "your-stakpak-api-key"

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

Fields

api_key: Option<String>

Legacy API key field (prefer auth field) Note: This field is optional when using auth

api_endpoint: Option<String>

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

auth: Option<ProviderAuth>

Authentication credentials (preferred over api_key)

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 (checks auth field first, then legacy api_key)

pub fn get_auth(&self) -> Option<ProviderAuth>

Get resolved authentication credentials.

Resolution order:

1. auth field (preferred)
2. Legacy api_key field (converted to ProviderAuth::Api)
3. Legacy access_token field for Anthropic (converted to ProviderAuth with access token)

pub fn set_auth(&mut self, auth: ProviderAuth)

Set authentication credentials on this provider config.

Also clears any legacy credential fields (api_key, access_token) so they don’t shadow the new auth field on future reads.

pub fn clear_auth(&mut self)

Clear authentication credentials from this provider config.

Clears both the auth field and any legacy credential fields (api_key, access_token) to ensure credentials are fully removed.

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

Get the API endpoint if set

pub fn set_api_endpoint(&mut self, endpoint: Option<String>)

Set the API endpoint for providers that support it.

For Custom, None is ignored because custom providers require an endpoint. For Bedrock, this is a no-op.

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

Get the access token (Anthropic only)

Checks the auth field first for OAuth access token, then falls back to the legacy access_token field.

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

Create an OpenAI provider config (legacy, uses api_key field)

pub fn openai_with_auth(auth: ProviderAuth) -> Self

Create an OpenAI provider config with auth

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

Create an Anthropic provider config (legacy, uses api_key/access_token fields)

pub fn anthropic_with_auth(auth: ProviderAuth) -> Self

Create an Anthropic provider config with auth

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

Create a Gemini provider config (legacy, uses api_key field)

pub fn gemini_with_auth(auth: ProviderAuth) -> Self

Create a Gemini provider config with auth

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

Create a custom provider config (legacy, uses api_key field)

pub fn custom_with_auth(api_endpoint: String, auth: ProviderAuth) -> Self

Create a custom provider config with auth

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

Create a Stakpak provider config (legacy, uses api_key field)

pub fn stakpak_with_auth( auth: ProviderAuth, api_endpoint: Option<String>, ) -> Self

Create a Stakpak provider config with auth

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)

pub fn empty_for_provider(provider_name: &str) -> Option<Self>

Create an empty provider config for a given provider name.

Used during migration when we need to create a provider config to attach auth credentials to.

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