Struct ChatMessage 

pub struct ChatMessage {
    pub role: Role,
    pub content: String,
    pub name: Option<String>,
    pub tool_calls: Option<Vec<ToolCall>>,
    pub tool_call_id: Option<String>,
}

Represents a single message in a chat conversation.

Fields

role: Role

The role of the message sender.

content: String

The content of the message.

name: Option<String>

The name of the message sender.

tool_calls: Option<Vec<ToolCall>>

Any tool calls requested by the assistant.

tool_call_id: Option<String>

The ID of the tool call this message is a response to.

Implementations

impl ChatMessage

pub fn system(content: impl Into<String>) -> Self

Creates a new system message.

Examples found in repository

examples/direct_llm_usage.rs (line 68)

async fn simple_call() -> helios_engine::Result<()> {
    // Create a configuration for the LLM.
    let llm_config = LLMConfig {
        model_name: "gpt-3.5-turbo".to_string(),
        base_url: "https://api.openai.com/v1".to_string(),
        api_key: std::env::var("OPENAI_API_KEY")
            .unwrap_or_else(|_| "your-api-key-here".to_string()),
        temperature: 0.7,
        max_tokens: 2048,
    };

    // Create a new LLM client.
    let client = LLMClient::new(helios_engine::llm::LLMProviderType::Remote(llm_config)).await?;

    // Prepare the messages to send to the LLM.
    let messages = vec![
        ChatMessage::system("You are a helpful assistant that gives concise answers."),
        ChatMessage::user("What is the capital of France? Answer in one sentence."),
    ];

    // Make the call to the LLM.
    println!("Sending request...");
    match client.chat(messages, None, None, None, None).await {
        Ok(response) => {
            println!("✓ Response: {}", response.content);
        }
        Err(e) => {
            println!("✗ Error: {}", e);
            println!("  (Make sure to set OPENAI_API_KEY environment variable)");
        }
    }

    Ok(())
}

examples/streaming_chat.rs (line 36)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Streaming Example");
    println!("=====================================\n");

    // Set up the LLM configuration.
    let llm_config = LLMConfig {
        model_name: "gpt-3.5-turbo".to_string(),
        base_url: "https://api.openai.com/v1".to_string(),
        api_key: std::env::var("OPENAI_API_KEY")
            .unwrap_or_else(|_| "your-api-key-here".to_string()),
        temperature: 0.7,
        max_tokens: 2048,
    };

    // Create a new LLM client.
    let client = LLMClient::new(helios_engine::llm::LLMProviderType::Remote(llm_config)).await?;

    // --- Example 1: Simple streaming response ---
    println!("Example 1: Simple Streaming Response");
    println!("======================================\n");

    let messages = vec![
        ChatMessage::system("You are a helpful assistant."),
        ChatMessage::user("Write a short poem about coding."),
    ];

    print!("Assistant: ");
    io::stdout().flush()?;

    // Stream the response from the model, printing each chunk as it arrives.
    let response = client
        .chat_stream(messages, None, None, None, None, |chunk| {
            print!("{}", chunk);
            io::stdout().flush().unwrap();
        })
        .await?;

    println!("\n\n");

    // --- Example 2: Interactive streaming chat ---
    println!("Example 2: Interactive Streaming Chat");
    println!("======================================\n");

    let mut session = ChatSession::new().with_system_prompt("You are a helpful coding assistant.");

    let questions = vec![
        "What is Rust?",
        "What are its main benefits?",
        "Show me a simple example.",
    ];

    for question in questions {
        println!("User: {}", question);
        session.add_user_message(question);

        print!("Assistant: ");
        io::stdout().flush()?;

        // Stream the response, maintaining the conversation context.
        let response = client
            .chat_stream(session.get_messages(), None, None, None, None, |chunk| {
                print!("{}", chunk);
                io::stdout().flush().unwrap();
            })
            .await?;

        session.add_assistant_message(&response.content);
        println!("\n");
    }

    // --- Example 3: Streaming with thinking tags ---
    println!("\nExample 3: Streaming with Thinking Tags");
    println!("=========================================\n");
    println!("When using models that support thinking tags (like o1),");
    println!("you can detect and display them during streaming.\n");

    /// A helper struct to track and display thinking tags in streamed responses.
    struct ThinkingTracker {
        in_thinking: bool,
        thinking_buffer: String,
    }

    impl ThinkingTracker {
        /// Creates a new `ThinkingTracker`.
        fn new() -> Self {
            Self {
                in_thinking: false,
                thinking_buffer: String::new(),
            }
        }

        /// Processes a chunk of a streamed response and returns the processed output.
        fn process_chunk(&mut self, chunk: &str) -> String {
            let mut output = String::new();
            let mut chars = chunk.chars().peekable();

            while let Some(c) = chars.next() {
                if c == '<' {
                    let remaining: String = chars.clone().collect();
                    if remaining.starts_with("thinking>") {
                        self.in_thinking = true;
                        self.thinking_buffer.clear();
                        output.push_str("\n💭 [Thinking");
                        for _ in 0..9 {
                            chars.next();
                        }
                        continue;
                    } else if remaining.starts_with("/thinking>") {
                        self.in_thinking = false;
                        output.push_str("]\n");
                        for _ in 0..10 {
                            chars.next();
                        }
                        continue;
                    }
                }

                if self.in_thinking {
                    self.thinking_buffer.push(c);
                    if self.thinking_buffer.len() % 3 == 0 {
                        output.push('.');
                    }
                } else {
                    output.push(c);
                }
            }

            output
        }
    }

    let messages = vec![ChatMessage::user(
        "Solve this problem: What is 15 * 234 + 89?",
    )];

    let mut tracker = ThinkingTracker::new();
    print!("Assistant: ");
    io::stdout().flush()?;

    // Stream the response, processing thinking tags as they arrive.
    let _response = client
        .chat_stream(messages, None, None, None, None, |chunk| {
            let output = tracker.process_chunk(chunk);
            print!("{}", output);
            io::stdout().flush().unwrap();
        })
        .await?;

    println!("\n\n Streaming examples completed!");
    println!("\nKey benefits of streaming:");
    println!("  • Real-time response display");
    println!("  • Better user experience for long responses");
    println!("  • Ability to show thinking/reasoning process");
    println!("  • Early cancellation possible (future feature)");

    Ok(())
}

