iicp-client 0.7.80

Use the open IICP AI mesh from Rust without running a node
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

// SPDX-License-Identifier: Apache-2.0
//! Client-side policy guardrails.
//!
//! This is intentionally narrow: it refuses intent URNs aligned with EU AI Act
//! prohibited-practice families before discovery, without turning the SDK into a
//! broad legal compliance engine.

use crate::errors::{IicpError, Result};

pub const POLICY_REFUSAL_CODE: &str = "IICP-POLICY-001";

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ProhibitedIntentRule {
    pub rule_id: &'static str,
    pub label: &'static str,
    pub fragments: &'static [&'static str],
}

pub const PROHIBITED_INTENT_RULES: &[ProhibitedIntentRule] = &[
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-social-scoring",
        label: "social scoring",
        fragments: &["social-scoring", "social_scoring", "social:scoring"],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-criminal-risk",
        label: "individual criminal risk prediction",
        fragments: &[
            "criminal-risk",
            "criminal_risk",
            "criminal:risk",
            "predict-crime",
        ],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-workplace-education-emotion",
        label: "workplace or education emotion recognition",
        fragments: &[
            "emotion:workplace",
            "emotion:education",
            "workplace-monitoring",
            "education-monitoring",
            "worker-monitoring",
        ],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-protected-trait-biometric",
        label: "biometric protected-trait classification",
        fragments: &["protected-trait", "protected_trait", "biometric:protected"],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-untargeted-face-scraping",
        label: "untargeted facial image scraping for recognition databases",
        fragments: &[
            "untargeted-scraping",
            "untargeted_scraping",
            "face-scraping",
            "facial-scraping",
        ],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-realtime-remote-biometric-id",
        label: "real-time remote biometric identification",
        fragments: &[
            "remote-biometric:realtime",
            "realtime-remote-biometric",
            "real-time-remote-biometric",
        ],
    },
    ProhibitedIntentRule {
        rule_id: "eu-ai-act-nonconsensual-sexual-deepfake",
        label: "non-consensual sexual deepfake or CSAM generation",
        fragments: &[
            "nonconsensual-sexual",
            "non-consensual-sexual",
            "child-sexual-abuse",
            "csam",
        ],
    },
];

pub fn prohibited_intent_reason(intent: &str) -> Option<String> {
    let normalized = intent.trim().to_ascii_lowercase();
    for rule in PROHIBITED_INTENT_RULES {
        if rule
            .fragments
            .iter()
            .any(|fragment| normalized.contains(fragment))
        {
            return Some(format!("{} ({})", rule.label, rule.rule_id));
        }
    }
    None
}

pub fn ensure_intent_allowed(intent: &str) -> Result<()> {
    if let Some(reason) = prohibited_intent_reason(intent) {
        return Err(IicpError::PolicyRefused {
            code: POLICY_REFUSAL_CODE.into(),
            message: format!(
                "Intent refused by IICP client policy before discovery/routing: {reason}. Use a lawful, documented, human-reviewed compliance path outside the public mesh for restricted/high-risk workflows."
            ),
        });
    }
    Ok(())
}

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

    #[test]
    fn refuses_prohibited_intent() {
        let err = ensure_intent_allowed("urn:iicp:intent:social-scoring:score:v1").unwrap_err();
        assert!(matches!(err, IicpError::PolicyRefused { .. }));
    }

    #[test]
    fn allows_normal_chat_intent() {
        ensure_intent_allowed("urn:iicp:intent:llm:chat:v1").unwrap();
    }
}