Reads a JSON object or returns a typed translation error at the given path.

Pin ``request``'s conversation to ``value`` (no-op when disabled). Writes through to the L2 when configured; an L2 error is swallowed so

Passthrough when possible, otherwise translate to the first supported type.

Translate a backend response to the original client's wire format.

Return a ChatResponse wrapper in the target wire format.

Send one normalized, buffered text request through LiteLLM.

Build a buffered OpenAI Responses response.

CAPABLE default. EFFICIENT only when the scorer is confidently negative.

Return the value pinned to ``request``'s conversation, or ``None``. Checks L1 first; on a miss (and only when an L2 is configured) consults

Stamps a served model into context the same way native backends do.

Builds an OpenAI Chat request fixture.

Builds a single-turn response: one assistant message carrying `completion`, for `model`. Construct [`AggLlmResponse`] directly when usage, tools, rea

Appends a processor to the head-of-request chain.

Build a streaming Anthropic response.

Finishes target-provider stream emission after the source stream closes.

The `libsy`-scoped meter from the globally installed provider.

Records a successful backend call.

Records token usage and end-to-end latency for a completed response.

Translate a backend stream to the original client's stream contract.

Run DimensionCollector.process() and return the populated context.

Builds an Axum router for the supported LLM wire formats.

Return ``"capable"``, ``"efficient"``, or ``None`` (fall-open).

Looks up a codec by format identifier.

Parses command-line arguments using clap.

Normalize request-format tags and wire strings.

Folds a request and its decision through the router, retaining `model`.

Converts a JSON value into a Python object.

Build the profile-backed runtime used by these tests.

A turn-1 request whose first user message anchors a distinct session.

Builds an Anthropic target fixture.

Build the native Rust backend for one resolved or auto ``LlmTarget``.

Gets a mutable typed extension by Rust type.

Return True iff ``{base_url}/v1/messages`` is a functional route. Sends a model-scoped probe POST with real auth. Response interpretation: *

Applies the lossy-conversion policy and records diagnostics when configured.

Return the latest statistics snapshot.

Converts an arbitrary Python object into a JSON value.

Return the retained values in least-to-most-recent order.

Return a formatted summary string, or empty string if no requests were made.

Return a context manager patching AsyncClient.post. If ``response`` is an Exception, it's raised from the POST; otherwise it's returned.

The top-scoring [`Score`], or `None` when the classifier abstained (an empty set). An [`Ambiguous`](Self::Ambiguous) classification also yields `None

Borrow the aggregate; `None` while this is still a stream.

Returns the base URL for this server.

Encodes a stream of IR chunks into a stream of target-format wire events. `served_model` is exposed as the response model (via the stream state's `ta

Transform each event in registration order.

Resolve ``BackendFormat.AUTO`` into the concrete native backend format.

Drives a fresh router through one turn.

A target set whose targets all serve via [`EchoClient`].

Concatenates text-like content blocks when the message has any.

Return a structured upstream-status response when one can be recovered. Python backends store status/body in ``ctx.metadata``. Rust backends atta

Load all trace JSON files from the output directory, sorted by timestamp.

Build ``config`` and verify the result implements the profile runtime.

Returns the cache-creation input-token count.

Returns the cache-read input-token count.

Inject the guidance note appropriate to the picked tier. Capable tier: the escalation note, gated to real wrong signals when ``only_o

Build a streaming OpenAI Responses response.

Builds an OpenAI target fixture.