agentcontract 0.1.1

Rust implementation of the AgentContract specification — behavioral contracts for AI agents
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

//! Regex pattern validator — must_match / must_not_match.

use regex::Regex;
use super::{RunContext, ValidationResult};

pub fn validate(
    ctx: &RunContext,
    name: &str,
    must_not_match: Option<&str>,
    must_match: Option<&str>,
    description: &str,
) -> ValidationResult {
    let output = &ctx.output;

    if let Some(pattern) = must_not_match {
        match Regex::new(pattern) {
            Ok(re) => {
                if let Some(m) = re.find(output) {
                    let snippet: String = m.as_str().chars().take(50).collect();
                    let text = if description.is_empty() {
                        format!("must_not_match: {pattern}")
                    } else {
                        description.into()
                    };
                    return ValidationResult::fail(
                        name,
                        &text,
                        "assert",
                        &format!("Forbidden pattern found at position {}: '{snippet}'", m.start()),
                    );
                }
            }
            Err(e) => {
                return ValidationResult::fail(name, description, "assert", &format!("Invalid regex: {e}"));
            }
        }
    }

    if let Some(pattern) = must_match {
        match Regex::new(pattern) {
            Ok(re) => {
                if !re.is_match(output) {
                    let text = if description.is_empty() {
                        format!("must_match: {pattern}")
                    } else {
                        description.into()
                    };
                    return ValidationResult::fail(
                        name,
                        &text,
                        "assert",
                        "Required pattern not found in output.",
                    );
                }
            }
            Err(e) => {
                return ValidationResult::fail(name, description, "assert", &format!("Invalid regex: {e}"));
            }
        }
    }

    let text = if description.is_empty() { name } else { description };
    ValidationResult::pass(name, text, "assert")
}