llm_optimizer_processor/decision/
config.rs

1//! Decision Engine configuration
2
3use serde::{Deserialize, Serialize};
4use std::time::Duration;
5
6/// Configuration for the Decision Engine
7#[derive(Debug, Clone, Serialize, Deserialize)]
8pub struct DecisionEngineConfig {
9    /// Base configuration
10    pub id: String,
11
12    /// Whether the engine is enabled
13    pub enabled: bool,
14
15    /// Decision interval (how often to make decisions)
16    pub decision_interval: Duration,
17
18    /// Minimum time between decisions for the same issue
19    pub min_decision_gap: Duration,
20
21    /// Maximum concurrent decisions
22    pub max_concurrent_decisions: usize,
23
24    /// Decision timeout
25    pub decision_timeout: Duration,
26
27    /// Whether to enable automatic execution
28    pub auto_execute: bool,
29
30    /// Whether to require approval for decisions
31    pub require_approval: bool,
32
33    /// Strategy configurations
34    pub strategies: StrategyConfigs,
35
36    /// Safety configuration
37    pub safety: SafetyConfig,
38
39    /// Monitoring configuration
40    pub monitoring: MonitoringConfig,
41}
42
43impl Default for DecisionEngineConfig {
44    fn default() -> Self {
45        Self {
46            id: "decision-engine".to_string(),
47            enabled: true,
48            decision_interval: Duration::from_secs(60),
49            min_decision_gap: Duration::from_secs(300),
50            max_concurrent_decisions: 3,
51            decision_timeout: Duration::from_secs(30),
52            auto_execute: false,
53            require_approval: true,
54            strategies: StrategyConfigs::default(),
55            safety: SafetyConfig::default(),
56            monitoring: MonitoringConfig::default(),
57        }
58    }
59}
60
61/// Configuration for all strategies
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub struct StrategyConfigs {
64    /// Model selection strategy configuration
65    pub model_selection: ModelSelectionConfig,
66
67    /// Caching strategy configuration
68    pub caching: CachingConfig,
69
70    /// Rate limiting strategy configuration
71    pub rate_limiting: RateLimitingConfig,
72
73    /// Batching strategy configuration
74    pub batching: BatchingConfig,
75
76    /// Prompt optimization strategy configuration
77    pub prompt_optimization: PromptOptimizationConfig,
78}
79
80impl Default for StrategyConfigs {
81    fn default() -> Self {
82        Self {
83            model_selection: ModelSelectionConfig::default(),
84            caching: CachingConfig::default(),
85            rate_limiting: RateLimitingConfig::default(),
86            batching: BatchingConfig::default(),
87            prompt_optimization: PromptOptimizationConfig::default(),
88        }
89    }
90}
91
92/// Model selection strategy configuration
93#[derive(Debug, Clone, Serialize, Deserialize)]
94pub struct ModelSelectionConfig {
95    /// Whether this strategy is enabled
96    pub enabled: bool,
97
98    /// Priority (higher = more important)
99    pub priority: u32,
100
101    /// Minimum confidence required
102    pub min_confidence: f64,
103
104    /// Cost weight in decision (0-1)
105    pub cost_weight: f64,
106
107    /// Performance weight in decision (0-1)
108    pub performance_weight: f64,
109
110    /// Quality weight in decision (0-1)
111    pub quality_weight: f64,
112
113    /// Available models to choose from
114    pub available_models: Vec<String>,
115
116    /// Minimum evaluation period before switching models
117    pub min_evaluation_period: Duration,
118
119    /// Maximum cost increase allowed for quality improvement (%)
120    pub max_cost_increase_pct: f64,
121}
122
123impl Default for ModelSelectionConfig {
124    fn default() -> Self {
125        Self {
126            enabled: true,
127            priority: 100,
128            min_confidence: 0.7,
129            cost_weight: 0.4,
130            performance_weight: 0.3,
131            quality_weight: 0.3,
132            available_models: vec![
133                "gpt-4".to_string(),
134                "gpt-3.5-turbo".to_string(),
135                "claude-3-opus".to_string(),
136                "claude-3-sonnet".to_string(),
137            ],
138            min_evaluation_period: Duration::from_secs(3600), // 1 hour
139            max_cost_increase_pct: 50.0,
140        }
141    }
142}
143
144/// Caching strategy configuration
145#[derive(Debug, Clone, Serialize, Deserialize)]
146pub struct CachingConfig {
147    /// Whether this strategy is enabled
148    pub enabled: bool,
149
150    /// Priority
151    pub priority: u32,
152
153    /// Minimum confidence required
154    pub min_confidence: f64,
155
156    /// Minimum request frequency to enable caching (req/min)
157    pub min_request_frequency: f64,
158
159    /// Minimum similarity threshold for cache hits (0-1)
160    pub min_similarity_threshold: f64,
161
162    /// Cache TTL
163    pub cache_ttl: Duration,
164
165    /// Maximum cache size (number of entries)
166    pub max_cache_size: usize,
167
168    /// Minimum expected hit rate to enable caching (%)
169    pub min_expected_hit_rate_pct: f64,
170}
171
172impl Default for CachingConfig {
173    fn default() -> Self {
174        Self {
175            enabled: true,
176            priority: 90,
177            min_confidence: 0.7,
178            min_request_frequency: 10.0,
179            min_similarity_threshold: 0.85,
180            cache_ttl: Duration::from_secs(3600),
181            max_cache_size: 10000,
182            min_expected_hit_rate_pct: 20.0,
183        }
184    }
185}
186
187/// Rate limiting strategy configuration
188#[derive(Debug, Clone, Serialize, Deserialize)]
189pub struct RateLimitingConfig {
190    /// Whether this strategy is enabled
191    pub enabled: bool,
192
193    /// Priority
194    pub priority: u32,
195
196    /// Minimum confidence required
197    pub min_confidence: f64,
198
199    /// Maximum requests per second
200    pub max_requests_per_second: f64,
201
202    /// Maximum tokens per minute
203    pub max_tokens_per_minute: u64,
204
205    /// Maximum cost per hour (USD)
206    pub max_cost_per_hour: f64,
207
208    /// Burst multiplier (allows temporary bursts)
209    pub burst_multiplier: f64,
210
211    /// Adaptive rate limiting enabled
212    pub adaptive_enabled: bool,
213
214    /// Target error rate for adaptive limiting (%)
215    pub target_error_rate_pct: f64,
216}
217
218impl Default for RateLimitingConfig {
219    fn default() -> Self {
220        Self {
221            enabled: true,
222            priority: 80,
223            min_confidence: 0.7,
224            max_requests_per_second: 100.0,
225            max_tokens_per_minute: 100000,
226            max_cost_per_hour: 10.0,
227            burst_multiplier: 1.5,
228            adaptive_enabled: true,
229            target_error_rate_pct: 1.0,
230        }
231    }
232}
233
234/// Batching strategy configuration
235#[derive(Debug, Clone, Serialize, Deserialize)]
236pub struct BatchingConfig {
237    /// Whether this strategy is enabled
238    pub enabled: bool,
239
240    /// Priority
241    pub priority: u32,
242
243    /// Minimum confidence required
244    pub min_confidence: f64,
245
246    /// Maximum batch size
247    pub max_batch_size: usize,
248
249    /// Batch timeout (max wait time)
250    pub batch_timeout: Duration,
251
252    /// Minimum requests to enable batching
253    pub min_requests_for_batching: usize,
254
255    /// Maximum latency increase allowed (ms)
256    pub max_latency_increase_ms: f64,
257
258    /// Minimum cost savings to enable batching (%)
259    pub min_cost_savings_pct: f64,
260}
261
262impl Default for BatchingConfig {
263    fn default() -> Self {
264        Self {
265            enabled: true,
266            priority: 70,
267            min_confidence: 0.7,
268            max_batch_size: 10,
269            batch_timeout: Duration::from_millis(100),
270            min_requests_for_batching: 5,
271            max_latency_increase_ms: 200.0,
272            min_cost_savings_pct: 15.0,
273        }
274    }
275}
276
277/// Prompt optimization strategy configuration
278#[derive(Debug, Clone, Serialize, Deserialize)]
279pub struct PromptOptimizationConfig {
280    /// Whether this strategy is enabled
281    pub enabled: bool,
282
283    /// Priority
284    pub priority: u32,
285
286    /// Minimum confidence required
287    pub min_confidence: f64,
288
289    /// Minimum token reduction to apply optimization (%)
290    pub min_token_reduction_pct: f64,
291
292    /// A/B test duration
293    pub ab_test_duration: Duration,
294
295    /// A/B test traffic split (0-1)
296    pub ab_test_traffic_split: f64,
297
298    /// Minimum quality score for optimized prompts
299    pub min_quality_score: f64,
300
301    /// Maximum quality degradation allowed (%)
302    pub max_quality_degradation_pct: f64,
303}
304
305impl Default for PromptOptimizationConfig {
306    fn default() -> Self {
307        Self {
308            enabled: true,
309            priority: 85,
310            min_confidence: 0.7,
311            min_token_reduction_pct: 10.0,
312            ab_test_duration: Duration::from_secs(3600),
313            ab_test_traffic_split: 0.1,
314            min_quality_score: 4.0,
315            max_quality_degradation_pct: 5.0,
316        }
317    }
318}
319
320/// Safety configuration
321#[derive(Debug, Clone, Serialize, Deserialize)]
322pub struct SafetyConfig {
323    /// Maximum cost increase allowed (USD/day)
324    pub max_cost_increase_usd: f64,
325
326    /// Maximum latency increase allowed (ms)
327    pub max_latency_increase_ms: f64,
328
329    /// Minimum quality score (0-5)
330    pub min_quality_score: f64,
331
332    /// Minimum success rate (%)
333    pub min_success_rate_pct: f64,
334
335    /// Enable circuit breaker
336    pub circuit_breaker_enabled: bool,
337
338    /// Circuit breaker error threshold (%)
339    pub circuit_breaker_error_threshold_pct: f64,
340
341    /// Circuit breaker timeout
342    pub circuit_breaker_timeout: Duration,
343
344    /// Enable automatic rollback
345    pub auto_rollback_enabled: bool,
346
347    /// Rollback timeout (max time before auto-rollback if metrics don't improve)
348    pub rollback_timeout: Duration,
349}
350
351impl Default for SafetyConfig {
352    fn default() -> Self {
353        Self {
354            max_cost_increase_usd: 100.0,
355            max_latency_increase_ms: 500.0,
356            min_quality_score: 3.5,
357            min_success_rate_pct: 95.0,
358            circuit_breaker_enabled: true,
359            circuit_breaker_error_threshold_pct: 10.0,
360            circuit_breaker_timeout: Duration::from_secs(300),
361            auto_rollback_enabled: true,
362            rollback_timeout: Duration::from_secs(600),
363        }
364    }
365}
366
367/// Monitoring configuration
368#[derive(Debug, Clone, Serialize, Deserialize)]
369pub struct MonitoringConfig {
370    /// Enable detailed logging
371    pub enable_logging: bool,
372
373    /// Enable metrics collection
374    pub enable_metrics: bool,
375
376    /// Enable tracing
377    pub enable_tracing: bool,
378
379    /// Metrics export interval
380    pub metrics_interval: Duration,
381
382    /// Decision history size (number of decisions to keep)
383    pub decision_history_size: usize,
384
385    /// Outcome history size (number of outcomes to keep)
386    pub outcome_history_size: usize,
387}
388
389impl Default for MonitoringConfig {
390    fn default() -> Self {
391        Self {
392            enable_logging: true,
393            enable_metrics: true,
394            enable_tracing: true,
395            metrics_interval: Duration::from_secs(60),
396            decision_history_size: 1000,
397            outcome_history_size: 1000,
398        }
399    }
400}
llm_optimizer_processor/decision/config.rs

llm_optimizer_processor/decision/
config.rs
