Struct MockLlm 

pub struct MockLlm { /* private fields */ }

A BaseLlm that replies from a script or a closure and records every request, for tests that must not reach a provider.

It replies three ways, one per kind of test:

Constructor	Replies with	Use it to test
MockLlm::text	the same text, every call	wiring, prompts, state flow
MockLlm::script	each response in turn, then an error	tool rounds, retries, multi-turn
MockLlm::from_fn	whatever the closure returns	replies that depend on the request

Every call’s LlmRequest is recorded, so a test can assert on what the agent actually sent — instructions, history, tool declarations, sampling — not only on what came back.

MockLlm is a cheap handle: clones share the script and the recording. Give one clone to the agent and keep one to inspect.

use gemini_adk_rs::llm::{BaseLlm, LlmRequest, LlmResponse, MockLlm};

let llm = MockLlm::script([
    LlmResponse::tool_call("get_weather", serde_json::json!({ "city": "Paris" })),
    LlmResponse::from_text("It is sunny in Paris."),
]);

let first = llm.generate(LlmRequest::from_text("Weather in Paris?")).await.unwrap();
assert_eq!(first.function_calls()[0].name, "get_weather");

let second = llm.generate(LlmRequest::from_text("…")).await.unwrap();
assert_eq!(second.text(), "It is sunny in Paris.");

// The script is spent: a third call is a test failure, not a silent reply.
assert!(llm.generate(LlmRequest::from_text("again")).await.is_err());
assert_eq!(llm.requests().len(), 3);

Implementations

impl MockLlm

pub fn text(text: impl Into<String>) -> MockLlm

Reply with text to every request.

pub fn script(responses: impl IntoIterator<Item = LlmResponse>) -> MockLlm

Reply with each response in order.

A call after the script is spent returns an error naming the call, so an agent that makes one model call more than the test expected fails instead of receiving a plausible reply.

pub fn from_fn<F>(reply: F) -> MockLlm

where F: Fn(&LlmRequest) -> Result<LlmResponse, LlmError> + Send + Sync + 'static,

Reply by calling reply with the request.

This is the programmable mock: branch on the conversation so far, echo the prompt, or return an error for a particular input.

pub fn then_fail(self, error: LlmError) -> MockLlm

Append a failure to a script, to test how an agent handles a provider error at that point in the conversation.

Panics

On a mock built with text or from_fn: those have no sequence to append to, and a closure can return the error itself.

pub fn with_model_id(self, model_id: impl Into<String>) -> MockLlm

Report model_id from BaseLlm::model_id instead of "mock".

pub fn requests(&self) -> Vec<LlmRequest>

Every request received so far, oldest first.

pub fn last_request(&self) -> Option<LlmRequest>

The most recent request, if any.

pub fn call_count(&self) -> usize

How many times the model has been called.

Trait Implementations

impl BaseLlm for MockLlm

fn generate_stream<'life0, 'async_trait>( &'life0 self, request: LlmRequest, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<LlmResponse, LlmError>> + Send>>, LlmError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MockLlm: 'async_trait,

Streams a text reply one word at a time (usage and the finish reason ride on the last chunk), so tests exercise the multi-chunk path; a reply with tool calls arrives as one chunk.

fn model_id(&self) -> &str

The model identifier (e.g., “gemini-2.5-flash”).

fn generate<'life0, 'async_trait>( &'life0 self, request: LlmRequest, ) -> Pin<Box<dyn Future<Output = Result<LlmResponse, LlmError>> + Send + 'async_trait>>

where 'life0: 'async_trait, MockLlm: 'async_trait,

Generate content from the LLM.

fn capabilities(&self) -> ModelCapabilities

What this model supports — the ADK model-capability-declaration pattern: the model states its capabilities instead of every caller re-inferring them from the id string. The default derives a conservative estimate from model_id; back-ends with authoritative knowledge should override.

fn warm_up<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), LlmError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Pre-warm the HTTP connection pool to avoid cold-start latency.

impl Clone for MockLlm

fn clone(&self) -> MockLlm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MockLlm

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

Formats the value using the given formatter.