systemprompt-models 0.14.3

Foundation data models for systemprompt.io AI governance infrastructure. Shared DTOs, config, and domain types consumed by every layer of the MCP governance pipeline.
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
129
130
131
132
133
134
135
136
137
138
139
140
141

//! AI configuration validator.

use super::ValidationConfigProvider;
use crate::ServicesConfig;
use systemprompt_traits::validation_report::{
    ValidationError, ValidationReport, ValidationWarning,
};
use systemprompt_traits::{ConfigProvider, DomainConfig, DomainConfigError};

#[derive(Debug, Default)]
pub struct AiConfigValidator {
    config: Option<ServicesConfig>,
}

impl AiConfigValidator {
    pub fn new() -> Self {
        Self::default()
    }
}

impl DomainConfig for AiConfigValidator {
    fn domain_id(&self) -> &'static str {
        "ai"
    }

    fn priority(&self) -> u32 {
        50
    }

    fn dependencies(&self) -> &[&'static str] {
        &["mcp"]
    }

    fn load(&mut self, config: &dyn ConfigProvider) -> Result<(), DomainConfigError> {
        let provider = config
            .as_any()
            .downcast_ref::<ValidationConfigProvider>()
            .ok_or_else(|| {
                DomainConfigError::LoadError(
                    "Expected ValidationConfigProvider with merged ServicesConfig".into(),
                )
            })?;

        self.config = Some(provider.services_config().clone());
        Ok(())
    }

    fn validate(&self) -> Result<ValidationReport, DomainConfigError> {
        let mut report = ValidationReport::new("ai");
        let config = self
            .config
            .as_ref()
            .ok_or_else(|| DomainConfigError::ValidationError("Not loaded".into()))?;
        let ai_config = &config.ai;

        Self::validate_default_provider(&mut report, ai_config);
        Self::validate_enabled_providers(&mut report, ai_config);
        Self::validate_mcp_config(&mut report, ai_config);

        if ai_config.history.retention_days == 0 {
            report.add_warning(ValidationWarning::new(
                "ai.history.retention_days",
                "History retention set to 0 days, history will not be retained",
            ));
        }

        Ok(report)
    }
}

impl AiConfigValidator {
    fn validate_default_provider(report: &mut ValidationReport, ai_config: &crate::AiConfig) {
        if ai_config.default_provider.is_empty() {
            report.add_error(ValidationError::new(
                "ai.default_provider",
                "Default AI provider not configured",
            ));
        } else if !ai_config
            .providers
            .contains_key(&ai_config.default_provider)
        {
            report.add_error(
                ValidationError::new(
                    "ai.default_provider",
                    format!(
                        "Default provider '{}' not found in providers",
                        ai_config.default_provider
                    ),
                )
                .with_suggestion("Add the provider to ai.providers or change default_provider"),
            );
        }
    }

    fn validate_enabled_providers(report: &mut ValidationReport, ai_config: &crate::AiConfig) {
        let enabled: Vec<_> = ai_config
            .providers
            .iter()
            .filter(|(_, c)| c.enabled)
            .collect();

        if enabled.is_empty() {
            report.add_error(
                ValidationError::new("ai.providers", "No AI providers are enabled")
                    .with_suggestion("Enable at least one provider in ai.providers"),
            );
        }

        // Connectivity (credential, endpoint, model catalog) lives in the
        // profile `providers` registry and is validated there; this policy
        // layer only flags an enabled provider that names no default-model
        // override.
        for (name, cfg) in &enabled {
            if cfg.default_model.is_empty() {
                report.add_warning(ValidationWarning::new(
                    format!("ai.providers.{}.default_model", name),
                    format!(
                        "Provider '{}' has no default_model override; the provider client default \
                         will be used",
                        name
                    ),
                ));
            }
        }
    }

    fn validate_mcp_config(report: &mut ValidationReport, ai_config: &crate::AiConfig) {
        if ai_config.mcp.resilience.connect_timeout_ms == 0 {
            report.add_error(ValidationError::new(
                "ai.mcp.resilience.connect_timeout_ms",
                "MCP connect timeout must be greater than 0",
            ));
        }
        if ai_config.mcp.resilience.request_timeout_ms == 0 {
            report.add_error(ValidationError::new(
                "ai.mcp.resilience.request_timeout_ms",
                "MCP execution timeout must be greater than 0",
            ));
        }
    }
}