Skip to main content

systemprompt_models/services/ai/
config.rs

1//! AI service configuration loaded from profile YAML.
2//!
3//! [`AiConfig`] is the top-level AI *policy* block: the default provider, the
4//! per-provider policy map (keyed by registry provider name), sampling, MCP
5//! discovery, and history retention. Upstream connectivity lives in the profile
6//! `providers` registry, not here. The nested [`ResilienceSettings`] is the
7//! per-dependency timeout/retry/circuit-breaker policy applied to outbound
8//! provider and MCP calls.
9//!
10//! Copyright (c) systemprompt.io — Business Source License 1.1.
11//! See <https://systemprompt.io> for licensing details.
12
13use serde::{Deserialize, Serialize};
14use std::collections::HashMap;
15
16use super::model::AiProviderConfig;
17
18#[derive(Debug, Clone, Default, Serialize, Deserialize)]
19pub struct AiConfig {
20    #[serde(default)]
21    pub default_provider: String,
22
23    #[serde(default)]
24    pub default_max_output_tokens: Option<u32>,
25
26    #[serde(default)]
27    pub sampling: SamplingConfig,
28
29    #[serde(default)]
30    pub providers: HashMap<String, AiProviderConfig>,
31
32    #[serde(default)]
33    pub mcp: McpConfig,
34
35    #[serde(default)]
36    pub history: HistoryConfig,
37}
38
39#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
40pub struct SamplingConfig {
41    #[serde(default)]
42    pub enable_smart_routing: bool,
43
44    #[serde(default)]
45    pub fallback_enabled: bool,
46}
47
48#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
49pub struct McpConfig {
50    #[serde(default)]
51    pub auto_discover: bool,
52
53    #[serde(default = "default_mcp_resilience")]
54    pub resilience: ResilienceSettings,
55}
56
57impl Default for McpConfig {
58    fn default() -> Self {
59        Self {
60            auto_discover: false,
61            resilience: default_mcp_resilience(),
62        }
63    }
64}
65
66fn default_mcp_resilience() -> ResilienceSettings {
67    ResilienceSettings {
68        request_timeout_ms: 30_000,
69        connect_timeout_ms: 5_000,
70        ..ResilienceSettings::default()
71    }
72}
73
74/// Per-dependency resilience policy: timeouts, retry, circuit breaker,
75/// bulkhead.
76///
77/// Plain serde data loaded from profile config (all values in milliseconds or
78/// counts). Translated into the runtime form consumed by the resilience
79/// primitives in `systemprompt-database`.
80#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
81pub struct ResilienceSettings {
82    #[serde(default = "default_request_timeout")]
83    pub request_timeout_ms: u64,
84
85    #[serde(default = "default_resilience_connect_timeout")]
86    pub connect_timeout_ms: u64,
87
88    #[serde(default = "default_stream_idle_timeout")]
89    pub stream_idle_timeout_ms: u64,
90
91    #[serde(default = "default_retry_attempts")]
92    pub retry_attempts: u32,
93
94    #[serde(default = "default_retry_base_delay")]
95    pub retry_base_delay_ms: u64,
96
97    #[serde(default = "default_retry_max_delay")]
98    pub retry_max_delay_ms: u64,
99
100    #[serde(default = "default_breaker_threshold")]
101    pub breaker_failure_threshold: u32,
102
103    #[serde(default = "default_breaker_cooldown")]
104    pub breaker_open_cooldown_ms: u64,
105
106    #[serde(default = "default_half_open_probes")]
107    pub breaker_half_open_probes: u32,
108
109    #[serde(default = "default_max_concurrent")]
110    pub max_concurrent: usize,
111}
112
113impl Default for ResilienceSettings {
114    fn default() -> Self {
115        Self {
116            request_timeout_ms: default_request_timeout(),
117            connect_timeout_ms: default_resilience_connect_timeout(),
118            stream_idle_timeout_ms: default_stream_idle_timeout(),
119            retry_attempts: default_retry_attempts(),
120            retry_base_delay_ms: default_retry_base_delay(),
121            retry_max_delay_ms: default_retry_max_delay(),
122            breaker_failure_threshold: default_breaker_threshold(),
123            breaker_open_cooldown_ms: default_breaker_cooldown(),
124            breaker_half_open_probes: default_half_open_probes(),
125            max_concurrent: default_max_concurrent(),
126        }
127    }
128}
129
130const fn default_request_timeout() -> u64 {
131    60_000
132}
133
134const fn default_resilience_connect_timeout() -> u64 {
135    10_000
136}
137
138const fn default_stream_idle_timeout() -> u64 {
139    60_000
140}
141
142const fn default_retry_attempts() -> u32 {
143    3
144}
145
146const fn default_retry_base_delay() -> u64 {
147    200
148}
149
150const fn default_retry_max_delay() -> u64 {
151    10_000
152}
153
154const fn default_breaker_threshold() -> u32 {
155    5
156}
157
158const fn default_breaker_cooldown() -> u64 {
159    30_000
160}
161
162const fn default_half_open_probes() -> u32 {
163    1
164}
165
166const fn default_max_concurrent() -> usize {
167    16
168}
169
170#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
171pub struct HistoryConfig {
172    #[serde(default = "default_retention_days")]
173    pub retention_days: u32,
174
175    #[serde(default)]
176    pub log_tool_executions: bool,
177}
178
179impl Default for HistoryConfig {
180    fn default() -> Self {
181        Self {
182            retention_days: default_retention_days(),
183            log_tool_executions: false,
184        }
185    }
186}
187
188const fn default_retention_days() -> u32 {
189    30
190}