use infinity_provider_protocol::message::{
AssistantContent, Message, ToolCall, ToolResult, UserContent,
};
use rap_protocol::{ChoiceId, ProviderCallId, ThreadId, ToolCallId};
use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum InputMessageContent {
OAuth(OAuthRequired),
UserChoice(UserChoiceRequired),
User(UserContent),
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct OAuthRequired {
#[serde(rename = "type")]
pub content_type: String,
pub id: ToolCallId,
pub call_id: Option<ProviderCallId>,
pub auth_url: String,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct UserChoiceRequired {
#[serde(rename = "type")]
pub content_type: String,
pub id: ChoiceId,
pub call_id: Option<ProviderCallId>,
pub prompt: String,
pub choices: Vec<String>,
pub default: usize,
pub response_url: String,
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(untagged)]
pub enum SyntheticKind {
Tagged(TaggedSyntheticKind),
SubscriptionEvent(ToolCallId),
}
#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(tag = "type")]
pub enum TaggedSyntheticKind {
#[serde(rename = "subscription_event")]
SubscriptionEvent {
tool_call_id: ToolCallId,
#[serde(default)]
associative: bool,
#[serde(default)]
r#final: bool,
},
#[serde(rename = "thread_report")]
ThreadReport {
tool_call_id: ToolCallId,
child_thread_id: ThreadId,
},
#[serde(rename = "parent_message")]
ParentMessage { tool_call_id: ToolCallId },
#[serde(rename = "compaction")]
Compaction,
#[serde(rename = "compaction_complete")]
CompactionComplete,
}
impl SyntheticKind {
pub fn tool_call_id(&self) -> &ToolCallId<str> {
match self {
SyntheticKind::Tagged(TaggedSyntheticKind::SubscriptionEvent {
tool_call_id, ..
}) => tool_call_id,
SyntheticKind::Tagged(TaggedSyntheticKind::ThreadReport { tool_call_id, .. }) => {
tool_call_id
}
SyntheticKind::Tagged(TaggedSyntheticKind::ParentMessage { tool_call_id }) => {
tool_call_id
}
SyntheticKind::Tagged(TaggedSyntheticKind::Compaction) => ToolCallId::from_ref(""),
SyntheticKind::Tagged(TaggedSyntheticKind::CompactionComplete) => {
ToolCallId::from_ref("")
}
SyntheticKind::SubscriptionEvent(id) => id,
}
}
pub fn is_thread_report(&self) -> bool {
matches!(
self,
SyntheticKind::Tagged(TaggedSyntheticKind::ThreadReport { .. })
)
}
pub fn is_parent_message(&self) -> bool {
matches!(
self,
SyntheticKind::Tagged(TaggedSyntheticKind::ParentMessage { .. })
)
}
pub fn is_compaction(&self) -> bool {
matches!(self, SyntheticKind::Tagged(TaggedSyntheticKind::Compaction))
}
pub fn is_compaction_complete(&self) -> bool {
matches!(
self,
SyntheticKind::Tagged(TaggedSyntheticKind::CompactionComplete)
)
}
pub fn is_associative(&self) -> bool {
matches!(
self,
SyntheticKind::Tagged(TaggedSyntheticKind::SubscriptionEvent {
associative: true,
..
})
)
}
pub fn is_final(&self) -> bool {
matches!(
self,
SyntheticKind::Tagged(TaggedSyntheticKind::SubscriptionEvent { r#final: true, .. })
)
}
}
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct InputMessage {
pub content: InputMessageContent,
pub group_id: ThreadId,
#[serde(default)]
pub metadata: Option<serde_json::Value>,
#[serde(default)]
pub synthetic: Option<SyntheticKind>,
#[serde(default)]
pub display_as: Option<Vec<rap_protocol::DisplaySegment>>,
#[serde(default)]
pub subscription: bool,
}
impl InputMessage {
pub fn user_text(thread_id: impl Into<ThreadId>, text: impl Into<String>) -> Self {
Self {
content: InputMessageContent::User(UserContent::text(text.into())),
group_id: thread_id.into(),
metadata: None,
synthetic: None,
display_as: None,
subscription: false,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum InfinityMessage {
#[serde(rename = "user")]
User { content: UserContent },
#[serde(rename = "assistant")]
Assistant { content: AssistantContent },
#[serde(rename = "tool_call")]
ToolCall {
call: ToolCall,
#[serde(default, skip_serializing_if = "Option::is_none")]
display_as: Option<String>,
},
#[serde(rename = "tool_result")]
ToolResult {
result: ToolResult,
#[serde(default, skip_serializing_if = "Option::is_none")]
display_segments: Option<Vec<rap_protocol::DisplaySegment>>,
},
#[serde(rename = "subscription_event")]
SubscriptionEvent {
result: Box<ToolResult>,
tool_call_id: ToolCallId,
#[serde(default, skip_serializing_if = "Option::is_none")]
child_thread_id: Option<ThreadId>,
#[serde(default, skip_serializing_if = "Option::is_none")]
invocation: Option<Box<ToolCall>>,
},
}
impl InfinityMessage {
pub fn into_messages(self) -> Vec<Message> {
match self {
Self::User { content } => vec![Message::User {
content: vec![content],
}],
Self::Assistant { content } => vec![Message::Assistant {
content: vec![content],
}],
Self::ToolCall { call, .. } => vec![Message::Assistant {
content: vec![AssistantContent::ToolCall(call)],
}],
Self::ToolResult { result, .. } => vec![Message::User {
content: vec![UserContent::ToolResult(result)],
}],
Self::SubscriptionEvent {
result, invocation, ..
} => {
let mut msgs = Vec::new();
if let Some(call) = invocation {
msgs.push(Message::Assistant {
content: vec![AssistantContent::ToolCall(*call)],
});
}
msgs.push(Message::User {
content: vec![UserContent::ToolResult(*result)],
});
msgs
}
}
}
pub fn tool_result(&self) -> Option<&ToolResult> {
match self {
Self::ToolResult { result, .. } => Some(result),
Self::SubscriptionEvent { result, .. } => Some(result),
_ => None,
}
}
pub fn from_message(msg: Message) -> Self {
match msg {
Message::User { content } => {
let first = content.into_iter().next().expect("bug: empty content");
match first {
UserContent::ToolResult(result) => Self::ToolResult {
result,
display_segments: None,
},
other => Self::User { content: other },
}
}
Message::Assistant { content } => {
let first = content.into_iter().next().expect("bug: empty content");
match first {
AssistantContent::ToolCall(call) => Self::ToolCall {
call,
display_as: None,
},
other => Self::Assistant { content: other },
}
}
}
}
}