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 deepinfra: DeepInfraConfig,
    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 orcarouter: OrcaRouterConfig,
    pub modelstudio: ModelStudioConfig,
    pub lyceum: LyceumConfig,
    pub devin: DevinConfig,
    pub notifications: NotificationsConfig,
    pub custom: Vec<CustomProviderConfig>,
    pub cline: ClineConfig,
}

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

deepinfra: DeepInfraConfig

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

orcarouter: OrcaRouterConfig

modelstudio: ModelStudioConfig

lyceum: LyceumConfig

devin: DevinConfig

notifications: NotificationsConfig

Quota-threshold desktop notifications ([notifications]).

custom: Vec<CustomProviderConfig>

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

cline: ClineConfig

Implementations

impl Config

pub const API_KEY_ACCOUNT_VENDORS: [VendorId; 11]

The API-key vendors that take a [[<vendor>.accounts]] array — OpenRouter’s (#221), generalized. Kimi is left out on purpose: its fallback is the Kimi Code CLI’s single OAuth login, not a key.

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 api_key_accounts(&self, id: VendorId) -> Option<&[ApiKeyAccount]>

The named [[<vendor>.accounts]] array, or None for a vendor that has no such array (see Self::API_KEY_ACCOUNT_VENDORS).

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

Whether the default key keeps its tab next to the named accounts. true for every vendor without an accounts array.

pub fn resolve_account_api_key_for( &self, id: VendorId, label: Option<&str>, ) -> Result<String>

The default key, or one named [[<vendor>.accounts]] key, for a vendor in Self::API_KEY_ACCOUNT_VENDORS. The default path is exactly the single-key resolution each vendor always had, error text included. A label for a vendor without the array fails loudly rather than falling back to the default key, which would show the wrong account’s usage.

pub fn openrouter_management_key(&self, label: Option<&str>) -> Option<String>

The optional OpenRouter management key for the default or a named account. None means none is configured, in which case the caller skips the /api/v1/activity request rather than firing a doomed 401 — the regular inference key is never sent there. A named account only resolves a management key when it names its own management_api_key_env; it never inherits the default account’s.

pub fn display_prefs(&self, vendor: VendorId) -> DisplayPrefs

Bar-number settings for one vendor.

Only the prepaid-balance vendors declare these; everything else keeps the quota shape (DisplayPrefs::default) and is unaffected.

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

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() -> Self

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.