Struct Chat 

pub struct Chat<A> { /* private fields */ }

A conversation with an agent: every send carries the turns before it, and the conversation keeps its own State.

use gemini_adk_rs::llm::{LlmResponse, MockLlm};
use gemini_adk_rs::text::{LlmTextAgent, TextAgent};

let llm = MockLlm::script([
    LlmResponse::from_text("Nice to meet you, Ada."),
    LlmResponse::from_text("Your name is Ada."),
]);
let agent = LlmTextAgent::new("assistant", llm.clone());

let mut chat = agent.chat();
chat.send("Hi, I'm Ada.").await.unwrap();
assert_eq!(chat.send("What's my name?").await.unwrap(), "Your name is Ada.");

// The second request carried the whole conversation.
assert_eq!(llm.last_request().unwrap().contents.len(), 3);
assert_eq!(chat.history().len(), 4);

agent.chat() borrows the agent; Chat::new(agent) takes it, for a conversation that outlives the scope that built the agent.

Implementations

impl<A: TextAgent> Chat<A>

pub fn new(agent: A) -> Self

A new conversation with agent, with empty history and fresh state.

pub fn with_state(agent: A, state: State) -> Self

A new conversation that reads and writes state.

pub async fn send( &mut self, message: impl Into<String>, ) -> Result<String, AgentError>

Send a message and get the reply. The turn is added to the history only when it succeeds.

pub async fn send_request( &mut self, request: RunRequest, ) -> Result<RunResult, AgentError>

Send a request (media, a response schema) and get the full result. The request’s own history is replaced by the conversation’s.

pub fn send_stream( &mut self, message: impl Into<String>, ) -> BoxStream<'_, Result<RunEvent, AgentError>>

Send a message and stream the reply; the turn joins the history when the stream delivers RunEvent::Finished.

pub fn history(&self) -> &[Content]

Every turn so far, oldest first.

pub fn usage(&self) -> TokenUsage

Tokens used by the conversation so far.

pub fn state(&self) -> &State

The conversation’s state.

pub fn clear(&mut self)

Forget the history (the state is kept).