use rig_core::{
message::AssistantContent,
wasm_compat::{WasmBoxedStream, WasmCompatSend},
};
use crate::{
agent::engine::{DriveItem, LiveTool, StreamingTurnSource, Surfaced, drive_agent},
agent::runner::AgentRunner,
streaming::{Item, StreamEvent},
};
use futures::{SinkExt, Stream, StreamExt, channel::mpsc, stream::FusedStream};
use serde::{Deserialize, Serialize};
use std::io::Write;
use std::pin::Pin;
use tracing_futures::Instrument;
use crate::completion::PromptError;
use crate::run::response::{CompletionCall, PromptResponse};
pub type StreamingResult = WasmBoxedStream<'static, Result<MultiTurnStreamItem, PromptError>>;
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(tag = "type", rename_all = "camelCase")]
#[non_exhaustive]
pub enum MultiTurnStreamItem {
StreamAssistantItem(Item<StreamEvent>),
ToolCall {
tool_call: rig_core::message::ToolCall,
},
ToolExecutionStarted {
tool_call: rig_core::message::ToolCall,
},
ToolResultItem {
tool_result: rig_core::message::ToolResult,
index: usize,
count: usize,
},
ToolExecutionCommitted {
tool_call: rig_core::message::ToolCall,
},
ToolResult {
tool_result: rig_core::message::ToolResult,
},
CompletionCall(CompletionCall),
ModelTurnRetried {
turn: usize,
},
FinalResponse(PromptResponse),
}
impl From<Surfaced> for MultiTurnStreamItem {
fn from(surfaced: Surfaced) -> Self {
match surfaced {
Surfaced::Provider(item) => Self::StreamAssistantItem(item),
Surfaced::CompletionCall(call) => Self::CompletionCall(call),
Surfaced::ModelTurnRetried { turn } => Self::ModelTurnRetried { turn },
Surfaced::Final(response) => Self::FinalResponse(response),
}
}
}
impl From<LiveTool> for MultiTurnStreamItem {
fn from(live: LiveTool) -> Self {
match live {
LiveTool::Started(tool_call) => Self::ToolExecutionStarted { tool_call },
LiveTool::Output {
tool_result,
index,
count,
} => Self::ToolResultItem {
tool_result,
index,
count,
},
}
}
}
impl AgentRunner {
#[must_use = "a stream does nothing until polled"]
pub fn stream(self) -> StreamingResult {
self.stream_under(tracing::Span::current())
}
fn stream_under(self, ambient: tracing::Span) -> StreamingResult {
let run_under = ambient.clone();
let stream = async_stream::stream! {
let mut inner = self.start_stream(run_under);
while let Some(item) = inner.next().await {
yield item;
}
};
Box::pin(stream.instrument(ambient))
}
fn start_stream(self, ambient: tracing::Span) -> StreamingResult {
let source = StreamingTurnSource::new(
&self.config.hooks,
self.agent_name_or_default().to_string(),
self.config.record_telemetry_content,
);
let driver = drive_agent(self, source, ambient).flat_map(|item| {
let (head, tools) = match item {
Ok(DriveItem::Surfaced(item)) => (Some(Ok(item.into())), None),
Ok(DriveItem::Live(live)) => (Some(Ok(live.into())), None),
Ok(DriveItem::Projected(items)) => (None, Some(items)),
Ok(DriveItem::Done(_)) => (None, None),
Err(err) => (Some(Err(err)), None),
};
futures::stream::iter(head.into_iter().chain(tools.into_iter().flatten().map(Ok)))
});
Box::pin(driver)
}
}
pub const RUN_EVENTS_CAPACITY: usize = 32;
#[derive(Debug)]
pub struct RunEvents {
receiver: mpsc::Receiver<MultiTurnStreamItem>,
}
impl RunEvents {
pub fn try_next(&mut self) -> Option<MultiTurnStreamItem> {
self.receiver.try_recv().ok()
}
pub fn is_done(&self) -> bool {
self.receiver.is_terminated()
}
}
impl Stream for RunEvents {
type Item = MultiTurnStreamItem;
fn poll_next(
mut self: Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
Pin::new(&mut self.receiver).poll_next(cx)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.receiver.size_hint()
}
}
impl FusedStream for RunEvents {
fn is_terminated(&self) -> bool {
self.receiver.is_terminated()
}
}
impl AgentRunner {
#[must_use = "the run does nothing until the future is driven"]
pub fn run_channel(
self,
) -> (
impl Future<Output = Result<PromptResponse, PromptError>> + WasmCompatSend,
RunEvents,
) {
let (mut sender, receiver) = mpsc::channel(RUN_EVENTS_CAPACITY);
let ambient = tracing::Span::current();
let future = async move {
let mut stream = self.stream_under(ambient);
let mut response = None;
let mut forward = true;
while let Some(item) = stream.next().await {
let item = match item {
Ok(item) => item,
Err(err) => {
while stream.next().await.is_some() {}
return Err(err);
}
};
match item {
MultiTurnStreamItem::FinalResponse(done) => {
if forward {
let _ = sender
.send(MultiTurnStreamItem::FinalResponse(done.clone()))
.await;
}
response = Some(done);
}
item => {
if forward && sender.send(item).await.is_err() {
forward = false;
}
}
}
}
response.ok_or_else(super::runner::no_final_response)
};
(future, RunEvents { receiver })
}
}
#[derive(Debug, thiserror::Error)]
pub enum StreamToStdoutError {
#[error(transparent)]
Run(#[from] PromptError),
#[error(transparent)]
Io(#[from] std::io::Error),
#[error("the stream ended without a final response")]
Incomplete,
}
pub async fn stream_to_stdout(
stream: &mut StreamingResult,
) -> Result<PromptResponse, StreamToStdoutError> {
let mut stdout = std::io::stdout();
write!(stdout, "Response: ")?;
while let Some(content) = stream.next().await {
match content? {
MultiTurnStreamItem::StreamAssistantItem(Item::Event(StreamEvent::Text {
text,
..
})) => {
write!(stdout, "{text}")?;
stdout.flush()?;
}
MultiTurnStreamItem::StreamAssistantItem(Item::Event(StreamEvent::End {
content: AssistantContent::Reasoning(reasoning),
..
})) => {
write!(stdout, "{}", reasoning.text)?;
stdout.flush()?;
}
MultiTurnStreamItem::FinalResponse(response) => return Ok(response),
MultiTurnStreamItem::ModelTurnRetried { turn } => {
write!(
stdout,
"\n[model turn {turn} rejected; retry requested]\nResponse: "
)?;
stdout.flush()?;
}
_ => {}
}
}
Err(StreamToStdoutError::Incomplete)
}
#[cfg(test)]
mod cut_off_tool_call_tests;
#[cfg(test)]
mod malformed_tool_args_tests;
#[cfg(test)]
mod tests;
#[cfg(test)]
mod tool_result_item_tests;
#[cfg(test)]
mod tool_started_tests;