Struct Config 

pub struct Config {

    pub ui: UiConfig,
    pub tray: TrayConfig,
    pub context: ContextConfig,
    pub anthropic: AnthropicConfig,
    pub anthropic_api: AnthropicApiConfig,
    pub openai: OpenAiConfig,
    pub copilot: CopilotConfig,
    pub zai: ZaiConfig,
    pub openrouter: OpenRouterConfig,
    pub deepseek: DeepseekConfig,
    pub kimi: KimiConfig,
    pub kilo: KiloConfig,
    pub novita: NovitaConfig,
    pub moonshot: MoonshotConfig,
    pub grok: GrokConfig,
    pub supergrok: SuperGrokConfig,
    pub grokbot: GrokbotConfig,
    pub antigravity: AntigravityConfig,
    pub cursor: CursorConfig,
    pub minimax: MinimaxConfig,
    pub kiro: KiroConfig,
    pub nous: NousConfig,
    pub opencode_go: OpenCodeGoConfig,
    pub commandcode: CommandCodeConfig,
    pub ollama: OllamaConfig,
    pub custom: Vec<CustomProviderConfig>,
}

A misspelled section name is silently ignored without this: [openrouer] leaves OpenRouter on its defaults and the user sees the wrong vendor set with no diagnostic. Denying unknown keys is deliberately applied at the section level only — the set of sections is small and stable, whereas denying unknown keys inside every section would hard-fail configs that carry a field from a future or removed version.

Fields

ui: UiConfig

tray: TrayConfig

context: ContextConfig

anthropic: AnthropicConfig

anthropic_api: AnthropicApiConfig

openai: OpenAiConfig

copilot: CopilotConfig

zai: ZaiConfig

openrouter: OpenRouterConfig

deepseek: DeepseekConfig

kimi: KimiConfig

kilo: KiloConfig

novita: NovitaConfig

moonshot: MoonshotConfig

grok: GrokConfig

supergrok: SuperGrokConfig

grokbot: GrokbotConfig

antigravity: AntigravityConfig

cursor: CursorConfig

minimax: MinimaxConfig

kiro: KiroConfig

nous: NousConfig

opencode_go: OpenCodeGoConfig

commandcode: CommandCodeConfig

ollama: OllamaConfig

custom: Vec<CustomProviderConfig>

User-defined providers, one [[custom]] table each.

Implementations

impl Config

pub fn load() -> Result<Self>

Load from ~/.config/ai-usagebar/config.toml. Returns defaults if the file doesn’t exist; errors only on actual parse failures.

pub fn load_from(path: &Path) -> Result<Self>

pub fn enabled_custom(&self) -> impl Iterator<Item = &CustomProviderConfig>

The [[custom]] providers that are switched on, in config order.

pub fn custom_by_id(&self, id: &str) -> Option<&CustomProviderConfig>

A [[custom]] provider by id, enabled or not.

pub fn is_enabled(&self, id: VendorId) -> bool

pub fn api_key_env_for(&self, id: VendorId) -> &str

The environment variable this provider’s API key is read from, honoring a per-vendor api_key_env override; "" for a provider that takes no key. Matching on VendorId rather than on a section name is deliberate: a new key vendor that nobody adds here fails to compile, where a _ => arm over &str sections would silently hand back the wrong default and report the provider as unconfigured for ever.

pub fn inline_api_key(&self, id: VendorId) -> Option<&str>

A non-empty inline api_key from this provider’s config section. An empty string counts as unset, the same way the vendors’ own resolve_api_key treats it.

pub fn enabled_vendors(&self) -> Vec<VendorId>

pub fn validate(&self) -> Result<()>

Validate cross-entry constraints that serde cannot express. Account labels are both CLI selectors and TUI tab identities, so duplicates would make either destination ambiguous.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Config

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

where Config: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Config

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

where __S: Serializer,

Serialize this value into the given Serde serializer.