menta 0.0.5

use futures_util::StreamExt;
use menta::{GenerateTextRequest, Part, StreamEvent, Tool, ToolChoice, ToolSchema, stream_text};

#[tokio::main]
async fn main() {
    let mut events = stream_text(
        GenerateTextRequest::new()
            .model("mock/mock-1")
            .prompt("remember rust uses cargo")
            .tools(vec![Tool::new(
                "add_resource",
                "Store a note for later",
                ToolSchema::string(),
                |input| format!("stored: {input}"),
            )])
            .tool_choice(ToolChoice::Required("add_resource".into())),
    )
    .await
    .expect("stream_text failed");

    while let Some(event) = events.next().await {
        match event {
            StreamEvent::TextDelta(text) => println!("text delta: {text}"),
            StreamEvent::ToolCall(call) => {
                println!("tool call: {}({})", call.name, call.input);
            }
            StreamEvent::ToolResult(result) => {
                println!("tool result: {} -> {}", result.name, result.output);
            }
            StreamEvent::Finish { reason, parts, .. } => {
                println!("finish: {:?}", reason);
                println!("parts: {:?}", parts);

                for part in parts {
                    match part {
                        Part::Text(text) => println!("final text: {text}"),
                        Part::ToolCall(call) => {
                            println!("final tool call: {}({})", call.name, call.input);
                        }
                        Part::ToolResult(result) => {
                            println!("final tool result: {} -> {}", result.name, result.output);
                        }
                    }
                }
            }
            StreamEvent::Error(error) => eprintln!("error: {error}"),
        }
    }

    println!(
        "note: stream_text only streams a single provider pass; use generate_text for automatic tool execution"
    );
}