Struct ModelProviderConfig 

pub struct ModelProviderConfig {

    pub api_key: Option<String>,
    pub kind: Option<String>,
    pub uri: Option<String>,
    pub model: Option<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.

temperature: Option<f64>

Sampling temperature passed to the model. Lower values (0.0–0.3) give deterministic, near-verbatim output — fits code, routing, summarization. Higher values (0.7–1.2) give more varied output — 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.