use rig_core::completion::{CompletionRequest, Message, ToolDefinition, Usage};
use rig_core::conversation::MessageId;
use rig_core::json_utils::json_len;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy)]
pub struct HeuristicTokenCounter {
bytes_per_token: f32,
per_message_overhead: usize,
per_attachment_tokens: usize,
}
impl HeuristicTokenCounter {
fn bytes_to_tokens(&self, bytes: usize) -> usize {
let tokens = (bytes as f32) / self.bytes_per_token;
tokens.ceil() as usize
}
pub fn count_tool(&self, tool: &ToolDefinition) -> usize {
let bytes = tool.name.len().saturating_add(tool.description.len());
self.bytes_to_tokens(bytes.saturating_add(json_len(&tool.parameters)))
.saturating_add(self.per_message_overhead)
}
pub(crate) fn count_user(&self, content: &rig_core::message::UserContent) -> usize {
use rig_core::message::UserContent;
match content {
UserContent::Text(text) => self.bytes_to_tokens(text.text.len()),
UserContent::ToolResult(result) => result
.content
.iter()
.map(|c| match c {
rig_core::message::ToolResultContent::Text(t) => {
self.bytes_to_tokens(t.text.len())
}
rig_core::message::ToolResultContent::Json { value } => {
self.bytes_to_tokens(json_len(value))
}
rig_core::message::ToolResultContent::Image(_) => self.per_attachment_tokens,
})
.fold(0, usize::saturating_add),
UserContent::Image(_)
| UserContent::Audio(_)
| UserContent::Video(_)
| UserContent::Document(_) => self.per_attachment_tokens,
}
}
fn count_assistant(&self, content: &rig_core::message::AssistantContent) -> usize {
use rig_core::message::AssistantContent;
match content {
AssistantContent::Text(text) => self.bytes_to_tokens(text.text.len()),
AssistantContent::Reasoning(reasoning) => self.bytes_to_tokens(reasoning.text.len()),
AssistantContent::ToolCall(call) => {
let name_bytes = call.function.name.len();
let args_bytes = json_len(&call.function.arguments);
self.bytes_to_tokens(name_bytes + args_bytes)
}
AssistantContent::Image(_) => self.per_attachment_tokens,
AssistantContent::Opaque(opaque) => self.bytes_to_tokens(json_len(&opaque.item)),
other => self.bytes_to_tokens(json_len(other)),
}
}
}
pub const ATTACHMENT_TOKENS: usize = 1_200;
impl Default for HeuristicTokenCounter {
fn default() -> Self {
Self {
bytes_per_token: 4.0,
per_message_overhead: 4,
per_attachment_tokens: ATTACHMENT_TOKENS,
}
}
}
impl HeuristicTokenCounter {
pub fn count(&self, message: &Message) -> usize {
let content_tokens: usize = match message {
Message::User { content } => content
.iter()
.map(|c| self.count_user(c))
.fold(0, usize::saturating_add),
Message::Assistant(turn) => turn
.content
.iter()
.map(|c| self.count_assistant(c))
.fold(0, usize::saturating_add),
Message::System { content } => self.bytes_to_tokens(content.len()),
};
content_tokens.saturating_add(self.per_message_overhead)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Anchor {
pub usage: Usage,
pub through: MessageId,
}
pub fn request_estimate(request: &CompletionRequest) -> u64 {
let counter = HeuristicTokenCounter::default();
let tools = request.tools.iter().map(|tool| counter.count_tool(tool));
let messages = request
.chat_history
.iter()
.map(|message| counter.count(message));
tools.chain(messages).fold(0, usize::saturating_add) as u64
}
#[cfg(test)]
mod tests;