Struct ModelConfig 

pub struct ModelConfig {
    pub model: String,
    pub temperature: f32,
    pub max_tokens: usize,
    pub system_prompt: Option<String>,
    pub dynamic_system_suffix: Option<String>,
    pub reasoning: ReasoningLevel,
    pub hide_reasoning_trace: bool,
    pub backend_options: HashMap<String, HashMap<String, String>>,
    pub tools: Vec<Value>,
}

Unified model configuration

Fields

model: String

Model identifier (provider/model or just model name) Examples: “ollama/qwen3-coder:30b”, “qwen3-coder:30b”, “gpt-4”

temperature: f32

Temperature (0.0-2.0, controls randomness)

max_tokens: usize

Maximum tokens to generate

system_prompt: Option<String>

System prompt override (None = use default)

dynamic_system_suffix: Option<String>

Project-specific instructions appended to the system prompt (Step 5h: MERMAID.md content). Runtime-only — never persisted. On Anthropic, this gets its own cache_control block so the static base stays cached even when the dynamic suffix changes. On other adapters, it’s concatenated onto the system prompt with a --- separator.

reasoning: ReasoningLevel

Requested reasoning depth. Adapters map this to provider-native shapes via nearest_effort() against ModelCapabilities ::supports_reasoning. Defaults to Medium — the OpenAI / Anthropic / Gemini default and the level that produces useful chain-of-thought without burning excessive latency for routine prompts.

hide_reasoning_trace: bool

Hide reasoning traces from the user-facing stream while still allowing the model to reason server-side. Maps to Ollama’s --hidethinking semantics and Anthropic’s thinking.display: "hidden". Internal plumbing; the reducer currently never sets this (no UI toggle) but the adapter pipeline honors it when a future toggle lands.

backend_options: HashMap<String, HashMap<String, String>>

Backend-specific options (provider name -> key/value pairs) Example: {“ollama”: {“num_gpu”: “10”, “num_ctx”: “8192”}}

tools: Vec<Value>

Tool definitions the model sees, already translated into OpenAI-compatible {type: "function", function: {name, description, parameters}} shape. Runtime-only. Populated by provider wrappers from ChatRequest.tools — adapters iterate this directly, no internal registry.

Implementations

impl ModelConfig

pub fn get_backend_option(&self, backend: &str, key: &str) -> Option<&String>

Get a backend-specific option

pub fn get_backend_option_i32(&self, backend: &str, key: &str) -> Option<i32>

Get backend option as integer

pub fn get_backend_option_bool(&self, backend: &str, key: &str) -> Option<bool>

Get backend option as boolean

pub fn set_backend_option( &mut self, backend: String, key: String, value: String, )

Set a backend-specific option

pub fn combined_system_prompt(&self) -> Option<String>

Build the system-prompt string for adapters that don’t support per-block cache control (Gemini, OpenAI-compat, Ollama). Joins the static base and the dynamic suffix (MERMAID.md content) with a --- separator. Anthropic’s adapter doesn’t use this helper — it emits two separately-cached typed-text blocks.

Returns None only when both fields are empty/unset.

pub fn from_app_config(config: &Config, model_id: &str) -> Self

Build a ModelConfig from user-facing app Config for a given model ID.

Centralizes the wiring of temperature, max_tokens, reasoning level, and Ollama hardware options that was previously scattered across orchestrator.rs and model.rs.

Reasoning resolution: per-model preference (config.reasoning_per_model[model_id]) wins, then falls back to the global default_model.reasoning. Set per-model via Alt+T or /reasoning <level> while using the model in question.

pub fn ollama_options(&self) -> OllamaOptions

Extract Ollama-specific options

Trait Implementations

impl Clone for ModelConfig

fn clone(&self) -> ModelConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModelConfig

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

Formats the value using the given formatter.

impl Default for ModelConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ModelConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ModelConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.