Struct ModelProviderConfig 

pub struct ModelProviderConfig {

    pub api_key: Option<String>,
    pub kind: Option<String>,
    pub uri: Option<String>,
    pub model: Option<String>,
    pub fallback: Vec<ModelProviderRef>,
    pub fallback_models: Vec<String>,
    pub temperature: Option<f64>,
    pub timeout_secs: Option<u64>,
    pub extra_headers: HashMap<String, String>,
    pub wire_api: Option<WireApi>,
    pub requires_openai_auth: bool,
    pub max_tokens: Option<u32>,
    pub merge_system_into_user: bool,
    pub provider_extra: Option<Value>,
    pub pricing: HashMap<String, f64>,
    pub native_tools: Option<bool>,
    pub think: Option<bool>,
    pub chat_template_kwargs: Option<Value>,
}

Named model_provider profile definition.

Fields

api_key: Option<String>

Secret API token for this model_provider. Grab it from the model_provider’s dashboard (OpenAI platform, Anthropic console, OpenRouter keys page, etc.). Stored via the OS keyring when possible; never commit it to config.toml directly.

kind: Option<String>

Provider implementation to instantiate for this profile. Use this when a canonical typed slot should run through a compatible implementation, e.g. [providers.models.openai.proxy] kind = "openai-compatible".

uri: Option<String>

Endpoint URI the client hits. Override the family’s default endpoint when pointing at a self-hosted gateway (LiteLLM, vLLM, Ollama), a custom proxy, or any non-standard URL. Leave unset to use the family’s default URI from its ModelEndpoint impl. Set this to the FULL endpoint URL; there is no separate path-suffix field.

model: Option<String>

Model identifier to send with each request: the ID string from the model_provider’s catalog (e.g. gpt-4o, claude-sonnet-4-5, llama-3.3-70b). Must match a model the model_provider actually serves on this account.

fallback: Vec<ModelProviderRef>

Ordered list of other provider aliases to try when every model on this alias has failed. Each entry is a dotted <type>.<alias> reference into providers.models and resolves with its own credentials, endpoint, and model. A fallback never inherits this alias’s key. The walk is depth-first: this alias’s models are exhausted first, then each fallback alias is descended in turn (applying its own fallback_models and fallback). Empty means no provider-level fallback.

fallback_models: Vec<String>

Ordered alternate models to try on THIS provider before falling over to the fallback aliases. Same endpoint, key, and headers as the primary model. Only the model identifier changes. Use this when a provider serves a backup model (e.g. a smaller or older variant) that should be tried before leaving the provider entirely. Empty means only model is tried.

temperature: Option<f64>

Sampling temperature passed to the model. Lower values (0.0–0.3) give deterministic, near-verbatim output, which fits code, routing, summarization. Higher values (0.7–1.2) give more varied output, which fits open-ended chat.

timeout_secs: Option<u64>

HTTP request timeout in seconds. Bump this for slow local model_providers (Ollama on CPU, big local models) or high-latency networks; leave unset otherwise.

extra_headers: HashMap<String, String>

Extra HTTP headers sent with every request. Niche: used for auth bridges, corporate proxies, or custom gateways that demand a tracing header. Most users never touch this; edit config.toml directly if you need it.

wire_api: Option<WireApi>

Wire protocol flavor: responses for OpenAI’s Codex/Responses API, chat_completions for everything else (OpenAI chat, Anthropic, OpenRouter, Groq, local gateways). Auto-selected per model_provider; only override if you’re forcing an unusual combination.

requires_openai_auth: bool

When true, the client pulls credentials from OPENAI_API_KEY or ~/.codex/auth.json instead of the api_key field above. Turn on only for the OpenAI Codex model_provider; leave off for standard API-key model_providers.

max_tokens: Option<u32>

Hard cap on response length in tokens. Most models enforce sensible built-in limits already; leave unset unless you specifically need to clip long outputs for cost or latency reasons.

merge_system_into_user: bool

ModelProvider-specific quirk: fold the system prompt into the first user message instead of sending a separate system role. Only needed for models that reject (or mishandle) a standalone system role, e.g. certain older Mistral variants.

provider_extra: Option<Value>

Extra JSON parameters to include in API requests. Merged at the top level of the request body, allowing provider-specific features (routing, transforms, etc.) without code changes. Example: provider_extra = { model_provider = { only = ["Anthropic"] } }

pricing: HashMap<String, f64>

Per-model pricing for cost tracking, USD per 1M tokens.

Free-form key/value map. Keys are user-defined model identifiers; an optional .input / .output suffix encodes pricing dimension when the operator wants to split rates. A bare key without a suffix is used as a flat per-token rate when neither dimension is specified. Default is empty: cost tracking falls back to “unknown” rates and only token usage is recorded.

Example: pricing = { opus = 15.0, sonnet = 3.0 } Or split: pricing = { "opus.input" = 15.0, "opus.output" = 75.0 }

native_tools: Option<bool>

Override the provider’s default for native tool calling. None (default) honors the provider’s built-in choice. Some(true) forces native tool calls on, Some(false) forces text-fallback. Currently consulted only by the Groq factory, which defaults to text-fallback because llama-family Groq models reject native tool calls with HTTP 400. Setting native_tools = true re-enables native tool calling for Groq models that support it.

