use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Message {
pub id: String,
pub model: String,
#[serde(default)]
pub content: Vec<ContentBlock>,
pub stop_reason: Option<StopReason>,
#[serde(default)]
pub stop_sequence: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stop_details: Option<Value>,
#[serde(default)]
pub usage: Usage,
}
impl Message {
pub fn text(&self) -> String {
self.content
.iter()
.filter_map(|b| match b {
ContentBlock::Text { text, .. } => Some(text.as_str()),
_ => None,
})
.collect()
}
pub fn is_refusal(&self) -> bool {
self.stop_reason == Some(StopReason::Refusal)
}
pub fn citations(&self) -> impl Iterator<Item = (&str, &Citation)> {
self.content.iter().flat_map(|b| match b {
ContentBlock::Text { text, citations } => citations.iter().map(move |c| (text.as_str(), c)).collect::<Vec<_>>(),
_ => Vec::new(),
})
}
pub fn web_search_results(&self) -> impl Iterator<Item = &WebSearchResult> {
self.content.iter().flat_map(|b| match b {
ContentBlock::WebSearchToolResult { content: WebSearchContent::Results(r), .. } => r.iter().collect::<Vec<_>>(),
_ => Vec::new(),
})
}
pub fn server_tool_errors(&self) -> impl Iterator<Item = (&str, &ServerToolError)> {
self.content.iter().filter_map(|b| {
let err = match b {
ContentBlock::WebSearchToolResult { content: WebSearchContent::Error(e), .. }
| ContentBlock::WebFetchToolResult { content: WebFetchContent::Error(e), .. }
| ContentBlock::BashCodeExecutionToolResult { content: CodeExecutionContent::Error(e), .. }
| ContentBlock::CodeExecutionToolResult { content: CodeExecutionContent::Error(e), .. }
| ContentBlock::ToolSearchToolResult { content: ToolSearchContent::Error(e), .. } => e,
_ => return None,
};
Some((b.server_tool_result_id()?, err))
})
}
pub fn tool_uses(&self) -> impl Iterator<Item = (&str, &str, &Value)> {
self.content.iter().filter_map(|b| match b {
ContentBlock::ToolUse { id, name, input } => Some((id.as_str(), name.as_str(), input)),
_ => None,
})
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Self", tag = "type", rename_all = "snake_case")]
pub enum ContentBlock {
Text {
text: String,
#[serde(default, skip_serializing_if = "Vec::is_empty", deserialize_with = "null_as_empty")]
citations: Vec<Citation>,
},
Thinking {
#[serde(default)]
thinking: String,
#[serde(default)]
signature: String,
},
RedactedThinking {
data: String,
},
ToolUse {
id: String,
name: String,
#[serde(default)]
input: Value,
},
ServerToolUse {
id: String,
name: String,
#[serde(default)]
input: Value,
#[serde(flatten)]
extra: Map<String, Value>,
},
WebSearchToolResult {
tool_use_id: String,
content: WebSearchContent,
#[serde(flatten)]
extra: Map<String, Value>,
},
WebFetchToolResult {
tool_use_id: String,
content: WebFetchContent,
#[serde(flatten)]
extra: Map<String, Value>,
},
BashCodeExecutionToolResult {
tool_use_id: String,
content: CodeExecutionContent,
#[serde(flatten)]
extra: Map<String, Value>,
},
CodeExecutionToolResult {
tool_use_id: String,
content: CodeExecutionContent,
#[serde(flatten)]
extra: Map<String, Value>,
},
TextEditorCodeExecutionToolResult {
tool_use_id: String,
content: Value,
#[serde(flatten)]
extra: Map<String, Value>,
},
ToolSearchToolResult {
tool_use_id: String,
content: ToolSearchContent,
#[serde(flatten)]
extra: Map<String, Value>,
},
Fallback {
from: ModelRef,
to: ModelRef,
},
#[serde(skip)]
Other(Value),
}
open_enum!(
ContentBlock,
[
"text",
"thinking",
"redacted_thinking",
"tool_use",
"server_tool_use",
"web_search_tool_result",
"web_fetch_tool_result",
"bash_code_execution_tool_result",
"code_execution_tool_result",
"text_editor_code_execution_tool_result",
"tool_search_tool_result",
"fallback",
]
);
impl ContentBlock {
pub fn server_tool_result_id(&self) -> Option<&str> {
match self {
ContentBlock::WebSearchToolResult { tool_use_id, .. }
| ContentBlock::WebFetchToolResult { tool_use_id, .. }
| ContentBlock::BashCodeExecutionToolResult { tool_use_id, .. }
| ContentBlock::CodeExecutionToolResult { tool_use_id, .. }
| ContentBlock::TextEditorCodeExecutionToolResult { tool_use_id, .. }
| ContentBlock::ToolSearchToolResult { tool_use_id, .. } => Some(tool_use_id),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServerToolError {
pub error_code: String,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WebSearchContent {
Results(Vec<WebSearchResult>),
Error(ServerToolError),
Other(Value),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebSearchResult {
pub url: String,
#[serde(default)]
pub title: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub page_age: Option<String>,
#[serde(default)]
pub encrypted_content: String,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WebFetchContent {
Page(WebFetchResult),
Error(ServerToolError),
Other(Value),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebFetchResult {
pub url: String,
pub content: Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub retrieved_at: Option<String>,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
impl WebFetchResult {
pub fn text(&self) -> Option<&str> {
self.content.get("source").and_then(|s| s.get("data")).and_then(Value::as_str)
}
pub fn title(&self) -> Option<&str> {
self.content.get("title").and_then(Value::as_str)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CodeExecutionContent {
Output(CodeExecutionOutput),
Error(ServerToolError),
Other(Value),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CodeExecutionOutput {
#[serde(default)]
pub stdout: String,
#[serde(default)]
pub stderr: String,
pub return_code: i64,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub content: Vec<Value>,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
impl CodeExecutionOutput {
pub fn file_ids(&self) -> impl Iterator<Item = &str> {
self.content.iter().filter_map(|f| f.get("file_id").and_then(Value::as_str))
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ToolSearchContent {
Found(ToolSearchFound),
Error(ServerToolError),
Other(Value),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolSearchFound {
pub tool_references: Vec<ToolReference>,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ToolReference {
pub tool_name: String,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ModelRef {
pub model: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Self", tag = "type", rename_all = "snake_case")]
pub enum Citation {
CharLocation {
cited_text: String,
document_index: usize,
#[serde(default)]
document_title: Option<String>,
start_char_index: usize,
end_char_index: usize,
},
PageLocation {
cited_text: String,
document_index: usize,
#[serde(default)]
document_title: Option<String>,
start_page_number: usize,
end_page_number: usize,
},
ContentBlockLocation {
cited_text: String,
document_index: usize,
#[serde(default)]
document_title: Option<String>,
start_block_index: usize,
end_block_index: usize,
},
WebSearchResultLocation {
url: String,
#[serde(default)]
title: Option<String>,
#[serde(default)]
cited_text: String,
#[serde(default)]
encrypted_index: String,
},
#[serde(skip)]
Other(Value),
}
open_enum!(Citation, ["char_location", "page_location", "content_block_location", "web_search_result_location"]);
impl Citation {
pub fn cited_text(&self) -> Option<&str> {
match self {
Citation::CharLocation { cited_text, .. }
| Citation::PageLocation { cited_text, .. }
| Citation::ContentBlockLocation { cited_text, .. }
| Citation::WebSearchResultLocation { cited_text, .. } => Some(cited_text),
Citation::Other(v) => v.get("cited_text").and_then(Value::as_str),
}
}
pub fn document_index(&self) -> Option<usize> {
match self {
Citation::CharLocation { document_index, .. }
| Citation::PageLocation { document_index, .. }
| Citation::ContentBlockLocation { document_index, .. } => Some(*document_index),
Citation::WebSearchResultLocation { .. } => None,
Citation::Other(v) => v.get("document_index").and_then(Value::as_u64).map(|i| i as usize),
}
}
pub fn url(&self) -> Option<&str> {
match self {
Citation::WebSearchResultLocation { url, .. } => Some(url),
Citation::Other(v) => v.get("url").and_then(Value::as_str),
_ => None,
}
}
}
fn null_as_empty<'de, D: serde::Deserializer<'de>>(d: D) -> Result<Vec<Citation>, D::Error> {
Ok(Option::<Vec<Citation>>::deserialize(d)?.unwrap_or_default())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StopReason {
EndTurn,
MaxTokens,
StopSequence,
ToolUse,
PauseTurn,
Refusal,
Other(String),
}
impl StopReason {
pub fn as_str(&self) -> &str {
match self {
StopReason::EndTurn => "end_turn",
StopReason::MaxTokens => "max_tokens",
StopReason::StopSequence => "stop_sequence",
StopReason::ToolUse => "tool_use",
StopReason::PauseTurn => "pause_turn",
StopReason::Refusal => "refusal",
StopReason::Other(s) => s,
}
}
}
impl From<String> for StopReason {
fn from(s: String) -> StopReason {
match s.as_str() {
"end_turn" => StopReason::EndTurn,
"max_tokens" => StopReason::MaxTokens,
"stop_sequence" => StopReason::StopSequence,
"tool_use" => StopReason::ToolUse,
"pause_turn" => StopReason::PauseTurn,
"refusal" => StopReason::Refusal,
_ => StopReason::Other(s),
}
}
}
impl Serialize for StopReason {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(self.as_str())
}
}
impl<'de> Deserialize<'de> for StopReason {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
String::deserialize(d).map(StopReason::from)
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Usage {
#[serde(default)]
pub input_tokens: u64,
#[serde(default)]
pub output_tokens: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cache_creation_input_tokens: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub cache_read_input_tokens: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub server_tool_use: Option<ServerToolUsage>,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
impl Usage {
pub(crate) fn merge(&mut self, delta: &Map<String, Value>) {
for (k, v) in delta {
if v.is_null() {
continue;
}
match k.as_str() {
"input_tokens" => self.input_tokens = v.as_u64().unwrap_or(self.input_tokens),
"output_tokens" => self.output_tokens = v.as_u64().unwrap_or(self.output_tokens),
"cache_creation_input_tokens" => self.cache_creation_input_tokens = v.as_u64(),
"cache_read_input_tokens" => self.cache_read_input_tokens = v.as_u64(),
"server_tool_use" => self.server_tool_use = serde_json::from_value(v.clone()).ok(),
_ => {
self.extra.insert(k.clone(), v.clone());
}
}
}
}
}
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ServerToolUsage {
#[serde(default)]
pub web_search_requests: u64,
#[serde(default)]
pub web_fetch_requests: u64,
#[serde(flatten)]
pub extra: Map<String, Value>,
}