realizar 0.8.4

Pure Rust ML inference engine built from scratch - model serving for GGUF and safetensors
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


// ============================================================================
// Property-Based Tests (EXTREME TDD)
// ============================================================================

#[cfg(test)]
mod proptests {
    use super::*;
    use proptest::prelude::*;

    proptest! {
        /// Property: Formatting never panics for arbitrary Unicode strings
        #[test]
        fn prop_format_never_panics(content in ".*") {
            let template = ChatMLTemplate::new();
            let messages = vec![ChatMessage::user(&content)];
            // Should not panic
            let _ = template.format_conversation(&messages);
        }

        /// Property: Output always contains the input content
        #[test]
        fn prop_output_contains_content(content in "[a-zA-Z0-9 ]{1,100}") {
            let template = ChatMLTemplate::new();
            let messages = vec![ChatMessage::user(&content)];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
            let output = result.expect("operation failed");
            prop_assert!(output.contains(&content));
        }

        /// Property: Auto-detection is deterministic
        #[test]
        fn prop_detection_deterministic(name in "[a-zA-Z0-9_-]{1,50}") {
            let format1 = detect_format_from_name(&name);
            let format2 = detect_format_from_name(&name);
            prop_assert_eq!(format1, format2);
        }

        /// Property: Message order preserved in output
        #[test]
        fn prop_message_order_preserved(
            msg1 in "[a-z]{5,10}",
            msg2 in "[a-z]{5,10}",
            msg3 in "[a-z]{5,10}"
        ) {
            let template = ChatMLTemplate::new();
            let messages = vec![
                ChatMessage::user(&msg1),
                ChatMessage::assistant(&msg2),
                ChatMessage::user(&msg3),
            ];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
            let output = result.expect("operation failed");

            let pos1 = output.find(&msg1);
            let pos2 = output.find(&msg2);
            let pos3 = output.find(&msg3);

            prop_assert!(pos1.is_some());
            prop_assert!(pos2.is_some());
            prop_assert!(pos3.is_some());
            prop_assert!(pos1.expect("operation failed") < pos2.expect("operation failed"));
            prop_assert!(pos2.expect("operation failed") < pos3.expect("operation failed"));
        }

        /// Property: Serde roundtrip preserves ChatMessage
        #[test]
        fn prop_message_serde_roundtrip(
            role in "(system|user|assistant)",
            content in ".*"
        ) {
            let msg = ChatMessage::new(&role, &content);
            let json = serde_json::to_string(&msg).expect("invalid UTF-8");
            let restored: ChatMessage = serde_json::from_str(&json).expect("parse failed");
            prop_assert_eq!(msg, restored);
        }

        /// Property: Template format enum is exhaustive in create_template
        #[test]
        fn prop_all_formats_creatable(format_idx in 0usize..8) {
            let formats = [
                TemplateFormat::ChatML,
                TemplateFormat::Llama2,
                TemplateFormat::Zephyr,
                TemplateFormat::Mistral,
                TemplateFormat::Phi,
                TemplateFormat::Alpaca,
                TemplateFormat::Custom,
                TemplateFormat::Raw,
            ];
            let format = formats[format_idx];
            let template = create_template(format);
            // Should not panic and should format
            let messages = vec![ChatMessage::user("test")];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
        }

        /// Property: Generation prompt is always appended for ChatML
        #[test]
        fn prop_chatml_generation_prompt(content in "[a-z]{1,50}") {
            let template = ChatMLTemplate::new();
            let messages = vec![ChatMessage::user(&content)];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
            let output = result.expect("operation failed");
            prop_assert!(output.ends_with("<|im_start|>assistant\n"));
        }

        /// Property: LLaMA2 always starts with BOS token
        #[test]
        fn prop_llama2_bos_token(content in "[a-z]{1,50}") {
            let template = Llama2Template::new();
            let messages = vec![ChatMessage::user(&content)];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
            let output = result.expect("operation failed");
            prop_assert!(output.starts_with("<s>"));
        }

        /// Property: Mistral never includes system prompt markers
        #[test]
        fn prop_mistral_no_system_markers(
            sys_content in "[a-z]{1,20}",
            user_content in "[a-z]{1,20}"
        ) {
            let template = MistralTemplate::new();
            let messages = vec![
                ChatMessage::system(&sys_content),
                ChatMessage::user(&user_content),
            ];
            let result = template.format_conversation(&messages);
            prop_assert!(result.is_ok());
            let output = result.expect("operation failed");
            // Mistral doesn't support system prompts
            prop_assert!(!output.contains("<<SYS>>"));
            prop_assert!(!output.contains("<</SYS>>"));
        }
    }
}