pub fn sys(content: impl Into<String>) -> Self

Creates a new system message. Alias for system().

Examples found in repository

examples/ultra_simple.rs (line 71)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Ultra Simple Helios Example\n");

    // ========== SIMPLEST AGENT CREATION ==========
    println!("1️⃣  Creating an agent - shortest possible syntax:\n");

    // One-liner: Create agent with auto config
    let mut agent = Agent::builder("Helper")
        .auto_config()
        .prompt("You are helpful and concise.")
        .build()
        .await?;

    println!("✓ Agent created!\n");

    // ========== SIMPLEST CHAT ==========
    println!("2️⃣  Asking questions - simplest possible:\n");

    // Use .ask() instead of .chat() for more natural syntax
    let answer = agent.ask("What is 2+2?").await?;
    println!("Q: What is 2+2?\nA: {}\n", answer);

    // ========== SIMPLEST CONFIG ==========
    println!("3️⃣  Creating config with shortest syntax:\n");

    // Ultra-short config creation
    let _config = Config::builder()
        .m("gpt-4") // .m() is shorthand for .model()
        .key("your-api-key") // .key() is shorthand for .api_key()
        .temp(0.8) // .temp() is shorthand for .temperature()
        .tokens(1024) // .tokens() is shorthand for .max_tokens()
        .build();

    println!("✓ Config created with ultra-short syntax!\n");

    // ========== SIMPLEST AGENT WITH TOOLS ==========
    println!("4️⃣  Agent with tools - simplest way:\n");

    let mut calc_agent = Agent::builder("Calculator")
        .auto_config()
        .prompt("You are a math expert.")
        .with_tool(Box::new(CalculatorTool)) // Add single tool
        .build()
        .await?;

    let result = calc_agent.ask("Calculate 15 * 7 + 5").await?;
    println!("Q: Calculate 15 * 7 + 5\nA: {}\n", result);

    // ========== SIMPLEST QUICK AGENT ==========
    println!("5️⃣  Quick agent - one method call:\n");

    // Agent::quick() creates agent in ONE LINE with auto config!
    let mut quick_agent = Agent::quick("QuickBot").await?;
    let quick_answer = quick_agent.ask("Say hello!").await?;
    println!("Response: {}\n", quick_answer);

    // ========== SIMPLEST CHAT MESSAGES ==========
    println!("6️⃣  Creating messages - super short syntax:\n");

    use helios_engine::ChatMessage;

    // Short aliases for message creation
    let _sys_msg = ChatMessage::sys("You are helpful"); // .sys() not .system()
    let _user_msg = ChatMessage::msg("Hello there"); // .msg() not .user()
    let _reply_msg = ChatMessage::reply("Hi! How can I help?"); // .reply() not .assistant()

    println!("✓ Messages created with ultra-short syntax!\n");

    // ========== SHORTEST AUTOFOREST ==========
    println!("7️⃣  AutoForest - simplest multi-agent orchestration:\n");

    use helios_engine::AutoForest;

    let mut forest = AutoForest::new(Config::builder().m("gpt-4").build())
        .with_tools(vec![Box::new(CalculatorTool)])
        .build()
        .await?;

    // Use .run() for shortest syntax
    let forest_result = forest.run("Analyze these numbers: 10, 20, 30, 40").await?;
    println!("Forest Result:\n{}\n", forest_result);

    // ========== COMPARISON TABLE ==========
    println!("📊 Syntax Comparison - Short vs Long:\n");
    println!("┌─────────────────────┬──────────────────────┬─────────────────┐");
    println!("│ Operation           │ Short Syntax         │ Long Syntax      │");
    println!("├─────────────────────┼──────────────────────┼─────────────────┤");
    println!("│ Create Agent        │ Agent::quick()       │ Agent::builder()│");
    println!("│ Ask Question        │ .ask()               │ .chat()          │");
    println!("│ System Prompt       │ .prompt()            │ .system_prompt() │");
    println!("│ Config Model        │ .m()                 │ .model()         │");
    println!("│ Config Key          │ .key()               │ .api_key()       │");
    println!("│ Config Temp         │ .temp()              │ .temperature()   │");
    println!("│ Config Tokens       │ .tokens()            │ .max_tokens()    │");
    println!("│ System Message      │ ChatMessage::sys()   │ ChatMessage::system()");
    println!("│ User Message        │ ChatMessage::msg()   │ ChatMessage::user()");
    println!("│ Assistant Message   │ ChatMessage::reply() │ ChatMessage::assistant()");
    println!("│ AutoForest Execute  │ .run()               │ .execute_task()  │");
    println!("└─────────────────────┴──────────────────────┴─────────────────┘\n");

    println!("✅ All examples completed!");
    println!("💡 Tip: Mix and match short and long syntax based on your preference!");

    Ok(())
}

