open_ai_rust 0.2.16

Open AI SDK for Rust. To my knowledge, the only fully comprehensive and up-to-date Open AI crate built in and for Rust. Provides both low-level control with high level ergonomics for doing cool things (the whole reason we use Rust in the first place). Is maintained and has been used and tested in products used in production.
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
111
112
113
114
115
116
117
118

use crate::logoi::{input::tool::{FunctionCall, ToolChoice, ToolType}, message::ChatMessage, models::OpenAiModel};

use super::ChatPayLoad;


/// This is a bunch of shorthand templates since you likely will not want to manually write out every setting,
/// but still want error handling to make sure you don't miss out on crucial features.
pub enum PayLoadTemplates {
    Chat(QuickChatTemplate),
    FunctionCall(QuickFunctionCallTemplate),
}

impl PayLoadTemplates {
    pub fn default(messages: Vec<ChatMessage>) -> Self {
        Self::Chat(QuickChatTemplate::default(messages))
    }

    pub fn to_payload(self) -> ChatPayLoad {
        match self {
            Self::Chat(template) => template.to_payload(),
            Self::FunctionCall(template) => ChatPayLoad {
                model: template.model,
                messages: template.messages,
                tools: template.tools,
                tool_choice: Some("auto".to_string()),
                frequency_penalty: None,
                logprobs: None,
                top_logprobs: None,
                max_tokens: None,
                n: None,
                presence_penalty: None,
                response_format: None,
                seed: None,
                service_tier: None,
                stop: None,
                stream: None,
                stream_options: None,
                temperature: None,
                top_p: None,
                user: None,
            }
        }
    }
}

pub struct QuickChatTemplate {
    pub model: OpenAiModel,
    pub messages: Vec<ChatMessage>,
}

impl QuickChatTemplate {
    pub fn default(messages: Vec<ChatMessage>) -> Self {
        Self {
            model: OpenAiModel::GPT4o,
            messages
        }
    }

    pub fn to_payload(self) -> crate::logoi::input::payload::ChatPayLoad {
        ChatPayLoad {
            model: self.model,
            messages: self.messages,
            frequency_penalty: None,
            logprobs: None,
            top_logprobs: None,
            max_tokens: None,
            n: None,
            presence_penalty: None,
            response_format: None,
            seed: None,
            service_tier: None,
            stop: None,
            stream: None,
            stream_options: None,
            temperature: None,
            top_p: None,
            tools: None,
            user: None,
            tool_choice: None,
        }
    }
}

// let payload = json!({
//     "model": MODEL,
//     "messages": messages,
//     "tools": processed_functions,
//     "tool_choice": match tool_choice_name {
//         Some(tool_choice_name) => json!({
//             "type": "function",
//             "function": {
//                 "name": tool_choice_name
//             }
//         }),
//         None => json!("auto".to_string())
//     }
// });
pub struct QuickFunctionCallTemplate {
    pub model: OpenAiModel,
    pub messages: Vec<ChatMessage>,
    pub tools: Option<Vec<ToolChoice>>,
    pub tool_choice: Option<FunctionCall>,
}

impl QuickFunctionCallTemplate {
    pub fn default(messages: Vec<ChatMessage>, functions: Vec<FunctionCall>, tool_choice: Option<FunctionCall>) -> Self {
        let mut tools: Vec<ToolChoice> = vec![];
        for f in functions {
            tools.push(ToolChoice { function: f, _type: ToolType::Function });
        }
        Self {
            model: OpenAiModel::GPT4o,
            messages,
            tools: Some(tools),
            tool_choice
        }
    }
}