Multi-turn Conversations

client.new_conversation();

// Add context to the conversation
client.append_message(Message::new(
    Type::User,
    "Let's play a word association game.".to_string(),
));
client.append_message(Message::new(
    Type::Assistant,
    "Great! I'm ready to play. Go ahead!".to_string(),
));
client.append_message(Message::new(Type::User, "Ocean".to_string()));
client.append_message(Message::new(Type::Assistant, "Waves".to_string()));
client.append_message(Message::new(Type::User, "Beach".to_string()));

// Now send without a new message - it will respond to "Beach"
let response = client
    .send("gemini-2.5-flash-lite", None, Some(config))
    .await?;

println!("Conversation history:");
for msg in client.get_messages() {
    let role = match msg.role {
        Type::User => "User",
        Type::Assistant => "Assistant",
    };
    println!("{}: {}", role, msg.content);
}

// Get the current thread ID
if let Some(thread_id) = client.get_thread_id() {
    println!("Thread ID: {}", thread_id);
}

// Get message count
let message_count = client.get_messages().len();
println!("Total messages: {}", message_count);

// Clear all history and start fresh
client.new_conversation();

// This will start a completely new conversation thread
let response = client
    .send(
        "claude-3.7",
        Some(Message::new(Type::User, "Hello!".to_string())),
        Some(config),
    )
    .await?;

// Clear messages but keep the same thread ID
client.clear_messages();

use dotenv::dotenv;
use t3router::t3::{
    client::Client,
    config::Config,
    message::{Message, Type},
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenv().ok();

    let cookies = std::env::var("COOKIES").expect("COOKIES not set");
    let convex_session_id = std::env::var("CONVEX_SESSION_ID")
        .expect("CONVEX_SESSION_ID not set");

    let mut client = Client::new(cookies, convex_session_id);
    client.init().await?;

    let config = Config::new();

    println!("=== Multi-turn Conversation ===");
    client.new_conversation();
    
    client.append_message(Message::new(
        Type::User,
        "I'm planning a trip to Paris. What are the top 3 attractions?".to_string(),
    ));
    
    let response1 = client
        .send("gemini-2.5-flash-lite", None, Some(config.clone()))
        .await?;
    
    println!("User: I'm planning a trip to Paris. What are the top 3 attractions?");
    println!("Assistant: {}", response1.content);

    let response2 = client
        .send(
            "gemini-2.5-flash-lite",
            Some(Message::new(
                Type::User,
                "Tell me more about the first one.".to_string(),
            )),
            Some(config.clone()),
        )
        .await?;
    
    println!("\nUser: Tell me more about the first one.");
    println!("Assistant: {}", response2.content);

    let response3 = client
        .send(
            "gemini-2.5-flash-lite",
            Some(Message::new(
                Type::User,
                "What's the best time to visit?".to_string(),
            )),
            Some(config),
        )
        .await?;
    
    println!("\nUser: What's the best time to visit?");
    println!("Assistant: {}", response3.content);

    println!("\n=== Conversation Summary ===");
    println!("Total messages: {}", client.get_messages().len());
    println!("Thread ID: {:?}", client.get_thread_id());

    Ok(())
}

=== Multi-turn Conversation ===
User: I'm planning a trip to Paris. What are the top 3 attractions?
Assistant: The top 3 attractions in Paris are:
1. The Eiffel Tower
2. The Louvre Museum
3. Notre-Dame Cathedral

User: Tell me more about the first one.
Assistant: The Eiffel Tower is an iconic iron lattice tower...

User: What's the best time to visit?
Assistant: The best time to visit Paris is during spring (April-June)...

=== Conversation Summary ===
Total messages: 6
Thread ID: Some("a1b2c3d4-e5f6-7890-abcd-ef1234567890")

let thread_id = match &self.thread_id {
    Some(id) => id.clone(),
    None => Uuid::new_v4().to_string(),
};

// Simple and straightforward
let response1 = client.send("model", Some(Message::new(Type::User, "Hello".into())), config).await?;
let response2 = client.send("model", Some(Message::new(Type::User, "How are you?".into())), config).await?;

// More control over conversation structure
client.append_message(Message::new(Type::User, "Hello".into()));
client.append_message(Message::new(Type::Assistant, "Hi there!".into()));
client.append_message(Message::new(Type::User, "How are you?".into()));

// Send all at once
let response = client.send("model", None, config).await?;