kernelx_core/providers/remote/openai/
utils.rs

1use crate::capabilities::{ChatMessage, Role};
2use crate::Result;
3use async_openai::types::{
4    ChatCompletionRequestAssistantMessageArgs, ChatCompletionRequestMessage,
5    ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs,
6};
7
8pub trait IntoOpenAIChatMessage {
9    fn into_openai_messages(self) -> Result<Vec<ChatCompletionRequestMessage>>;
10}
11
12impl IntoOpenAIChatMessage for Vec<ChatMessage> {
13    fn into_openai_messages(self) -> Result<Vec<ChatCompletionRequestMessage>> {
14        self.into_iter()
15            .map(|msg| {
16                Ok(match msg.role() {
17                    Role::System => ChatCompletionRequestSystemMessageArgs::default()
18                        .content(msg.content())
19                        .build()?
20                        .into(),
21                    Role::User => ChatCompletionRequestUserMessageArgs::default()
22                        .content(msg.content())
23                        .build()?
24                        .into(),
25                    Role::Assistant => ChatCompletionRequestAssistantMessageArgs::default()
26                        .content(msg.content())
27                        .build()?
28                        .into(),
29                })
30            })
31            .collect()
32    }
33}
34
35#[cfg(test)]
36mod tests {
37    use super::*;
38
39    #[test]
40    fn test_message_conversion() -> Result<()> {
41        let messages = vec![
42            ChatMessage::new(Role::System, "You are a helpful assistant"),
43            ChatMessage::new(Role::User, "Hello!"),
44            ChatMessage::new(Role::Assistant, "Hi there!"),
45        ];
46
47        let openai_messages = messages.into_openai_messages()?;
48        assert_eq!(openai_messages.len(), 3);
49
50        Ok(())
51    }
52
53    #[test]
54    fn test_system_message_conversion() -> Result<()> {
55        let messages = vec![ChatMessage::new(Role::System, "System instruction")];
56
57        let openai_messages = messages.into_openai_messages()?;
58        assert_eq!(openai_messages.len(), 1);
59        assert!(matches!(
60            openai_messages[0],
61            ChatCompletionRequestMessage::System { .. }
62        ));
63
64        Ok(())
65    }
66
67    #[test]
68    fn test_user_message_conversion() -> Result<()> {
69        let messages = vec![ChatMessage::new(Role::User, "User message")];
70
71        let openai_messages = messages.into_openai_messages()?;
72        assert_eq!(openai_messages.len(), 1);
73        assert!(matches!(
74            openai_messages[0],
75            ChatCompletionRequestMessage::User { .. }
76        ));
77
78        Ok(())
79    }
80
81    #[test]
82    fn test_assistant_message_conversion() -> Result<()> {
83        let messages = vec![ChatMessage::new(Role::Assistant, "Assistant response")];
84
85        let openai_messages = messages.into_openai_messages()?;
86        assert_eq!(openai_messages.len(), 1);
87        assert!(matches!(
88            openai_messages[0],
89            ChatCompletionRequestMessage::Assistant { .. }
90        ));
91
92        Ok(())
93    }
94
95    #[test]
96    fn test_empty_messages() -> Result<()> {
97        let messages: Vec<ChatMessage> = vec![];
98        let openai_messages = messages.into_openai_messages()?;
99        assert_eq!(openai_messages.len(), 0);
100        Ok(())
101    }
102}