use rig_core::error::ProviderError;
use rig_core::{
message::AssistantContent,
wasm_compat::{WasmBoxedStream, WasmCompatSend},
};
use crate::{
agent::engine::{DriveItem, StreamingTurnSource, drive_agent},
agent::hook::{AgentHook, RunSettled, SettledOutcome, StepEventKind},
agent::runner::{AgentRunner, RunOrigin},
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};
use rig_core::message::Message;
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),
}
fn final_response_from_content(
content: Vec<AssistantContent>,
aggregated_usage: crate::completion::Usage,
completion_calls: Vec<CompletionCall>,
history: Vec<Message>,
) -> PromptResponse {
PromptResponse::from_content(content, aggregated_usage)
.with_completion_calls(completion_calls)
.with_messages(history)
}
impl MultiTurnStreamItem {
pub(crate) fn stream_item(item: Item<StreamEvent>) -> Self {
Self::StreamAssistantItem(item)
}
pub(crate) fn with_memory_append(
self,
memory_append: Option<crate::run::MemoryAppend>,
) -> Self {
match self {
Self::FinalResponse(response) => {
Self::FinalResponse(response.with_memory_append(memory_append))
}
other => other,
}
}
pub fn final_response(
content: Vec<AssistantContent>,
aggregated_usage: crate::completion::Usage,
) -> Self {
Self::FinalResponse(final_response_from_content(
content,
aggregated_usage,
Vec::new(),
Vec::new(),
))
}
pub(crate) fn final_response_with_completion_calls(
content: Vec<AssistantContent>,
aggregated_usage: crate::completion::Usage,
completion_calls: Vec<CompletionCall>,
history: Vec<Message>,
) -> Self {
Self::FinalResponse(final_response_from_content(
content,
aggregated_usage,
completion_calls,
history,
))
}
}
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).await;
while let Some(item) = inner.next().await {
yield item;
}
};
Box::pin(stream.instrument(ambient))
}
async fn start_stream(self, ambient: tracing::Span) -> StreamingResult {
let (agent_span, created_agent_span) = self.open_agent_span(ambient);
let bus = self.config.bus.clone();
let hook_ctx = self.hook_context(true);
let resolved = match &self.origin {
RunOrigin::Resume(_) => self.resumed_memory(),
RunOrigin::Prompt(_) => {
let resolve = self.resolve_history_and_memory(&hook_ctx);
futures::pin_mut!(resolve);
let mut driven = bus.drive(futures::stream::once(resolve));
driven.next().await.unwrap_or(Ok((None, None)))
}
};
let (history_override, memory_handle) = match resolved {
Ok(resolved) => resolved,
Err(err) => {
let hooks = self.config.hooks.clone();
let stream = async_stream::stream! {
let err = PromptError::from(err);
if hooks.observes(StepEventKind::RunSettled) {
let reason = err.to_string();
hooks
.on_run_settled(
&hook_ctx,
RunSettled {
outcome: SettledOutcome::Error(&reason),
messages: None,
},
)
.await;
}
yield Err(err);
};
return Box::pin(stream.instrument(agent_span));
}
};
let run = self.build_run(history_override);
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,
memory_handle,
hook_ctx,
)
.filter_map(|item| {
std::future::ready(match item {
Ok(DriveItem::Item(item)) => Some(Ok(item)),
Ok(DriveItem::Done(_)) => None,
Err(err) => Some(Err(err)),
})
});
let driver = bus.drive(Box::pin(driver));
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;