pub fn user(content: impl Into<String>) -> Self

Creates a new user message.

Examples found in repository

examples/direct_llm_usage.rs (line 69)

async fn simple_call() -> helios_engine::Result<()> {
    // Create a configuration for the LLM.
    let llm_config = LLMConfig {
        model_name: "gpt-3.5-turbo".to_string(),
        base_url: "https://api.openai.com/v1".to_string(),
        api_key: std::env::var("OPENAI_API_KEY")
            .unwrap_or_else(|_| "your-api-key-here".to_string()),
        temperature: 0.7,
        max_tokens: 2048,
    };

    // Create a new LLM client.
    let client = LLMClient::new(helios_engine::llm::LLMProviderType::Remote(llm_config)).await?;

    // Prepare the messages to send to the LLM.
    let messages = vec![
        ChatMessage::system("You are a helpful assistant that gives concise answers."),
        ChatMessage::user("What is the capital of France? Answer in one sentence."),
    ];

    // Make the call to the LLM.
    println!("Sending request...");
    match client.chat(messages, None, None, None, None).await {
        Ok(response) => {
            println!("✓ Response: {}", response.content);
        }
        Err(e) => {
            println!("✗ Error: {}", e);
            println!("  (Make sure to set OPENAI_API_KEY environment variable)");
        }
    }

    Ok(())
}

