ai-providers 0.0.1

A comprehensive collection of AI provider implementations, schematics, and API integrations for various AI services
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::openai::errors::ConversionError;
use crate::openai::request::input_models::common::{Content, Role};
use crate::openai::request::input_models::input_reference::InputReference;
use crate::openai::request::input_models::item::Item;
use serde::{Deserialize, Serialize};
use std::str::FromStr;

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TextInput {
    pub role: Role,
    pub content: String,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_field: Option<String>,
}

impl TextInput {
    pub fn new(content: impl Into<String>) -> Self {
        Self {
            role: Role::default(),
            content: content.into(),
            type_field: None,
        }
    }

    pub fn role(mut self, role: impl AsRef<str>) -> Result<Self, ConversionError> {
        self.role = Role::from_str(role.as_ref())?;
        Ok(self)
    }

    pub fn insert_type(mut self) -> Self {
        self.type_field = Some("message".to_string());
        self
    }
}

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct InputItemContentList {
    pub role: Role,
    pub content: Vec<Content>,
    #[serde(rename = "type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_field: Option<String>,
}

impl InputItemContentList {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn role(mut self, role: impl AsRef<str>) -> Result<Self, ConversionError> {
        self.role = Role::from_str(role.as_ref())?;
        Ok(self)
    }

    pub fn insert_type(mut self) -> Self {
        self.type_field = Some("message".to_string());
        self
    }
}

impl From<Item> for InputItemContentList {
    fn from(_item: Item) -> Self {
        Self {
            role: Role::default(),
            content: Vec::new(),
            type_field: Some("message".to_string()),
        }
    }
}

impl From<InputReference> for InputItemContentList {
    fn from(_reference: InputReference) -> Self {
        Self {
            role: Role::default(),
            content: Vec::new(),
            type_field: Some("message".to_string()),
        }
    }
}

#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InputMessage {
    TextInput(TextInput),
    InputItemContentList(InputItemContentList),
}

impl From<TextInput> for InputMessage {
    fn from(text_input: TextInput) -> Self {
        InputMessage::TextInput(text_input)
    }
}

impl From<InputItemContentList> for InputMessage {
    fn from(content_list: InputItemContentList) -> Self {
        InputMessage::InputItemContentList(content_list)
    }
}

#[cfg(test)]
mod tests {
    use crate::openai::request::input_models::common::TextContent;

    use super::*;

    #[test]
    fn test_json_values() {
        let text_input = TextInput::new("Hello, world!");
        let input_message: InputMessage = text_input.clone().into();
        assert_eq!(input_message, InputMessage::TextInput(text_input));

        let json_value = serde_json::to_value(&input_message).unwrap();
        assert_eq!(
            json_value,
            serde_json::json!({
                "role": "user",
                "content": "Hello, world!"
            })
        );
    }

    #[test]
    fn test_json_values_input_item_content_list() {
        let mut input_item_content_list = InputItemContentList::new()
            .insert_type()
            .role("developer")
            .unwrap();

        input_item_content_list
            .content
            .push(Content::Text(TextContent::new().text("Hello, world!")));

        let input_message: InputMessage = input_item_content_list.clone().into();
        assert_eq!(
            input_message,
            InputMessage::InputItemContentList(input_item_content_list)
        );

        let json_value = serde_json::to_value(&input_message).unwrap();
        assert_eq!(
            json_value,
            serde_json::json!({
                "role": "developer",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Hello, world!"
                    }
                ],
                "type": "message"
            })
        );
    }
}