Struct ScriptedProvider 

pub struct ScriptedProvider { /* private fields */ }

A ModelProvider that answers from a script and refuses to improvise.

Steps are consumed in order. When the script runs out, the provider does not fall back to a default answer: it records a ScriptViolation::UnexpectedCall and fails the call with UNEXPECTED_CALL_CODE, so a runtime that calls a model one more time than the test believed cannot pass silently.

use turnframe_provider::prelude::*;
use turnframe_test::providers::{ScriptedProvider, ScriptedReply};

let provider = ScriptedProvider::builder("fake", "m")
    .reply(ScriptedReply::text("una frase"))
    .build();

let request = ModelRequest::new(ModelPurpose::Acknowledge).with_message(Message::user("ciao"));
assert_eq!(provider.generate(request.clone()).await.unwrap().text(), "una frase");

// The second call was never scripted.
assert!(provider.generate(request).await.is_err());
assert!(provider.verify().is_err());

Implementations

impl ScriptedProvider

pub fn builder( provider: impl Into<ProviderKey>, model: impl Into<ModelKey>, ) -> ScriptedProviderBuilder

A builder for a provider that declares native JSON Schema output, parallel tool calling and no streaming.

Those are the capabilities a mutation-capable interpretation stage requires (spec §20.4), which is what most tests need; call capabilities to say something else.

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

The one-line common case: a provider that acknowledges one turn with text, passes its review, and refuses everything else.

pub fn profile_ref(&self) -> &ModelProfile

The routing profile, as configured.

pub fn candidate(provider: Arc<Self>) -> ProviderCandidate

Wraps a shared provider as a healthy routing candidate.

pub fn calls(&self) -> Vec<RecordedCall>

Every request received, in order.

pub fn call_count(&self) -> usize

How many requests were received.

pub fn nth_call(&self, index: usize) -> Option<RecordedCall>

The index-th request received.

pub fn last_call(&self) -> Option<RecordedCall>

The most recent request received.

pub fn calls_for(&self, purpose: ModelPurpose) -> Vec<RecordedCall>

Every request made for one purpose, in order.

pub fn remaining_steps(&self) -> usize

How many steps are still unused.

pub fn violations(&self) -> Vec<ScriptViolation>

Every violation the script observed, in order.

pub fn verify(&self) -> Result<(), ScriptViolation>

Checks that the script was followed exactly: no unanticipated call and no unused step.

A call the script did not anticipate already failed at the time it was made; this is how the test learns about it even when the code under test swallowed the error.

Errors

The first ScriptViolation observed, or ScriptViolation::StepsUnused when steps remain.

pub fn push(&self, step: ScriptStep)

Appends a step to a provider already in use, for a turn whose script depends on identifiers an earlier turn produced.

pub fn clear_calls(&self)

Forgets the recorded calls and violations, keeping the remaining script.

Trait Implementations

impl Debug for ScriptedProvider

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

Formats the value using the given formatter.

impl ModelProvider for ScriptedProvider

fn provider_key(&self) -> ProviderKey

The configured provider key, e.g. "openai". Labels every metric, attempt record and replay entry this provider produces.

fn model_key(&self) -> ModelKey

The configured model key, e.g. "gpt-4o-2024-08-06".

fn capabilities(&self) -> ProviderCapabilities

What this provider-model pair can actually do (spec §20.3).

fn profile(&self) -> ModelProfile

The full routing profile: keys, capabilities, and the cost, region and tags routing filters on.

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

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

Runs one model call and returns the whole answer.

fn stream<'life0, 'async_trait>( &'life0 self, request: ModelRequest, ) -> Pin<Box<dyn Future<Output = Result<ModelStream, ProviderError>> + Send + 'async_trait>>

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

Runs one model call and returns its answer incrementally.

fn reference(&self) -> ModelRef

The provider-model pair, as routing and health tracking key it.

fn supports( &self, requirements: &CapabilityRequirements, ) -> Result<(), CapabilityMismatch>

Checks the declared capabilities against requirements.