use indexmap::IndexMap;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TextContent {
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub text_signature: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ThinkingContent {
pub thinking: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub thinking_signature: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub redacted: Option<bool>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ImageContent {
pub data: String,
pub mime_type: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolCall {
pub id: String,
pub name: String,
pub arguments: Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub thought_signature: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum UserContent {
Text(TextContent),
Image(ImageContent),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum AssistantContent {
Text(TextContent),
Thinking(ThinkingContent),
ToolCall(ToolCall),
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Cost {
pub input: f64,
pub output: f64,
pub cache_read: f64,
pub cache_write: f64,
pub total: f64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Usage {
pub input: u64,
pub output: u64,
pub cache_read: u64,
pub cache_write: u64,
#[serde(rename = "cacheWrite1h", default, skip_serializing_if = "Option::is_none")]
pub cache_write_1h: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reasoning: Option<u64>,
pub total_tokens: u64,
pub cost: Cost,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum StopReason {
Pending,
Stop,
Length,
ToolUse,
Error,
Aborted,
Deferred,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DiagnosticErrorInfo {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
pub message: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stack: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AssistantMessageDiagnostic {
#[serde(rename = "type")]
pub kind: String,
pub timestamp: i64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<DiagnosticErrorInfo>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub details: Option<Map<String, Value>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DeferredHandle {
pub provider: String,
pub model_id: String,
pub api: String,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub expires_at: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub poll_after_ms: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub data: Option<Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum ConstrainedSamplingConfig {
#[serde(rename = "json_schema")]
JsonSchema {
strict: StrictMode,
},
Grammar {
variants: GrammarVariants,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum StrictMode {
Prefer,
Require,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct GrammarVariants {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub openai_lark: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub openai_regex: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ConstrainedSampling {
Disabled(bool),
Config(ConstrainedSamplingConfig),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Tool {
pub name: String,
pub description: String,
pub parameters: Value,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub constrained_sampling: Option<ConstrainedSampling>,
}
impl Tool {
pub(crate) fn sampling_config(&self) -> Option<&ConstrainedSamplingConfig> {
match &self.constrained_sampling {
Some(ConstrainedSampling::Config(config)) => Some(config),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ToolReference {
pub name: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SystemContent {
Text(String),
Blocks(Vec<TypedText>),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum TypedText {
Text(TextContent),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UserMessageContent {
Text(String),
Blocks(Vec<UserContent>),
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "role", rename = "system", rename_all = "camelCase")]
pub struct SystemMessage {
pub content: SystemContent,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sections: Option<IndexMap<String, Option<String>>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tools_added: Option<Vec<Tool>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tools_removed: Option<Vec<ToolReference>>,
pub timestamp: i64,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "role", rename = "user")]
pub struct UserMessage {
pub content: UserMessageContent,
pub timestamp: i64,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "role", rename = "assistant", rename_all = "camelCase")]
pub struct AssistantMessage {
pub content: Vec<AssistantContent>,
pub api: String,
pub provider: String,
pub model: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub response_model: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub response_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider_thinking_level: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub diagnostics: Option<Vec<AssistantMessageDiagnostic>>,
pub usage: Usage,
pub stop_reason: StopReason,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deferred: Option<DeferredHandle>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub raw_stop_reason: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub end_turn: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider_metadata: Option<Map<String, Value>>,
pub timestamp: i64,
}
impl AssistantMessage {
pub(crate) fn pending(model: &Model, timestamp: i64) -> Self {
AssistantMessage {
content: Vec::new(),
api: model.api.clone(),
provider: model.provider.clone(),
model: model.id.clone(),
response_model: None,
response_id: None,
provider_thinking_level: None,
diagnostics: None,
usage: Usage::default(),
stop_reason: StopReason::Pending,
deferred: None,
error_message: None,
raw_stop_reason: None,
end_turn: None,
provider_metadata: None,
timestamp,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "role", rename = "toolResult", rename_all = "camelCase")]
pub struct ToolResultMessage {
pub tool_call_id: String,
pub tool_name: String,
pub content: Vec<UserContent>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub details: Option<Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage: Option<Usage>,
pub is_error: bool,
pub timestamp: i64,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
#[serde(untagged)]
#[allow(clippy::large_enum_variant)] pub enum Message {
System(SystemMessage),
User(UserMessage),
Assistant(AssistantMessage),
ToolResult(ToolResultMessage),
}
impl<'de> Deserialize<'de> for Message {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::Error;
let value = Value::deserialize(deserializer)?;
let parsed = match value.get("role").and_then(Value::as_str) {
Some("system") => serde_json::from_value(value).map(Message::System),
Some("user") => serde_json::from_value(value).map(Message::User),
Some("assistant") => serde_json::from_value(value).map(Message::Assistant),
Some("toolResult") => serde_json::from_value(value).map(Message::ToolResult),
other => return Err(D::Error::custom(format!("unknown message role {other:?}"))),
};
parsed.map_err(D::Error::custom)
}
}
impl Message {
pub fn timestamp(&self) -> i64 {
match self {
Message::System(m) => m.timestamp,
Message::User(m) => m.timestamp,
Message::Assistant(m) => m.timestamp,
Message::ToolResult(m) => m.timestamp,
}
}
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Context {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub system_prompt: Option<String>,
pub messages: Vec<Message>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tools: Option<Vec<Tool>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
pub struct TranscriptContext {
pub messages: Vec<Message>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum AssistantMessageEvent {
Start {
partial: AssistantMessage,
},
TextStart {
#[serde(rename = "contentIndex")]
content_index: usize,
partial: AssistantMessage,
},
TextDelta {
#[serde(rename = "contentIndex")]
content_index: usize,
delta: String,
partial: AssistantMessage,
},
TextEnd {
#[serde(rename = "contentIndex")]
content_index: usize,
content: String,
partial: AssistantMessage,
},
ThinkingStart {
#[serde(rename = "contentIndex")]
content_index: usize,
partial: AssistantMessage,
},
ThinkingDelta {
#[serde(rename = "contentIndex")]
content_index: usize,
delta: String,
partial: AssistantMessage,
},
ThinkingEnd {
#[serde(rename = "contentIndex")]
content_index: usize,
content: String,
partial: AssistantMessage,
},
#[serde(rename = "toolcall_start")]
ToolCallStart {
#[serde(rename = "contentIndex")]
content_index: usize,
partial: AssistantMessage,
},
#[serde(rename = "toolcall_delta")]
ToolCallDelta {
#[serde(rename = "contentIndex")]
content_index: usize,
delta: String,
partial: AssistantMessage,
},
#[serde(rename = "toolcall_end")]
ToolCallEnd {
#[serde(rename = "contentIndex")]
content_index: usize,
#[serde(rename = "toolCall", with = "tagged_tool_call")]
tool_call: ToolCall,
partial: AssistantMessage,
},
Done {
reason: StopReason,
message: AssistantMessage,
},
Error {
reason: StopReason,
error: AssistantMessage,
},
}
mod tagged_tool_call {
use super::{AssistantContent, ToolCall};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
pub fn serialize<S: Serializer>(call: &ToolCall, serializer: S) -> Result<S::Ok, S::Error> {
AssistantContent::ToolCall(call.clone()).serialize(serializer)
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<ToolCall, D::Error> {
match AssistantContent::deserialize(deserializer)? {
AssistantContent::ToolCall(call) => Ok(call),
_ => Err(serde::de::Error::custom("expected a toolCall block")),
}
}
}
pub type EventSink<'a> = dyn FnMut(&AssistantMessageEvent) + Send + 'a;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CacheRetention {
None,
Short,
Long,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelCostTier {
pub input_tokens_above: f64,
pub input: f64,
pub output: f64,
pub cache_read: f64,
pub cache_write: f64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ModelCost {
pub input: f64,
pub output: f64,
pub cache_read: f64,
pub cache_write: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tiers: Option<Vec<ModelCostTier>>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Model {
pub id: String,
pub name: String,
pub api: String,
pub provider: String,
pub base_url: String,
pub reasoning: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub thinking_level_map: Option<IndexMap<String, Option<String>>>,
pub input: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub input_limits: Option<Value>,
pub cost: ModelCost,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub prompt_cache: Option<IndexMap<String, f64>>,
pub context_window: u64,
pub max_tokens: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sampling_params: Option<Map<String, Value>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub headers: Option<IndexMap<String, String>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub compat: Option<Map<String, Value>>,
#[serde(skip)]
pub request: Option<crate::model_registry::RequestConfig>,
#[serde(flatten)]
pub extra: Map<String, Value>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mapped<'a> {
Missing,
Unsupported,
Value(&'a str),
}
impl Model {
pub(crate) fn compat_value(&self, key: &str) -> Option<&Value> {
self.compat.as_ref()?.get(key).filter(|v| !v.is_null())
}
pub(crate) fn compat_bool(&self, key: &str) -> Option<bool> {
self.compat_value(key)?.as_bool()
}
pub(crate) fn compat_str(&self, key: &str) -> Option<&str> {
self.compat_value(key)?.as_str()
}
pub(crate) fn supports_images(&self) -> bool {
self.input.iter().any(|i| i == "image")
}
pub fn thinking_level(&self, level: &str) -> Mapped<'_> {
match self.thinking_level_map.as_ref().and_then(|map| map.get(level)) {
None => Mapped::Missing,
Some(None) => Mapped::Unsupported,
Some(Some(value)) => Mapped::Value(value),
}
}
pub(crate) fn mapped_or<'a>(&'a self, level: &'a str) -> &'a str {
match self.thinking_level(level) {
Mapped::Value(value) => value,
_ => level,
}
}
}