Skip to main content

edwin/
message.rs

1use async_openai::types::{
2  ChatCompletionMessageToolCall,
3  ChatCompletionRequestAssistantMessageArgs,
4  ChatCompletionRequestMessage, ChatCompletionRequestSystemMessage,
5  ChatCompletionRequestSystemMessageContent,
6  ChatCompletionRequestToolMessage,
7  ChatCompletionRequestToolMessageContent,
8  ChatCompletionRequestUserMessage,
9  ChatCompletionRequestUserMessageContent, ChatCompletionTool,
10  ChatCompletionToolType, FunctionCall, FunctionObject,
11};
12use serde::{Deserialize, Serialize};
13use serde_json::Value;
14
15#[derive(Debug)]
16pub enum Action {
17  Message(String),
18  None,
19  ToolCall(ToolCall),
20}
21
22#[derive(Debug, Clone, PartialEq)]
23pub enum Status {
24  Success,
25  Error,
26}
27
28#[derive(Debug, Clone, PartialEq)]
29pub struct Observation {
30  pub display: Option<String>,
31  pub output: String,
32}
33
34impl Observation {
35  pub fn new(output: String) -> Self {
36    Self {
37      display: None,
38      output: output,
39    }
40  }
41}
42
43#[derive(Debug, Clone, PartialEq)]
44pub enum Role {
45  Assistant,
46  System,
47  ToolOutput,
48  User,
49}
50
51#[derive(Debug, Clone)]
52pub struct Request {
53  pub messages: Vec<Message>,
54  pub tools: Vec<Tool>,
55}
56
57#[derive(Debug, Clone, PartialEq)]
58pub struct Tool {
59  pub name: String,
60  pub description: Option<String>,
61  pub parameters: Option<Value>,
62  pub strict: Option<bool>,
63}
64
65impl From<&Tool> for ChatCompletionTool {
66  fn from(tool: &Tool) -> Self {
67    ChatCompletionTool {
68      r#type: ChatCompletionToolType::Function,
69      function: FunctionObject {
70        name: tool.name.clone(),
71        description: tool.description.clone(),
72        parameters: tool.parameters.clone(),
73        strict: tool.strict.clone(),
74      },
75    }
76  }
77}
78
79#[derive(Debug, Clone, PartialEq)]
80pub struct Message {
81  pub content: String,
82  pub role: Role,
83  pub id: Option<String>,
84  pub tool_calls: Vec<ToolCall>,
85}
86
87impl Message {
88  pub fn new(content: String, role: Role) -> Self {
89    Self {
90      content: content,
91      role,
92      id: None,
93      tool_calls: Vec::new(),
94    }
95  }
96}
97
98impl From<&Message> for ChatCompletionRequestMessage {
99  fn from(msg: &Message) -> Self {
100    match msg.role {
101      Role::Assistant => ChatCompletionRequestMessage::Assistant(
102        ChatCompletionRequestAssistantMessageArgs::default()
103          .content(msg.content.clone())
104          .tool_calls(
105            msg
106              .tool_calls
107              .clone()
108              .into_iter()
109              .map(|tool_call| ChatCompletionMessageToolCall {
110                id: tool_call.id,
111                r#type: ChatCompletionToolType::Function,
112                function: FunctionCall {
113                  name: tool_call.name,
114                  arguments: tool_call.arguments,
115                },
116              })
117              .collect::<Vec<ChatCompletionMessageToolCall>>(),
118          )
119          .build()
120          .unwrap(),
121      ),
122      Role::System => ChatCompletionRequestMessage::System(
123        ChatCompletionRequestSystemMessage {
124          content: ChatCompletionRequestSystemMessageContent::Text(
125            msg.content.clone(),
126          ),
127          name: None,
128        },
129      ),
130      Role::ToolOutput => ChatCompletionRequestMessage::Tool(
131        ChatCompletionRequestToolMessage {
132          content: ChatCompletionRequestToolMessageContent::Text(
133            msg.content.clone(),
134          ),
135          tool_call_id: msg.id.clone().expect("Tool id must be set"),
136        },
137      ),
138      Role::User => ChatCompletionRequestMessage::User(
139        ChatCompletionRequestUserMessage {
140          content: ChatCompletionRequestUserMessageContent::Text(
141            msg.content.clone(),
142          ),
143          name: None,
144        },
145      ),
146    }
147  }
148}
149
150#[derive(Debug, Clone, PartialEq)]
151pub struct Response {
152  pub content: String,
153  pub role: Role,
154  pub tool_calls: Vec<ToolCall>,
155}
156
157#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
158pub struct ToolCall {
159  pub id: String,
160  pub name: String,
161  pub arguments: String,
162}