examples/streaming_chat.rs (line 37)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Helios Engine - Streaming Example");
    println!("=====================================\n");

    // Set up the LLM configuration.
    let llm_config = LLMConfig {
        model_name: "gpt-3.5-turbo".to_string(),
        base_url: "https://api.openai.com/v1".to_string(),
        api_key: std::env::var("OPENAI_API_KEY")
            .unwrap_or_else(|_| "your-api-key-here".to_string()),
        temperature: 0.7,
        max_tokens: 2048,
    };

    // Create a new LLM client.
    let client = LLMClient::new(helios_engine::llm::LLMProviderType::Remote(llm_config)).await?;

    // --- Example 1: Simple streaming response ---
    println!("Example 1: Simple Streaming Response");
    println!("======================================\n");

    let messages = vec![
        ChatMessage::system("You are a helpful assistant."),
        ChatMessage::user("Write a short poem about coding."),
    ];

    print!("Assistant: ");
    io::stdout().flush()?;

    // Stream the response from the model, printing each chunk as it arrives.
    let response = client
        .chat_stream(messages, None, None, None, None, |chunk| {
            print!("{}", chunk);
            io::stdout().flush().unwrap();
        })
        .await?;

    println!("\n\n");

    // --- Example 2: Interactive streaming chat ---
    println!("Example 2: Interactive Streaming Chat");
    println!("======================================\n");

    let mut session = ChatSession::new().with_system_prompt("You are a helpful coding assistant.");

    let questions = vec![
        "What is Rust?",
        "What are its main benefits?",
        "Show me a simple example.",
    ];

    for question in questions {
        println!("User: {}", question);
        session.add_user_message(question);

        print!("Assistant: ");
        io::stdout().flush()?;

        // Stream the response, maintaining the conversation context.
        let response = client
            .chat_stream(session.get_messages(), None, None, None, None, |chunk| {
                print!("{}", chunk);
                io::stdout().flush().unwrap();
            })
            .await?;

        session.add_assistant_message(&response.content);
        println!("\n");
    }

    // --- Example 3: Streaming with thinking tags ---
    println!("\nExample 3: Streaming with Thinking Tags");
    println!("=========================================\n");
    println!("When using models that support thinking tags (like o1),");
    println!("you can detect and display them during streaming.\n");

    /// A helper struct to track and display thinking tags in streamed responses.
    struct ThinkingTracker {
        in_thinking: bool,
        thinking_buffer: String,
    }

    impl ThinkingTracker {
        /// Creates a new `ThinkingTracker`.
        fn new() -> Self {
            Self {
                in_thinking: false,
                thinking_buffer: String::new(),
            }
        }

        /// Processes a chunk of a streamed response and returns the processed output.
        fn process_chunk(&mut self, chunk: &str) -> String {
            let mut output = String::new();
            let mut chars = chunk.chars().peekable();

            while let Some(c) = chars.next() {
                if c == '<' {
                    let remaining: String = chars.clone().collect();
                    if remaining.starts_with("thinking>") {
                        self.in_thinking = true;
                        self.thinking_buffer.clear();
                        output.push_str("\n💭 [Thinking");
                        for _ in 0..9 {
                            chars.next();
                        }
                        continue;
                    } else if remaining.starts_with("/thinking>") {
                        self.in_thinking = false;
                        output.push_str("]\n");
                        for _ in 0..10 {
                            chars.next();
                        }
                        continue;
                    }
                }

                if self.in_thinking {
                    self.thinking_buffer.push(c);
                    if self.thinking_buffer.len() % 3 == 0 {
                        output.push('.');
                    }
                } else {
                    output.push(c);
                }
            }

            output
        }
    }

    let messages = vec![ChatMessage::user(
        "Solve this problem: What is 15 * 234 + 89?",
    )];

    let mut tracker = ThinkingTracker::new();
    print!("Assistant: ");
    io::stdout().flush()?;

    // Stream the response, processing thinking tags as they arrive.
    let _response = client
        .chat_stream(messages, None, None, None, None, |chunk| {
            let output = tracker.process_chunk(chunk);
            print!("{}", output);
            io::stdout().flush().unwrap();
        })
        .await?;

    println!("\n\n Streaming examples completed!");
    println!("\nKey benefits of streaming:");
    println!("  • Real-time response display");
    println!("  • Better user experience for long responses");
    println!("  • Ability to show thinking/reasoning process");
    println!("  • Early cancellation possible (future feature)");

    Ok(())
}

pub fn msg(content: impl Into<String>) -> Self

Creates a new user message. Alias for user().

Examples found in repository

