use std::collections::{BTreeMap, BTreeSet};
use serde::{Deserialize, Serialize};
use rig_core::completion::{FinishReason, Message};
use rig_core::error::ProviderError;
use rig_core::message::{
AssistantContent, AssistantMessage, CallId, ToolCall, ToolName, ToolResult,
};
use rig_core::streaming::{Item, PartKind, StreamEvent};
fn unknown_payload_loses_assistant_content(payload: &serde_json::Value) -> bool {
if AssistantContent::deserialize(payload).is_ok() {
return true;
}
payload
.get("text")
.is_some_and(serde_json::Value::is_string)
&& payload.get("native").is_some()
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamedInvalidToolCall {
pub tool_call: ToolCall,
pub args: Option<String>,
pub executable_tool_names: BTreeSet<String>,
pub allowed_tool_names: BTreeSet<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PartialStreamedTurn {
#[serde(default)]
pub head: AssistantMessage,
pub content: Vec<AssistantContent>,
pub pending_tool_calls: Vec<ToolCall>,
}
impl PartialStreamedTurn {
pub fn assistant_message(&self, current_tool_call: Option<ToolCall>) -> Option<Message> {
let mut calls: Vec<ToolCall> = self
.pending_tool_calls
.iter()
.cloned()
.chain(current_tool_call)
.collect();
let mut content: Vec<AssistantContent> = self
.content
.iter()
.filter_map(|part| match part {
AssistantContent::ToolCall(call) => {
let at = calls.iter().position(|kept| kept.id == call.id)?;
let mut kept = calls.remove(at);
kept.native.clone_from(&call.native);
Some(AssistantContent::ToolCall(kept))
}
part => (!part.is_blank()).then(|| part.clone()),
})
.collect();
content.extend(calls.into_iter().map(|mut call| {
call.native = None;
AssistantContent::ToolCall(call)
}));
if content.is_empty() {
return None;
}
Some(Message::Assistant(self.head.clone().with_content(content)))
}
pub fn rollback_messages(
&self,
invalid_tool_call: ToolCall,
feedback: String,
) -> Option<(Message, Message)> {
let assistant_message = self.assistant_message(Some(invalid_tool_call.clone()))?;
let Message::Assistant(turn) = &assistant_message else {
return None;
};
let user_message = Message::User {
content: rig_core::transcript::invalid_call_feedback(
&turn.content,
&invalid_tool_call.id,
&feedback,
),
};
Some((assistant_message, user_message))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StreamedTurn {
pub head: AssistantMessage,
pub choice: Vec<AssistantContent>,
pub executable_tool_names: BTreeSet<String>,
pub allowed_tool_names: BTreeSet<String>,
pub finish_reason: Option<FinishReason>,
}
#[derive(Debug)]
pub enum StreamedResolution {
Repaired {
tool_name: String,
},
TurnAbandoned {
skipped_tool_result: Option<ToolResult>,
},
Ignored,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub enum StreamedTurnEvent {
EmitIngested,
EmitToolCallDelta,
HoldToolCall,
EmitToolCall {
call: ToolCall,
},
InvalidToolCall(StreamedInvalidToolCall),
}
#[derive(Clone, Serialize, Deserialize)]
struct OpenCall {
name: Option<ToolName>,
live: bool,
arguments: String,
}
#[derive(Clone, Serialize, Deserialize)]
struct PendingInvalid {
tool_call: ToolCall,
}
#[derive(Clone, Serialize, Deserialize)]
pub struct StreamedTurnAssembler {
executable_tool_names: BTreeSet<String>,
allowed_tool_names: BTreeSet<String>,
text: String,
reasoning: BTreeMap<usize, String>,
#[serde(default)]
open_calls: BTreeMap<usize, OpenCall>,
pending_tool_calls: Vec<ToolCall>,
pending_invalid: Option<PendingInvalid>,
ignored_calls: Vec<CallId>,
repaired_calls: Vec<(CallId, ToolName)>,
excluded_assistant_content: ExclusionCount,
}
#[derive(Default, Clone, Serialize, Deserialize)]
#[serde(transparent)]
struct ExclusionCount(usize);
impl Drop for ExclusionCount {
fn drop(&mut self) {
if self.0 > 0 {
tracing::warn!(
excluded = self.0,
"stream items matching rig's tagged assistant-content \
serialization were excluded from the assembled assistant \
message — replayed assistant blocks are not stream-item \
shapes, and their content is lost from assembled history"
);
}
}
}
impl StreamedTurnAssembler {
pub fn new(
executable_tool_names: BTreeSet<String>,
allowed_tool_names: BTreeSet<String>,
) -> Self {
Self {
executable_tool_names,
allowed_tool_names,
text: String::new(),
reasoning: BTreeMap::new(),
open_calls: BTreeMap::new(),
pending_tool_calls: Vec::new(),
pending_invalid: None,
ignored_calls: Vec::new(),
repaired_calls: Vec::new(),
excluded_assistant_content: ExclusionCount::default(),
}
}
pub fn excluded_assistant_content(&self) -> usize {
self.excluded_assistant_content.0
}
pub fn aggregated_text(&self) -> &str {
&self.text
}
pub fn aggregated_reasoning(&self, index: usize) -> Option<&str> {
self.reasoning.get(&index).map(String::as_str)
}
pub fn aggregated_arguments(&self, index: usize) -> Option<&str> {
self.open_calls
.get(&index)
.map(|call| call.arguments.as_str())
}
pub fn streaming_tool_name(&self, index: usize) -> Option<&ToolName> {
self.open_calls
.get(&index)
.and_then(|call| call.name.as_ref())
}
pub fn ingest(
&mut self,
item: &Item<StreamEvent>,
) -> Result<Vec<StreamedTurnEvent>, ProviderError> {
if self.pending_invalid.is_some() {
return Err(ProviderError::Response(
"streamed turn ingested while an invalid tool call awaits resolution".to_string(),
));
}
let event = match item {
Item::Event(event) => event,
Item::Unknown(payload) => {
if unknown_payload_loses_assistant_content(payload.value()) {
self.excluded_assistant_content.0 += 1;
tracing::debug!(
excluded = self.excluded_assistant_content.0,
"stream item is a replayed assistant block, not a \
stream-item shape; excluded from assembly"
);
}
return Ok(vec![StreamedTurnEvent::EmitIngested]);
}
};
match event {
StreamEvent::Text { text, .. } => {
self.text.push_str(text);
Ok(vec![StreamedTurnEvent::EmitIngested])
}
StreamEvent::Reasoning { part, text } => {
self.reasoning
.entry(part.index())
.or_default()
.push_str(text);
Ok(vec![StreamedTurnEvent::EmitIngested])
}
StreamEvent::Start {
part,
kind: PartKind::ToolCall,
name,
} => {
let live = name
.as_ref()
.is_some_and(|name| self.allowed_tool_names.contains(name.as_str()));
self.open_calls.insert(
part.index(),
OpenCall {
name: name.clone(),
live,
arguments: String::new(),
},
);
Ok(vec![if live {
StreamedTurnEvent::EmitIngested
} else {
StreamedTurnEvent::HoldToolCall
}])
}
StreamEvent::Arguments { part, json } => {
let call = self.open_calls.entry(part.index()).or_insert(OpenCall {
name: None,
live: false,
arguments: String::new(),
});
call.arguments.push_str(json);
Ok(vec![if call.live {
StreamedTurnEvent::EmitToolCallDelta
} else {
StreamedTurnEvent::HoldToolCall
}])
}
StreamEvent::End {
part,
content: AssistantContent::ToolCall(tool_call),
} => {
self.open_calls.remove(&part.index());
if !self
.allowed_tool_names
.contains(tool_call.function.name.as_str())
{
return Ok(self.surface_invalid_call(
tool_call.clone(),
Some(tool_call.function.arguments_value().to_string()),
));
}
self.pending_tool_calls.push(tool_call.clone());
Ok(vec![StreamedTurnEvent::EmitToolCall {
call: tool_call.clone(),
}])
}
StreamEvent::Start { .. } | StreamEvent::End { .. } => {
Ok(vec![StreamedTurnEvent::EmitIngested])
}
}
}
pub fn resolve_pending_invalid(
&mut self,
resolution: &StreamedResolution,
) -> Vec<StreamedTurnEvent> {
let Some(pending) = self.pending_invalid.take() else {
return Vec::new();
};
let PendingInvalid { mut tool_call } = pending;
match resolution {
StreamedResolution::Repaired { tool_name } => {
if let Ok(tool_name) = ToolName::new(tool_name.clone()) {
self.repaired_calls
.push((tool_call.id.clone(), tool_name.clone()));
tool_call.function.name = tool_name;
}
self.pending_tool_calls.push(tool_call.clone());
vec![StreamedTurnEvent::EmitToolCall { call: tool_call }]
}
StreamedResolution::TurnAbandoned { .. } => Vec::new(),
StreamedResolution::Ignored => {
self.ignored_calls.push(tool_call.id);
Vec::new()
}
}
}
pub fn partial_turn(
&self,
partial: &rig_core::completion::CompletionResponse,
) -> PartialStreamedTurn {
PartialStreamedTurn {
head: partial.continued(Vec::new()),
content: partial.choice.clone(),
pending_tool_calls: self.pending_tool_calls.clone(),
}
}
pub fn finish(self, response: &rig_core::completion::CompletionResponse) -> StreamedTurn {
let choice = response
.choice
.iter()
.filter(|content| match content {
AssistantContent::ToolCall(call) => !self.ignored_calls.contains(&call.id),
_ => true,
})
.cloned()
.map(|content| match content {
AssistantContent::ToolCall(mut call) => {
if let Some((_, name)) =
self.repaired_calls.iter().find(|(id, _)| *id == call.id)
{
call.function.name = name.clone();
}
AssistantContent::ToolCall(call)
}
other => other,
})
.collect();
StreamedTurn {
head: response.head(),
choice,
executable_tool_names: self.executable_tool_names.clone(),
allowed_tool_names: self.allowed_tool_names.clone(),
finish_reason: response.finish_reason(),
}
}
fn surface_invalid_call(
&mut self,
tool_call: ToolCall,
args: Option<String>,
) -> Vec<StreamedTurnEvent> {
let invalid = StreamedInvalidToolCall {
tool_call: tool_call.clone(),
args,
executable_tool_names: self.executable_tool_names.clone(),
allowed_tool_names: self.allowed_tool_names.clone(),
};
self.pending_invalid = Some(PendingInvalid { tool_call });
vec![StreamedTurnEvent::InvalidToolCall(invalid)]
}
}
#[cfg(test)]
mod tests;