asimov_prompt/
prompt_message.rs

1// This is free and unencumbered software released into the public domain.
2
3use super::prompt_role::PromptRole;
4use derive_more::Display;
5use dogma::prelude::{FromStr, String};
6
7#[derive(Clone, Debug, Display, Eq, Hash, Ord, PartialEq, PartialOrd)]
8#[display("{_0}: {_1}")]
9pub struct PromptMessage(pub PromptRole, pub String);
10
11impl FromStr for PromptMessage {
12    type Err = ();
13
14    fn from_str(input: &str) -> Result<Self, Self::Err> {
15        Ok((PromptRole::User, input).into())
16    }
17}
18
19impl From<&str> for PromptMessage {
20    fn from(input: &str) -> Self {
21        (PromptRole::User, input).into()
22    }
23}
24
25impl From<String> for PromptMessage {
26    fn from(input: String) -> Self {
27        (PromptRole::User, input).into()
28    }
29}
30
31impl From<(PromptRole, &str)> for PromptMessage {
32    fn from((role, message): (PromptRole, &str)) -> Self {
33        PromptMessage(role, message.into())
34    }
35}
36
37impl From<(PromptRole, String)> for PromptMessage {
38    fn from((role, message): (PromptRole, String)) -> Self {
39        PromptMessage(role, message)
40    }
41}
42
43#[cfg(feature = "openai")]
44impl TryFrom<&openai::schemas::ChatCompletionRequestMessage> for PromptMessage {
45    type Error = ();
46
47    fn try_from(
48        input: &openai::schemas::ChatCompletionRequestMessage,
49    ) -> Result<Self, Self::Error> {
50        use PromptRole::*;
51        match (input.role(), input.text_content()) {
52            ("assistant", Some(message)) => Ok(PromptMessage(Assistant, message.into())),
53            ("developer", Some(message)) => Ok(PromptMessage(Developer, message.into())),
54            ("system", Some(message)) => Ok(PromptMessage(System, message.into())),
55            ("user", Some(message)) => Ok(PromptMessage(User, message.into())),
56            _ => Err(()),
57        }
58    }
59}
60
61#[cfg(feature = "openai")]
62impl TryFrom<openai::schemas::ChatCompletionRequestAssistantMessage> for PromptMessage {
63    type Error = ();
64
65    fn try_from(
66        input: openai::schemas::ChatCompletionRequestAssistantMessage,
67    ) -> Result<Self, Self::Error> {
68        input.content.ok_or(())?.try_into()
69    }
70}
71
72#[cfg(feature = "openai")]
73impl TryFrom<openai::schemas::ChatCompletionRequestAssistantMessage_Content> for PromptMessage {
74    type Error = ();
75
76    fn try_from(
77        input: openai::schemas::ChatCompletionRequestAssistantMessage_Content,
78    ) -> Result<Self, Self::Error> {
79        let text_content = input.text_content().ok_or(())?;
80        Ok(PromptMessage(PromptRole::Assistant, text_content.into()))
81    }
82}
83
84#[cfg(feature = "openai")]
85impl TryFrom<openai::schemas::ChatCompletionRequestDeveloperMessage> for PromptMessage {
86    type Error = ();
87
88    fn try_from(
89        input: openai::schemas::ChatCompletionRequestDeveloperMessage,
90    ) -> Result<Self, Self::Error> {
91        input.content.try_into()
92    }
93}
94
95#[cfg(feature = "openai")]
96impl TryFrom<openai::schemas::ChatCompletionRequestDeveloperMessage_Content> for PromptMessage {
97    type Error = ();
98
99    fn try_from(
100        input: openai::schemas::ChatCompletionRequestDeveloperMessage_Content,
101    ) -> Result<Self, Self::Error> {
102        let text_content = input.text_content().ok_or(())?;
103        Ok(PromptMessage(PromptRole::Developer, text_content.into()))
104    }
105}
106
107#[cfg(feature = "openai")]
108impl TryFrom<openai::schemas::ChatCompletionRequestSystemMessage> for PromptMessage {
109    type Error = ();
110
111    fn try_from(
112        input: openai::schemas::ChatCompletionRequestSystemMessage,
113    ) -> Result<Self, Self::Error> {
114        input.content.try_into()
115    }
116}
117
118#[cfg(feature = "openai")]
119impl TryFrom<openai::schemas::ChatCompletionRequestSystemMessage_Content> for PromptMessage {
120    type Error = ();
121
122    fn try_from(
123        input: openai::schemas::ChatCompletionRequestSystemMessage_Content,
124    ) -> Result<Self, Self::Error> {
125        let text_content = input.text_content().ok_or(())?;
126        Ok(PromptMessage(PromptRole::Developer, text_content.into()))
127    }
128}
129
130#[cfg(feature = "openai")]
131impl TryFrom<openai::schemas::ChatCompletionRequestUserMessage> for PromptMessage {
132    type Error = ();
133
134    fn try_from(
135        input: openai::schemas::ChatCompletionRequestUserMessage,
136    ) -> Result<Self, Self::Error> {
137        input.content.try_into()
138    }
139}
140
141#[cfg(feature = "openai")]
142impl TryFrom<openai::schemas::ChatCompletionRequestUserMessage_Content> for PromptMessage {
143    type Error = ();
144
145    fn try_from(
146        input: openai::schemas::ChatCompletionRequestUserMessage_Content,
147    ) -> Result<Self, Self::Error> {
148        let text_content = input.text_content().ok_or(())?;
149        Ok(PromptMessage(PromptRole::User, text_content.into()))
150    }
151}