examples/ultra_simple.rs (line 72)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Ultra Simple Helios Example\n");

    // ========== SIMPLEST AGENT CREATION ==========
    println!("1️⃣  Creating an agent - shortest possible syntax:\n");

    // One-liner: Create agent with auto config
    let mut agent = Agent::builder("Helper")
        .auto_config()
        .prompt("You are helpful and concise.")
        .build()
        .await?;

    println!("✓ Agent created!\n");

    // ========== SIMPLEST CHAT ==========
    println!("2️⃣  Asking questions - simplest possible:\n");

    // Use .ask() instead of .chat() for more natural syntax
    let answer = agent.ask("What is 2+2?").await?;
    println!("Q: What is 2+2?\nA: {}\n", answer);

    // ========== SIMPLEST CONFIG ==========
    println!("3️⃣  Creating config with shortest syntax:\n");

    // Ultra-short config creation
    let _config = Config::builder()
        .m("gpt-4") // .m() is shorthand for .model()
        .key("your-api-key") // .key() is shorthand for .api_key()
        .temp(0.8) // .temp() is shorthand for .temperature()
        .tokens(1024) // .tokens() is shorthand for .max_tokens()
        .build();

    println!("✓ Config created with ultra-short syntax!\n");

    // ========== SIMPLEST AGENT WITH TOOLS ==========
    println!("4️⃣  Agent with tools - simplest way:\n");

    let mut calc_agent = Agent::builder("Calculator")
        .auto_config()
        .prompt("You are a math expert.")
        .with_tool(Box::new(CalculatorTool)) // Add single tool
        .build()
        .await?;

    let result = calc_agent.ask("Calculate 15 * 7 + 5").await?;
    println!("Q: Calculate 15 * 7 + 5\nA: {}\n", result);

    // ========== SIMPLEST QUICK AGENT ==========
    println!("5️⃣  Quick agent - one method call:\n");

    // Agent::quick() creates agent in ONE LINE with auto config!
    let mut quick_agent = Agent::quick("QuickBot").await?;
    let quick_answer = quick_agent.ask("Say hello!").await?;
    println!("Response: {}\n", quick_answer);

    // ========== SIMPLEST CHAT MESSAGES ==========
    println!("6️⃣  Creating messages - super short syntax:\n");

    use helios_engine::ChatMessage;

    // Short aliases for message creation
    let _sys_msg = ChatMessage::sys("You are helpful"); // .sys() not .system()
    let _user_msg = ChatMessage::msg("Hello there"); // .msg() not .user()
    let _reply_msg = ChatMessage::reply("Hi! How can I help?"); // .reply() not .assistant()

    println!("✓ Messages created with ultra-short syntax!\n");

    // ========== SHORTEST AUTOFOREST ==========
    println!("7️⃣  AutoForest - simplest multi-agent orchestration:\n");

    use helios_engine::AutoForest;

    let mut forest = AutoForest::new(Config::builder().m("gpt-4").build())
        .with_tools(vec![Box::new(CalculatorTool)])
        .build()
        .await?;

    // Use .run() for shortest syntax
    let forest_result = forest.run("Analyze these numbers: 10, 20, 30, 40").await?;
    println!("Forest Result:\n{}\n", forest_result);

    // ========== COMPARISON TABLE ==========
    println!("📊 Syntax Comparison - Short vs Long:\n");
    println!("┌─────────────────────┬──────────────────────┬─────────────────┐");
    println!("│ Operation           │ Short Syntax         │ Long Syntax      │");
    println!("├─────────────────────┼──────────────────────┼─────────────────┤");
    println!("│ Create Agent        │ Agent::quick()       │ Agent::builder()│");
    println!("│ Ask Question        │ .ask()               │ .chat()          │");
    println!("│ System Prompt       │ .prompt()            │ .system_prompt() │");
    println!("│ Config Model        │ .m()                 │ .model()         │");
    println!("│ Config Key          │ .key()               │ .api_key()       │");
    println!("│ Config Temp         │ .temp()              │ .temperature()   │");
    println!("│ Config Tokens       │ .tokens()            │ .max_tokens()    │");
    println!("│ System Message      │ ChatMessage::sys()   │ ChatMessage::system()");
    println!("│ User Message        │ ChatMessage::msg()   │ ChatMessage::user()");
    println!("│ Assistant Message   │ ChatMessage::reply() │ ChatMessage::assistant()");
    println!("│ AutoForest Execute  │ .run()               │ .execute_task()  │");
    println!("└─────────────────────┴──────────────────────┴─────────────────┘\n");

    println!("✅ All examples completed!");
    println!("💡 Tip: Mix and match short and long syntax based on your preference!");

    Ok(())
}

pub fn assistant(content: impl Into<String>) -> Self

Creates a new assistant message.

pub fn reply(content: impl Into<String>) -> Self

Creates a new assistant message. Alias for assistant().

Examples found in repository

examples/ultra_simple.rs (line 73)

