gpt_rs/chat/
model.rs

1use serde::{Deserialize, Serialize};
2use std::convert::From;
3
4#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
5pub struct CompletionRequest {
6    pub model: String,
7    pub messages: Vec<Message>,
8    pub temperature: f64,
9}
10
11#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
12pub struct Message {
13    pub role: Role,
14    pub content: String,
15    #[serde(skip_serializing_if = "Option::is_none")]
16    pub name: Option<String>,
17    // pub function_call: Option<String>,
18}
19
20impl From<&str> for Message {
21    fn from(value: &str) -> Self {
22        Self {
23            role: Role::User.into(),
24            content: value.to_string(),
25            name: None,
26            // function_call: None,
27        }
28    }
29}
30
31#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
32#[serde(rename_all = "lowercase")]
33pub enum Role {
34    System,
35    User,
36    Assistant,
37    Function,
38}
39impl From<Role> for &str {
40    fn from(value: Role) -> Self {
41        match value {
42            Role::System => "system",
43            Role::User => "user",
44            Role::Assistant => "assistant",
45            Role::Function => "function",
46        }
47    }
48}
49impl From<Role> for String {
50    fn from(value: Role) -> Self {
51        let value: &str = value.into();
52        value.to_string()
53    }
54}
55
56#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
57pub struct CompletionResponse {
58    pub id: String,
59    pub object: String,
60    pub created: u64,
61    pub model: String,
62    pub usage: Usage,
63    pub choices: Vec<Choice>,
64}
65
66#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
67pub struct Usage {
68    pub prompt_tokens: u64,
69    pub completion_tokens: u64,
70    pub total_tokens: u64,
71}
72
73#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
74pub struct Choice {
75    pub message: Message,
76    pub finish_reason: String,
77    pub index: u64,
78}