use rig_core::error::ProviderError;
use rig_core::{message::AssistantContent, wasm_compat::WasmCompatSend};
use crate::{
agent::engine::{DriveItem, StreamingTurnSource, drive_agent, streaming_error_into_prompt},
agent::hook::{AgentHook, RunSettled, SettledOutcome, StepEventKind},
agent::runner::{AgentRunner, RunOrigin},
streaming::{Item, StreamEvent, StreamedUserContent},
};
use futures::{SinkExt, Stream, StreamExt, channel::mpsc, stream::FusedStream};
use serde::Serialize;
use std::pin::Pin;
use tracing_futures::Instrument;
use crate::completion::PromptError;
use crate::run::response::{CompletionCall, PromptResponse};
use crate::run::transcript::assistant_text_from_choice;
use rig_core::message::Message;
#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
pub type StreamingResult =
Pin<Box<dyn Stream<Item = Result<MultiTurnStreamItem, StreamingError>> + Send>>;
#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
pub type StreamingResult = Pin<Box<dyn Stream<Item = Result<MultiTurnStreamItem, StreamingError>>>>;
#[derive(Serialize, Debug, Clone)]
#[serde(tag = "type", rename_all = "camelCase")]
pub enum MultiTurnStreamItem {
StreamAssistantItem(Item<StreamEvent>),
ToolCall {
tool_call: rig_core::message::ToolCall,
},
ToolExecutionCommitted {
tool_call: rig_core::message::ToolCall,
},
StreamUserItem(StreamedUserContent),
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: Option<Vec<Message>>,
) -> PromptResponse {
let mut response = PromptResponse::new(assistant_text_from_choice(&content), aggregated_usage)
.with_content(content)
.with_completion_calls(completion_calls);
response.messages = history;
response
}
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(),
None,
))
}
pub(crate) fn final_response_with_completion_calls(
content: Vec<AssistantContent>,
aggregated_usage: crate::completion::Usage,
completion_calls: Vec<CompletionCall>,
history: Option<Vec<Message>>,
) -> Self {
Self::FinalResponse(final_response_from_content(
content,
aggregated_usage,
completion_calls,
history,
))
}
}
pub(crate) fn finalize_streamed_choice(
last_final_choice: &[AssistantContent],
output: &str,
) -> Option<Vec<AssistantContent>> {
let finalized_via_output_tool = last_final_choice
.iter()
.any(|item| matches!(item, AssistantContent::ToolCall(_)));
if !finalized_via_output_tool {
return None;
}
let mut items: Vec<AssistantContent> = last_final_choice
.iter()
.filter(|item| {
!matches!(
item,
AssistantContent::ToolCall(_) | AssistantContent::Text(_)
)
})
.cloned()
.collect();
items.push(AssistantContent::text(output.to_string()));
Some(items)
}
#[derive(Debug, thiserror::Error)]
pub enum StreamingError {
#[error("CompletionError: {0}")]
Completion(ProviderError),
#[error("{0}")]
Report(#[from] rig_core::error::ErrorReport),
#[error("PromptError: {0}")]
Prompt(#[from] PromptError),
}
impl From<ProviderError> for StreamingError {
fn from(error: ProviderError) -> Self {
match error {
ProviderError::Relayed(report) => Self::Report(*report),
error => Self::Completion(error),
}
}
}
impl From<rig_core::memory::MemoryError> for StreamingError {
fn from(err: rig_core::memory::MemoryError) -> Self {
Self::Prompt(PromptError::MemoryError(err))
}
}
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(_) => Ok((None, None)),
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 = StreamingError::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) => {
let error = streaming_error_into_prompt(err);
while stream.next().await.is_some() {}
return Err(error);
}
};
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::CompletionError(ProviderError::Response(
"agent run ended without producing a final response".to_string(),
))
})
};
(future, RunEvents { receiver })
}
}
pub async fn stream_to_stdout(
stream: &mut StreamingResult,
) -> Result<PromptResponse, std::io::Error> {
let mut final_res = PromptResponse::empty();
print!("Response: ");
while let Some(content) = stream.next().await {
match content {
Ok(MultiTurnStreamItem::StreamAssistantItem(Item::Event(StreamEvent::Text {
text,
..
}))) => {
print!("{text}");
std::io::Write::flush(&mut std::io::stdout())?;
}
Ok(MultiTurnStreamItem::StreamAssistantItem(Item::Event(StreamEvent::End {
content: AssistantContent::Reasoning(reasoning),
..
}))) => {
let reasoning = reasoning
.open(reasoning.issuer())
.map(|reasoning| reasoning.display_text())
.unwrap_or_default();
print!("{reasoning}");
std::io::Write::flush(&mut std::io::stdout())?;
}
Ok(MultiTurnStreamItem::FinalResponse(res)) => {
final_res = res;
}
Ok(MultiTurnStreamItem::ModelTurnRetried { turn }) => {
print!("\n[model turn {turn} rejected; retry requested]\nResponse: ");
std::io::Write::flush(&mut std::io::stdout())?;
}
Err(err) => {
eprintln!("Error: {err}");
}
_ => {}
}
}
Ok(final_res)
}
#[cfg(test)]
mod malformed_tool_args_tests;
#[cfg(test)]
#[allow(irrefutable_let_patterns, unreachable_patterns)]
mod tests;