terraphim_config 1.16.34

Terraphim configuration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! LLM Router Configuration Types
//!
//! Configuration types for intelligent LLM routing in Terraphim AI.

use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

/// Router configuration from Role
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
pub struct LlmRouterConfig {
    /// Enable intelligent routing (default: true)
    #[serde(default)]
    pub enabled: bool,

    /// Routing mode: "library" (in-process) or "service" (HTTP proxy)
    #[serde(default)]
    pub mode: RouterMode,

    /// Proxy URL for service mode (default: http://127.0.0.1:3456)
    #[serde(default)]
    pub proxy_url: Option<String>,

    /// Taxonomy path for pattern-based routing (default: docs/taxonomy)
    #[serde(default)]
    pub taxonomy_path: Option<String>,

    /// Enable cost optimization phase
    #[serde(default)]
    pub cost_optimization_enabled: bool,

    /// Enable performance optimization phase
    #[serde(default)]
    pub performance_optimization_enabled: bool,

    /// Routing strategy preference
    #[serde(default)]
    pub strategy: RouterStrategy,
}

impl Default for LlmRouterConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            mode: RouterMode::Library,
            proxy_url: None,
            taxonomy_path: None,
            cost_optimization_enabled: false,
            performance_optimization_enabled: false,
            strategy: RouterStrategy::Balanced,
        }
    }
}

/// Router mode selection
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default, JsonSchema)]
pub enum RouterMode {
    /// In-process library routing (fast, single deployment)
    #[serde(rename = "library")]
    #[default]
    Library,

    /// External HTTP service (slower, separate deployment)
    #[serde(rename = "service")]
    Service,
}

/// Router strategy for preference
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default, JsonSchema)]
pub enum RouterStrategy {
    /// Cost-first optimization
    #[serde(rename = "cost_first")]
    CostFirst,

    /// Quality-first (performance metrics)
    #[serde(rename = "quality_first")]
    QualityFirst,

    /// Balanced (cost + quality)
    #[serde(rename = "balanced")]
    #[default]
    Balanced,

    /// Static model selection (backward compatibility)
    #[serde(rename = "static")]
    Static,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_llm_router_config_default() {
        let config = LlmRouterConfig::default();
        assert!(config.enabled);
        assert!(matches!(config.mode, RouterMode::Library));
        assert_eq!(config.strategy, RouterStrategy::Balanced);
        assert!(config.proxy_url.is_none());
        assert_eq!(config.taxonomy_path, None);
    }

    #[test]
    fn test_router_mode_serialization() {
        let modes = vec![RouterMode::Library, RouterMode::Service];

        for mode in modes {
            let serialized = serde_json::to_string(&mode).unwrap();
            let deserialized: RouterMode = serde_json::from_str(&serialized).unwrap();
            assert_eq!(mode, deserialized);
        }
    }

    #[test]
    fn test_router_strategy_serialization() {
        let strategies = vec![
            RouterStrategy::CostFirst,
            RouterStrategy::QualityFirst,
            RouterStrategy::Balanced,
            RouterStrategy::Static,
        ];

        for strategy in strategies {
            let serialized = serde_json::to_string(&strategy).unwrap();
            let deserialized: RouterStrategy = serde_json::from_str(&serialized).unwrap();
            assert_eq!(strategy, deserialized);
        }
    }
}