1use rig_core::completion::{CompletionRequest, Message, ToolDefinition, Usage};
5use rig_core::conversation::MessageId;
6use rig_core::json_utils::json_len;
7use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Clone, Copy)]
21pub struct HeuristicTokenCounter {
22 bytes_per_token: f32,
23 per_message_overhead: usize,
24 per_attachment_tokens: usize,
25}
26
27impl HeuristicTokenCounter {
28 fn bytes_to_tokens(&self, bytes: usize) -> usize {
29 let tokens = (bytes as f32) / self.bytes_per_token;
31 tokens.ceil() as usize
32 }
33
34 pub fn count_tool(&self, tool: &ToolDefinition) -> usize {
37 let bytes = tool.name.len().saturating_add(tool.description.len());
38 self.bytes_to_tokens(bytes.saturating_add(json_len(&tool.parameters)))
39 .saturating_add(self.per_message_overhead)
40 }
41
42 pub(crate) fn count_user(&self, content: &rig_core::message::UserContent) -> usize {
45 use rig_core::message::UserContent;
46 match content {
47 UserContent::Text(text) => self.bytes_to_tokens(text.text.len()),
48 UserContent::ToolResult(result) => result
49 .content
50 .iter()
51 .map(|c| match c {
52 rig_core::message::ToolResultContent::Text(t) => {
53 self.bytes_to_tokens(t.text.len())
54 }
55 rig_core::message::ToolResultContent::Json { value } => {
56 self.bytes_to_tokens(json_len(value))
57 }
58 rig_core::message::ToolResultContent::Image(_) => self.per_attachment_tokens,
59 })
60 .fold(0, usize::saturating_add),
61 UserContent::Image(_)
62 | UserContent::Audio(_)
63 | UserContent::Video(_)
64 | UserContent::Document(_) => self.per_attachment_tokens,
65 }
66 }
67
68 fn count_assistant(&self, content: &rig_core::message::AssistantContent) -> usize {
71 use rig_core::message::AssistantContent;
72 match content {
73 AssistantContent::Text(text) => self.bytes_to_tokens(text.text.len()),
74 AssistantContent::Reasoning(reasoning) => self.bytes_to_tokens(reasoning.text.len()),
75 AssistantContent::ToolCall(call) => {
76 let name_bytes = call.function.name.len();
77 let args_bytes = json_len(&call.function.arguments);
78 self.bytes_to_tokens(name_bytes + args_bytes)
79 }
80 AssistantContent::Image(_) => self.per_attachment_tokens,
81 AssistantContent::Opaque(opaque) => self.bytes_to_tokens(json_len(&opaque.item)),
83 other => self.bytes_to_tokens(json_len(other)),
84 }
85 }
86}
87
88pub const ATTACHMENT_TOKENS: usize = 1_200;
90
91impl Default for HeuristicTokenCounter {
92 fn default() -> Self {
95 Self {
96 bytes_per_token: 4.0,
97 per_message_overhead: 4,
98 per_attachment_tokens: ATTACHMENT_TOKENS,
99 }
100 }
101}
102
103impl HeuristicTokenCounter {
104 pub fn count(&self, message: &Message) -> usize {
106 let content_tokens: usize = match message {
107 Message::User { content } => content
108 .iter()
109 .map(|c| self.count_user(c))
110 .fold(0, usize::saturating_add),
111 Message::Assistant(turn) => turn
112 .content
113 .iter()
114 .map(|c| self.count_assistant(c))
115 .fold(0, usize::saturating_add),
116 Message::System { content } => self.bytes_to_tokens(content.len()),
117 };
118 content_tokens.saturating_add(self.per_message_overhead)
119 }
120}
121
122#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
127pub struct Anchor {
128 pub usage: Usage,
131 pub through: MessageId,
133}
134
135pub fn request_estimate(request: &CompletionRequest) -> u64 {
146 let counter = HeuristicTokenCounter::default();
147 let tools = request.tools.iter().map(|tool| counter.count_tool(tool));
148 let messages = request
149 .chat_history
150 .iter()
151 .map(|message| counter.count(message));
152 tools.chain(messages).fold(0, usize::saturating_add) as u64
153}
154
155#[cfg(test)]
156mod tests;