use rig_core::error::ProviderError;
use rig_core::{
message::AssistantContent,
wasm_compat::{WasmBoxedStream, WasmCompatSend},
};
use crate::{
agent::engine::{DriveItem, 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,
},
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 MultiTurnStreamItem {
pub fn final_response(
content: Vec<AssistantContent>,
aggregated_usage: crate::completion::Usage,
) -> Self {
Self::FinalResponse(PromptResponse::from_content(content, aggregated_usage))
}
}
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 (agent_span, created_agent_span) = self.open_agent_span(ambient);
let hook_ctx = self.hook_context(true);
let run = self.build_run();
let source = StreamingTurnSource::new(
&self.config.hooks,
self.agent_name_or_default().to_string(),
created_agent_span,
self.config.record_telemetry_content,
);
let driver = drive_agent(
self,
source,
run,
agent_span.clone(),
created_agent_span,
hook_ctx,
)
.flat_map(|item| {
let (head, tools) = match item {
Ok(DriveItem::Surfaced(item)) => (Some(Ok(item.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.instrument(agent_span))
}
}
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(|| {
PromptError::Provider(ProviderError::Response(
"agent run ended without producing a final response".to_string(),
))
})
};
(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 malformed_tool_args_tests;
#[cfg(test)]
#[allow(irrefutable_let_patterns, unreachable_patterns)]
mod tests;