think: Option<bool>

Enable or disable chain-of-thought thinking for models that support it (e.g. Qwen3, GLM-4). true turns thinking on, false turns it off. None (default) lets the model decide. Forwarded as enable_thinking in the request body; mirrors the Ollama provider’s think field.

chat_template_kwargs: Option<Value>

Arbitrary key/value pairs forwarded verbatim as chat_template_kwargs in the request body (llama.cpp-specific). Use this to pass model-family template variables that control behaviour not exposed by other fields. Example (Qwen3 thinking suppression): chat_template_kwargs = { enable_thinking = false }

Implementations

impl ModelProviderConfig

pub fn configurable_prefix() -> &'static str

Returns the #[prefix] value for this Configurable struct.

pub fn secret_fields(&self) -> Vec<SecretFieldInfo>

Returns metadata about all #[secret] fields on this struct and nested children.

pub fn secret_field_terminals() -> Vec<&'static str>

Static enumeration of every #[secret] field’s terminal name (snake_case, matching the on-disk TOML key) reachable from this type via #[nested] traversal. Unlike secret_fields(), this requires no instance — the per-struct codegen literals are joined at call time with recursive calls into the inner types’ own secret_field_terminals().

Used by the migration crate’s raw-TOML encrypt walker as the secret-key allowlist. prop_fields()-derived allowlists skip compound (non-Vec) #[secret] fields, so this method is the authoritative source.

pub fn encrypt_secrets(&mut self, store: &SecretStore) -> Result<()>

Encrypt all secret fields in place using the provided store.

pub fn decrypt_secrets(&mut self, store: &SecretStore) -> Result<()>

Decrypt all secret fields in place using the provided store.

pub fn set_secret(&mut self, name: &str, value: String) -> Result<()>

Set a secret field by its full dotted name, dispatching to nested children.

pub fn prop_fields(&self) -> Vec<PropFieldInfo>

Returns metadata about all property fields on this struct and nested children.

pub fn get_prop(&self, name: &str) -> Result<String>

Get a property value by its full dotted name, returning it as a display string.

pub fn set_prop(&mut self, name: &str, value_str: &str) -> Result<()>

Set a property value by its full dotted name, parsing from string.

pub fn prop_is_secret(name: &str) -> bool

Check if a property name refers to a secret field (static, no instance needed).

pub fn init_defaults(&mut self, prefix: Option<&str>) -> Vec<&'static str>

Instantiate None nested sections whose prefix matches. Returns the prefixes that were initialized.

pub fn map_key_sections() -> Vec<MapKeySection>

Enumerate every map-keyed (HashMap<String, T>) and list-shaped (Vec<T>) section discoverable from this Configurable’s tree. The dashboard / CLI consume this to surface “+ Add” affordances without hardcoding the section list.

pub fn nested_section_help(name: &str) -> Option<&'static str>

Help blurb for a #[nested] field on this struct, sourced from the field-level /// docstring. Returns None for unknown names so callers can fall through to a different lookup.

pub fn get_map_keys(&self, section_path: &str) -> Option<Vec<String>>

Return the current alias keys at section_path, or None if the path doesn’t resolve to a map-keyed section in this tree.

pub fn nested_option_entries(&self) -> Vec<NestedOptionEntry>

Snapshot of every #[nested] Option<T> field on this struct as (field_name, is_some) tuples, in declaration order.

field_name is the raw Rust ident (snake_case) — consumers can map to display names via their own table. The schema is the single source of truth: adding a new pub foo: Option<FooConfig> field with #[nested] surfaces here without touching any caller.

pub fn create_map_key( &mut self, section_path: &str, map_key: &str, ) -> Result<bool, String>

Insert a default-valued entry under a map-keyed section, or append to a list-shaped one, with map_key as the new entry’s natural identifier (HashMap key for Map sections; identifier field for List sections).

Returns Ok(true) if a new entry was created, Ok(false) if the entry already existed (idempotent), or Err(reason) if the section path doesn’t resolve to a Map/List in this tree.

pub fn delete_map_key( &mut self, section_path: &str, map_key: &str, ) -> Result<bool, String>

Remove the entry identified by map_key from the map-keyed section at section_path.

Returns Ok(true) if the entry existed and was removed, Ok(false) if it didn’t exist, or Err(reason) if the section path doesn’t resolve.

pub fn rename_map_key( &mut self, section_path: &str, map_key: &str, new_key: &str, ) -> Result<bool, String>

Rename map_key to new_key within the map-keyed section at section_path, preserving the entry’s value.

Returns Ok(true) if renamed, Ok(false) if map_key didn’t exist, or Err(reason) if new_key already exists or the section path doesn’t resolve.

Trait Implementations

impl Clone for ModelProviderConfig

fn clone(&self) -> ModelProviderConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelProviderConfig

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

Formats the value using the given formatter.

impl Default for ModelProviderConfig

fn default() -> ModelProviderConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ModelProviderConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ModelProviderConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl MaskSecrets for ModelProviderConfig

fn mask_secrets(&mut self)

fn restore_secrets_from(&mut self, current: &Self)

impl Serialize for ModelProviderConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.