async fn main() -> helios_engine::Result<()> {
    println!("🚀 Ultra Simple Helios Example\n");

    // ========== SIMPLEST AGENT CREATION ==========
    println!("1️⃣  Creating an agent - shortest possible syntax:\n");

    // One-liner: Create agent with auto config
    let mut agent = Agent::builder("Helper")
        .auto_config()
        .prompt("You are helpful and concise.")
        .build()
        .await?;

    println!("✓ Agent created!\n");

    // ========== SIMPLEST CHAT ==========
    println!("2️⃣  Asking questions - simplest possible:\n");

    // Use .ask() instead of .chat() for more natural syntax
    let answer = agent.ask("What is 2+2?").await?;
    println!("Q: What is 2+2?\nA: {}\n", answer);

    // ========== SIMPLEST CONFIG ==========
    println!("3️⃣  Creating config with shortest syntax:\n");

    // Ultra-short config creation
    let _config = Config::builder()
        .m("gpt-4") // .m() is shorthand for .model()
        .key("your-api-key") // .key() is shorthand for .api_key()
        .temp(0.8) // .temp() is shorthand for .temperature()
        .tokens(1024) // .tokens() is shorthand for .max_tokens()
        .build();

    println!("✓ Config created with ultra-short syntax!\n");

    // ========== SIMPLEST AGENT WITH TOOLS ==========
    println!("4️⃣  Agent with tools - simplest way:\n");

    let mut calc_agent = Agent::builder("Calculator")
        .auto_config()
        .prompt("You are a math expert.")
        .with_tool(Box::new(CalculatorTool)) // Add single tool
        .build()
        .await?;

    let result = calc_agent.ask("Calculate 15 * 7 + 5").await?;
    println!("Q: Calculate 15 * 7 + 5\nA: {}\n", result);

    // ========== SIMPLEST QUICK AGENT ==========
    println!("5️⃣  Quick agent - one method call:\n");

    // Agent::quick() creates agent in ONE LINE with auto config!
    let mut quick_agent = Agent::quick("QuickBot").await?;
    let quick_answer = quick_agent.ask("Say hello!").await?;
    println!("Response: {}\n", quick_answer);

    // ========== SIMPLEST CHAT MESSAGES ==========
    println!("6️⃣  Creating messages - super short syntax:\n");

    use helios_engine::ChatMessage;

    // Short aliases for message creation
    let _sys_msg = ChatMessage::sys("You are helpful"); // .sys() not .system()
    let _user_msg = ChatMessage::msg("Hello there"); // .msg() not .user()
    let _reply_msg = ChatMessage::reply("Hi! How can I help?"); // .reply() not .assistant()

    println!("✓ Messages created with ultra-short syntax!\n");

    // ========== SHORTEST AUTOFOREST ==========
    println!("7️⃣  AutoForest - simplest multi-agent orchestration:\n");

    use helios_engine::AutoForest;

    let mut forest = AutoForest::new(Config::builder().m("gpt-4").build())
        .with_tools(vec![Box::new(CalculatorTool)])
        .build()
        .await?;

    // Use .run() for shortest syntax
    let forest_result = forest.run("Analyze these numbers: 10, 20, 30, 40").await?;
    println!("Forest Result:\n{}\n", forest_result);

    // ========== COMPARISON TABLE ==========
    println!("📊 Syntax Comparison - Short vs Long:\n");
    println!("┌─────────────────────┬──────────────────────┬─────────────────┐");
    println!("│ Operation           │ Short Syntax         │ Long Syntax      │");
    println!("├─────────────────────┼──────────────────────┼─────────────────┤");
    println!("│ Create Agent        │ Agent::quick()       │ Agent::builder()│");
    println!("│ Ask Question        │ .ask()               │ .chat()          │");
    println!("│ System Prompt       │ .prompt()            │ .system_prompt() │");
    println!("│ Config Model        │ .m()                 │ .model()         │");
    println!("│ Config Key          │ .key()               │ .api_key()       │");
    println!("│ Config Temp         │ .temp()              │ .temperature()   │");
    println!("│ Config Tokens       │ .tokens()            │ .max_tokens()    │");
    println!("│ System Message      │ ChatMessage::sys()   │ ChatMessage::system()");
    println!("│ User Message        │ ChatMessage::msg()   │ ChatMessage::user()");
    println!("│ Assistant Message   │ ChatMessage::reply() │ ChatMessage::assistant()");
    println!("│ AutoForest Execute  │ .run()               │ .execute_task()  │");
    println!("└─────────────────────┴──────────────────────┴─────────────────┘\n");

    println!("✅ All examples completed!");
    println!("💡 Tip: Mix and match short and long syntax based on your preference!");

    Ok(())
}

pub fn tool(content: impl Into<String>, tool_call_id: impl Into<String>) -> Self

Creates a new tool message.

Trait Implementations

impl Clone for ChatMessage

fn clone(&self) -> ChatMessage

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChatMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ChatMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ChatMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.