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    /// Per-attempt (not whole-call) timeout; non-streaming only.
83    #[serde(default = "default_request_timeout")]
84    pub request_timeout_ms: u64,
85
86    #[serde(default = "default_resilience_connect_timeout")]
87    pub connect_timeout_ms: u64,
88
89    /// Max gap between two chunks before a stream is aborted.
90    #[serde(default = "default_stream_idle_timeout")]
91    pub stream_idle_timeout_ms: u64,
92
93    /// Counts the first try, so `1` disables retries.
94    #[serde(default = "default_retry_attempts")]
95    pub retry_attempts: u32,
96
97    /// Doubles each subsequent attempt.
98    #[serde(default = "default_retry_base_delay")]
99    pub retry_base_delay_ms: u64,
100
101    #[serde(default = "default_retry_max_delay")]
102    pub retry_max_delay_ms: u64,
103
104    /// Consecutive (not cumulative) failures that trip the breaker open.
105    #[serde(default = "default_breaker_threshold")]
106    pub breaker_failure_threshold: u32,
107
108    #[serde(default = "default_breaker_cooldown")]
109    pub breaker_open_cooldown_ms: u64,
110
111    #[serde(default = "default_half_open_probes")]
112    pub breaker_half_open_probes: u32,
113
114    #[serde(default = "default_max_concurrent")]
115    pub max_concurrent: usize,
116}
117
118impl Default for ResilienceSettings {
119    fn default() -> Self {
120        Self {
121            request_timeout_ms: default_request_timeout(),
122            connect_timeout_ms: default_resilience_connect_timeout(),
123            stream_idle_timeout_ms: default_stream_idle_timeout(),
124            retry_attempts: default_retry_attempts(),
125            retry_base_delay_ms: default_retry_base_delay(),
126            retry_max_delay_ms: default_retry_max_delay(),
127            breaker_failure_threshold: default_breaker_threshold(),
128            breaker_open_cooldown_ms: default_breaker_cooldown(),
129            breaker_half_open_probes: default_half_open_probes(),
130            max_concurrent: default_max_concurrent(),
131        }
132    }
133}
134
135const fn default_request_timeout() -> u64 {
136    60_000
137}
138
139const fn default_resilience_connect_timeout() -> u64 {
140    10_000
141}
142
143const fn default_stream_idle_timeout() -> u64 {
144    60_000
145}
146
147const fn default_retry_attempts() -> u32 {
148    3
149}
150
151const fn default_retry_base_delay() -> u64 {
152    200
153}
154
155const fn default_retry_max_delay() -> u64 {
156    10_000
157}
158
159const fn default_breaker_threshold() -> u32 {
160    5
161}
162
163const fn default_breaker_cooldown() -> u64 {
164    30_000
165}
166
167const fn default_half_open_probes() -> u32 {
168    1
169}
170
171const fn default_max_concurrent() -> usize {
172    16
173}
174
175#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
176pub struct HistoryConfig {
177    #[serde(default = "default_retention_days")]
178    pub retention_days: u32,
179
180    #[serde(default)]
181    pub log_tool_executions: bool,
182}
183
184impl Default for HistoryConfig {
185    fn default() -> Self {
186        Self {
187            retention_days: default_retention_days(),
188            log_tool_executions: false,
189        }
190    }
191}
192
193const fn default_retention_days() -> u32 {
194    30
195}