Struct AgentStream 

pub struct AgentStream<'a> { /* private fields */ }

Stream of agent events during execution

Implementations

impl<'a> AgentStream<'a>

pub async fn next(&mut self) -> Option<AgentEvent>

Get the next event from the agent stream

Examples found in repository

examples/agent_streaming/main.rs (line 138)

async fn main() -> Result<()> {
    // Build the model
    // Using a model that supports tool calling (e.g., Llama 3.1, Qwen, Mistral)
    let model = TextModelBuilder::new("../hf_models/qwen3_4b")
        .with_isq(IsqType::Q4K)
        .with_logging()
        .with_paged_attn(|| PagedAttentionMetaBuilder::default().build())?
        .build()
        .await?;

    // Create the agent with registered tools
    // - get_weather is a sync tool (runs in spawn_blocking)
    // - web_search is an async tool (runs natively async)
    // Both can execute in parallel when the model calls multiple tools
    let agent = AgentBuilder::new(model)
        .with_system_prompt(
            "You are a helpful assistant with access to weather and web search tools. \
             Use them when needed to answer user questions accurately.",
        )
        .with_max_iterations(5)
        .with_parallel_tool_execution(true) // Enable parallel tool execution (default)
        .register_tool(get_weather_tool_with_callback())
        .register_tool(web_search_tool_with_callback())
        .build();

    println!("=== Agent with Streaming Output ===\n");
    println!(
        "User: What's the weather like in Boston, and can you find me some good restaurants there?\n"
    );
    print!("Assistant: ");

    // Run the agent with streaming output
    let mut stream = agent
        .run_stream(
            "What's the weather like in Boston, and can you find me some good restaurants there?",
        )
        .await?;

    let stdout = std::io::stdout();
    let mut handle = stdout.lock();

    // Process streaming events
    while let Some(event) = stream.next().await {
        match event {
            AgentEvent::TextDelta(text) => {
                // Print text as it streams - this gives real-time output
                write!(handle, "{}", text)?;
                handle.flush()?;
            }
            AgentEvent::ToolCallsStart(calls) => {
                // Model is about to call tools
                writeln!(handle, "\n\n[Calling {} tool(s)...]", calls.len())?;
                for call in &calls {
                    writeln!(
                        handle,
                        "  - {}: {}",
                        call.function.name, call.function.arguments
                    )?;
                }
            }
            AgentEvent::ToolResult(result) => {
                // A single tool finished execution
                let status = if result.result.is_ok() { "OK" } else { "ERROR" };
                writeln!(
                    handle,
                    "  [Tool {} completed: {}]",
                    result.tool_name, status
                )?;
            }
            AgentEvent::ToolCallsComplete => {
                // All tools finished, model will continue generating
                writeln!(handle, "[All tools completed, continuing...]\n")?;
                write!(handle, "Assistant: ")?;
                handle.flush()?;
            }
            AgentEvent::Complete(response) => {
                // Agent finished executing
                writeln!(handle, "\n\n=== Agent Execution Summary ===")?;
                writeln!(handle, "Completed in {} iteration(s)", response.iterations)?;
                writeln!(handle, "Stop reason: {:?}", response.stop_reason)?;
                writeln!(handle, "Steps taken: {}", response.steps.len())?;

                match response.stop_reason {
                    AgentStopReason::TextResponse => {
                        writeln!(handle, "Final response delivered successfully.")?;
                    }
                    AgentStopReason::MaxIterations => {
                        writeln!(
                            handle,
                            "Agent reached maximum iterations without producing a final response."
                        )?;
                    }
                    AgentStopReason::NoAction => {
                        writeln!(handle, "Agent produced no response.")?;
                    }
                    AgentStopReason::Error(e) => {
                        writeln!(handle, "Agent encountered an error: {}", e)?;
                    }
                }
            }
        }
    }

    Ok(())
}