rustic-ai 0.1.0

A Rust-native agent framework with tool calling, streaming, and multi-provider support for OpenAI, Anthropic, Gemini, and Grok
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
156
157
158

use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::usage::RequestUsage;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ImageUrl {
    pub url: String,
    pub media_type: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct VideoUrl {
    pub url: String,
    pub media_type: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct AudioUrl {
    pub url: String,
    pub media_type: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DocumentUrl {
    pub url: String,
    pub media_type: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct BinaryContent {
    pub data: Vec<u8>,
    pub media_type: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum UserContent {
    Text(String),
    Image(ImageUrl),
    Video(VideoUrl),
    Audio(AudioUrl),
    Document(DocumentUrl),
    Binary(BinaryContent),
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SystemPromptPart {
    pub content: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct UserPromptPart {
    pub content: Vec<UserContent>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolReturnPart {
    pub tool_name: String,
    pub tool_call_id: String,
    pub content: Value,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct RetryPromptPart {
    pub content: String,
    pub tool_name: Option<String>,
    pub tool_call_id: Option<String>,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ModelRequestPart {
    SystemPrompt(SystemPromptPart),
    UserPrompt(UserPromptPart),
    ToolReturn(ToolReturnPart),
    RetryPrompt(RetryPromptPart),
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ModelRequest {
    pub parts: Vec<ModelRequestPart>,
    pub instructions: Option<String>,
}

impl ModelRequest {
    pub fn user_text_prompt(prompt: impl Into<String>) -> Self {
        Self {
            parts: vec![ModelRequestPart::UserPrompt(UserPromptPart {
                content: vec![UserContent::Text(prompt.into())],
            })],
            instructions: None,
        }
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TextPart {
    pub content: String,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ToolCallPart {
    pub id: String,
    pub name: String,
    pub arguments: Value,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ProviderItemPart {
    pub provider: String,
    pub payload: Value,
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ModelResponsePart {
    Text(TextPart),
    ToolCall(ToolCallPart),
    ProviderItem(ProviderItemPart),
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ModelResponse {
    pub parts: Vec<ModelResponsePart>,
    pub usage: Option<RequestUsage>,
    pub model_name: Option<String>,
    pub finish_reason: Option<String>,
}

impl ModelResponse {
    pub fn text(&self) -> Option<String> {
        let mut texts = Vec::new();
        for part in &self.parts {
            if let ModelResponsePart::Text(text) = part {
                texts.push(text.content.clone());
            }
        }
        if texts.is_empty() {
            None
        } else {
            Some(texts.join("\n\n"))
        }
    }

    pub fn tool_calls(&self) -> Vec<ToolCallPart> {
        self.parts
            .iter()
            .filter_map(|part| match part {
                ModelResponsePart::ToolCall(call) => Some(call.clone()),
                _ => None,
            })
            .collect()
    }
}

#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum ModelMessage {
    Request(ModelRequest),
    Response(ModelResponse),
}