xybrid-core 0.1.0-rc4

Core runtime for hybrid cloud-edge AI inference: model execution, pipeline orchestration, and routing primitives.
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

//! Intermediate Representation (IR) module - Data serialization layer.
//!
//! This module defines the Envelope IR, which is the serialization layer that
//! defines how data flows between pipeline stages. Envelopes encapsulate typed
//! payloads (audio, text, embeddings) and can be serialized for storage or
//! transmission between local processes or over HTTP to cloud endpoints.

pub mod envelope;

pub use envelope::{AudioSamples, Envelope, EnvelopeKind};
// Note: MessageRole is defined below in this file and is public by default

/// Message role in a conversation.
///
/// Defines the role of each message in a chat completion or conversation context.
/// This is the single source of truth for message roles across xybrid-core and xybrid-sdk.
///
/// # Serialization
///
/// Serializes to lowercase strings for JSON compatibility:
/// - `System` → `"system"`
/// - `User` → `"user"`
/// - `Assistant` → `"assistant"`
///
/// # Example
///
/// ```rust
/// use xybrid_core::ir::MessageRole;
///
/// let role = MessageRole::User;
/// assert_eq!(serde_json::to_string(&role).unwrap(), "\"user\"");
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum MessageRole {
    /// System message - sets the behavior and context for the assistant
    System,
    /// User message - the human's input
    User,
    /// Assistant message - the AI's response
    Assistant,
}

impl MessageRole {
    /// Returns the role as a lowercase string.
    pub fn as_str(&self) -> &'static str {
        match self {
            MessageRole::System => "system",
            MessageRole::User => "user",
            MessageRole::Assistant => "assistant",
        }
    }
}

impl std::fmt::Display for MessageRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

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

    #[test]
    fn test_message_role_serialization_lowercase() {
        assert_eq!(
            serde_json::to_string(&MessageRole::System).unwrap(),
            "\"system\""
        );
        assert_eq!(
            serde_json::to_string(&MessageRole::User).unwrap(),
            "\"user\""
        );
        assert_eq!(
            serde_json::to_string(&MessageRole::Assistant).unwrap(),
            "\"assistant\""
        );
    }

    #[test]
    fn test_message_role_deserialization_lowercase() {
        assert_eq!(
            serde_json::from_str::<MessageRole>("\"system\"").unwrap(),
            MessageRole::System
        );
        assert_eq!(
            serde_json::from_str::<MessageRole>("\"user\"").unwrap(),
            MessageRole::User
        );
        assert_eq!(
            serde_json::from_str::<MessageRole>("\"assistant\"").unwrap(),
            MessageRole::Assistant
        );
    }

    #[test]
    fn test_message_role_as_str() {
        assert_eq!(MessageRole::System.as_str(), "system");
        assert_eq!(MessageRole::User.as_str(), "user");
        assert_eq!(MessageRole::Assistant.as_str(), "assistant");
    }

    #[test]
    fn test_message_role_display() {
        assert_eq!(format!("{}", MessageRole::System), "system");
        assert_eq!(format!("{}", MessageRole::User), "user");
        assert_eq!(format!("{}", MessageRole::Assistant), "assistant");
    }
}