systemprompt-models 0.15.0

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

//! Per-provider JSON-Schema capability matrices.
//!
//! [`ProviderCapabilities`] declares which JSON-Schema constructs a provider's
//! tool/output schema parser accepts. It is the input to
//! [`super::SchemaSanitizer`], which strips everything a provider does not
//! support. The matrices live here in `shared/models` so both the gateway wire
//! codecs and the agent-flow provider clients resolve the same authority; the
//! wire protocol picks one via
//! [`crate::profile::WireProtocol::schema_capabilities`].

use serde_json::Value;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SchemaComposition {
    pub allof: bool,
    pub anyof: bool,
    pub oneof: bool,
    pub if_then_else: bool,
    pub not: bool,
}

#[expect(
    clippy::struct_excessive_bools,
    reason = "schema feature matrix: each bool is an independent JSON-Schema construct the \
              provider does or does not accept, not state"
)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SchemaFeatures {
    pub references: bool,
    pub definitions: bool,
    pub additional_properties: bool,
    pub const_values: bool,
    /// `exclusiveMinimum` / `exclusiveMaximum` numeric bounds. Gemini's
    /// OpenAPI-subset parser rejects these; Anthropic and `OpenAI` accept them.
    pub exclusive_bounds: bool,
    /// `propertyNames` / `patternProperties` object constraints. Rejected by
    /// Gemini's parser; accepted by Anthropic and `OpenAI`.
    pub property_names: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProviderCapabilities {
    pub composition: SchemaComposition,
    pub features: SchemaFeatures,
}

impl ProviderCapabilities {
    pub const fn anthropic() -> Self {
        Self {
            composition: SchemaComposition {
                allof: true,
                anyof: true,
                oneof: true,
                if_then_else: true,
                not: true,
            },
            features: SchemaFeatures {
                references: true,
                definitions: true,
                additional_properties: true,
                const_values: true,
                exclusive_bounds: true,
                property_names: true,
            },
        }
    }

    pub const fn openai() -> Self {
        Self {
            composition: SchemaComposition {
                allof: true,
                anyof: true,
                oneof: true,
                if_then_else: false,
                not: false,
            },
            features: SchemaFeatures {
                references: true,
                definitions: true,
                additional_properties: true,
                const_values: true,
                exclusive_bounds: true,
                property_names: true,
            },
        }
    }

    pub const fn gemini() -> Self {
        Self {
            composition: SchemaComposition {
                allof: false,
                anyof: true,
                oneof: false,
                if_then_else: false,
                not: false,
            },
            features: SchemaFeatures {
                references: false,
                definitions: false,
                additional_properties: false,
                const_values: false,
                exclusive_bounds: false,
                property_names: false,
            },
        }
    }

    pub fn requires_transformation(&self, schema: &Value) -> bool {
        if let Some(obj) = schema.as_object() {
            if obj.contains_key("allOf") && !self.composition.allof {
                return true;
            }
            if obj.contains_key("anyOf") && !self.composition.anyof {
                return true;
            }
            if obj.contains_key("oneOf") && !self.composition.oneof {
                return true;
            }
            if obj.contains_key("if") && !self.composition.if_then_else {
                return true;
            }
            if obj.contains_key("$ref") && !self.features.references {
                return true;
            }
            if (obj.contains_key("definitions") || obj.contains_key("$defs"))
                && !self.features.definitions
            {
                return true;
            }
            if obj.contains_key("not") && !self.composition.not {
                return true;
            }
        }
        false
    }
}