systemprompt-models 0.53.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
137
138
139
140
141
142
143
144
145
146
147
148

//! Consumer receipts: the authenticated device, byte-exact file readbacks and
//! the installation plan a consumer acknowledges.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use systemprompt_identifiers::{
    ConsumerInstallationId, DeviceId, InstallationReceiptId, ManagedResourceId, NativeSessionId,
    PublicationId, ResourceRevisionId, UserId,
};

use super::{ContentDigest, EvaluatorClient, FeedbackContractError, validate_relative_path};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AuthenticatedConsumerDevice {
    pub consumer_id: UserId,
    pub device_id: DeviceId,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ReadbackStatus {
    Verified,
    Mismatch,
    Unavailable,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct FileReadback {
    pub revision_id: ResourceRevisionId,
    pub path: String,
    pub digest: ContentDigest,
    pub bytes: u64,
    pub executable: bool,
    pub content_check: ReadbackStatus,
    pub mode_check: ReadbackStatus,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct RuntimeFileReadback {
    pub path: String,
    pub digest: ContentDigest,
    pub bytes: u64,
    pub executable: bool,
    pub content_check: ReadbackStatus,
    pub mode_check: ReadbackStatus,
}

#[derive(Debug, Clone, Serialize, Deserialize, schemars::JsonSchema)]
pub struct InstallationPlanFile {
    pub path: String,
    pub bytes: Vec<u8>,
    pub executable: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize, schemars::JsonSchema)]
pub struct ConsumerInstallationPlan {
    pub publication_id: PublicationId,
    pub resource_id: ManagedResourceId,
    pub revision_id: ResourceRevisionId,
    pub generation: i64,
    pub bundle_digest: ContentDigest,
    pub host: EvaluatorClient,
    pub canonical_files: Vec<FileReadback>,
    pub runtime_files: Vec<InstallationPlanFile>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct ConsumerReceiptRequest {
    pub installation_id: ConsumerInstallationId,
    pub publication_id: PublicationId,
    pub resource_id: ManagedResourceId,
    pub revision_id: ResourceRevisionId,
    pub generation: i64,
    pub bundle_digest: ContentDigest,
    pub host: EvaluatorClient,
    pub observed_at: DateTime<Utc>,
    pub files: Vec<FileReadback>,
    #[serde(default)]
    pub runtime_files: Vec<RuntimeFileReadback>,
}

impl ConsumerReceiptRequest {
    pub fn validate(&self) -> Result<(), FeedbackContractError> {
        if self.generation < 1 || self.files.is_empty() || self.files.len() > 4096 {
            return Err(FeedbackContractError::Bounds);
        }
        let mut paths = std::collections::BTreeSet::new();
        for file in &self.files {
            validate_relative_path(&file.path)?;
            if !paths.insert((&file.revision_id, &file.path)) {
                return Err(FeedbackContractError::IncompleteManifest);
            }
        }
        let mut runtime_paths = std::collections::BTreeSet::new();
        if self.runtime_files.len() > 8192 {
            return Err(FeedbackContractError::Bounds);
        }
        for file in &self.runtime_files {
            validate_relative_path(&file.path)?;
            if !runtime_paths.insert(&file.path) {
                return Err(FeedbackContractError::IncompleteManifest);
            }
        }
        Ok(())
    }

    pub fn fully_verified(&self) -> bool {
        self.validate().is_ok()
            && !self.runtime_files.is_empty()
            && self.runtime_files.iter().all(|file| {
                file.content_check == ReadbackStatus::Verified
                    && file.mode_check == ReadbackStatus::Verified
            })
            && self.files.iter().all(|file| {
                file.content_check == ReadbackStatus::Verified
                    && file.mode_check == ReadbackStatus::Verified
            })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)]
pub struct SessionBindingRequest {
    pub receipt_id: InstallationReceiptId,
    pub host: EvaluatorClient,
    pub session_id: NativeSessionId,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ReceiptAcknowledgement {
    Accepted,
    IdenticalRetry,
}

#[derive(Debug, Clone, Serialize, Deserialize, schemars::JsonSchema)]
pub struct ConsumerReceiptResponse {
    pub receipt_id: InstallationReceiptId,
    pub acknowledgement: ReceiptAcknowledgement,
    pub acknowledged_at: DateTime<Utc>,
    pub fully_verified: bool,
}