Struct Config 

pub struct Config {

    pub agent: AgentConfig,
    pub llm: LlmConfig,
    pub skills: SkillsConfig,
    pub memory: MemoryConfig,
    pub telegram: Option<TelegramConfig>,
    pub discord: Option<DiscordConfig>,
    pub slack: Option<SlackConfig>,
    pub tools: ToolsConfig,
    pub a2a: A2aServerConfig,
    pub mcp: McpConfig,
    pub index: IndexConfig,
    pub vault: VaultConfig,
    pub security: SecurityConfig,
    pub timeouts: TimeoutConfig,
    pub cost: CostConfig,
    pub gateway: GatewayConfig,
    pub daemon: DaemonConfig,
    pub scheduler: SchedulerConfig,
    pub tui: TuiConfig,
    pub acp: AcpConfig,
    pub agents: SubAgentConfig,
    pub orchestration: OrchestrationConfig,
    pub classifiers: ClassifiersConfig,
    pub experiments: ExperimentConfig,
    pub debug: DebugConfig,
    pub logging: LoggingConfig,
    pub hooks: HooksConfig,
    pub lsp: LspConfig,
    pub magic_docs: MagicDocsConfig,
    pub telemetry: TelemetryConfig,
    pub metrics: MetricsConfig,
    pub secrets: ResolvedSecrets,
}

Top-level agent configuration.

Loaded from a TOML file via Config::load. Env-var overrides can be applied via apply_env_overrides. Secret resolution via VaultProvider is handled in zeph-core through the SecretResolver trait.

Fields

agent: AgentConfig

llm: LlmConfig

skills: SkillsConfig

memory: MemoryConfig

telegram: Option<TelegramConfig>

discord: Option<DiscordConfig>

slack: Option<SlackConfig>

tools: ToolsConfig

a2a: A2aServerConfig

mcp: McpConfig

index: IndexConfig

vault: VaultConfig

security: SecurityConfig

timeouts: TimeoutConfig

cost: CostConfig

gateway: GatewayConfig

daemon: DaemonConfig

scheduler: SchedulerConfig

tui: TuiConfig

acp: AcpConfig

agents: SubAgentConfig

orchestration: OrchestrationConfig

classifiers: ClassifiersConfig

experiments: ExperimentConfig

debug: DebugConfig

logging: LoggingConfig

hooks: HooksConfig

lsp: LspConfig

magic_docs: MagicDocsConfig

MagicDocs auto-maintained markdown (#2702).

telemetry: TelemetryConfig

Profiling and distributed tracing configuration.

metrics: MetricsConfig

Prometheus metrics export configuration.

secrets: ResolvedSecrets

Resolved secrets from vault. Never serialized — populated at runtime.

Implementations

impl Config

pub fn apply_env_overrides(&mut self)

impl Config

pub fn load(path: &Path) -> Result<Config, ConfigError>

Load configuration from a TOML file with env var overrides.

Falls back to sensible defaults when the file does not exist.

Errors

Returns an error if the file exists but cannot be read or parsed.

pub fn dump_defaults() -> Result<String, ConfigError>

Serialize the default configuration to a TOML string.

Produces a pretty-printed TOML representation of Config::default(). Useful for bootstrapping a new config file or documenting available options.

The secrets field is always excluded from the output because it is populated at runtime only and must never be written to disk.

Errors

Returns an error if serialization fails (unlikely — the default value is always structurally valid).

Examples

use zeph_config::Config;

let toml = Config::dump_defaults().expect("serialization failed");
assert!(toml.contains("[agent]"));
assert!(toml.contains("[memory]"));

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

Validate configuration values are within sane bounds.

Errors

Returns an error if any value is out of range.

Trait Implementations

impl Debug for Config

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

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Config, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl SecretResolver for Config

async fn resolve_secrets( &mut self, vault: &dyn VaultProvider, ) -> Result<(), ConfigError>

Populate secrets fields from the vault.

impl Serialize for Config

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

where __S: Serializer,

Serialize this value into the given Serde serializer.