Struct MockProvider

Source

pub struct MockProvider {
    pub info: ModelInfo,
    pub responses: Vec<CompletionResponse>,
    /* private fields */
}

Expand description

Deterministic mock provider that returns responses in sequence.

Each call to complete() returns the next response from the internal sequence. When all responses have been returned, subsequent calls return the last response (clamp behavior, not wrap-around).

§Thread Safety

MockProvider is Send + Sync by design — it uses AtomicUsize for lock-free call indexing.

§Example

use traitclaw_test_utils::provider::MockProvider;

let p = MockProvider::text("hello");
// p.complete(req).await returns "hello" every time

Fields§

§info: ModelInfo

Model information returned by Provider::model_info.

§responses: Vec<CompletionResponse>

Ordered list of responses to return.

Implementations§

Source §

impl MockProvider

Source

pub fn text(text: &str) -> Self

Create a provider that always returns a single text response.

§Example

use traitclaw_test_utils::provider::MockProvider;

let p = MockProvider::text("I am a mock LLM");

Source

pub fn sequence(responses: Vec<CompletionResponse>) -> Self

Create a provider with an explicit sequence of responses.

Responses are returned in order. Once exhausted, the last response is repeated.

§Panics

Panics if responses is empty.

§Example

use traitclaw_test_utils::provider::MockProvider;
use traitclaw_core::types::completion::{CompletionResponse, ResponseContent, Usage};

let p = MockProvider::sequence(vec![
    CompletionResponse {
        content: ResponseContent::Text("first".into()),
        usage: Usage { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
    },
    CompletionResponse {
        content: ResponseContent::Text("second".into()),
        usage: Usage { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
    },
]);

Source

pub fn tool_then_text(tool_calls: Vec<ToolCall>, final_text: &str) -> Self

Create a provider that returns tool calls first, then a final text response.

This is the standard pattern for testing ReAct-style agent loops.

§Example

use traitclaw_test_utils::provider::MockProvider;
use traitclaw_core::types::tool_call::ToolCall;

let p = MockProvider::tool_then_text(
    vec![ToolCall {
        id: "call_1".into(),
        name: "search".into(),
        arguments: r#"{"query":"rust"}"#.into(),
    }],
    "Here are the results.",
);

Source

pub fn always_tool_calls(tool_calls: Vec<ToolCall>) -> Self

Create a provider that always returns tool calls (never text).

Useful for testing tool-budget guards and loop detection.

Source

pub fn error(msg: &str) -> Self

Create a provider that always returns an error.

Useful for testing error handling paths in strategies and agents.

§Example

use traitclaw_test_utils::provider::MockProvider;

let p = MockProvider::error("API rate limit exceeded");
// p.complete(req).await will return Err(Error::Runtime(...))

Source