Per-request state shared by Python and native components.

Single Python-facing engine for request, response, and stream translation.

Pins a routing decision per conversation and reuses it on later turns. The shared building block both routing paths use for the *common* part of

Convert a stamped :class:`RouteDecision` into a deterministic backend tier. This processor performs no LLM calls and does not mutate the request

Raised when a YAML route bundle is malformed.

Extract semantic routing signals by calling an underlying LLM. The processor leaves the inbound request unchanged. It validates the classifie

Validated parsing config for weighted strong/weak random routing.

Configuration for :class:`LLMClassifierRequestProcessor`. The classifier call is OpenAI-chat-compatible by default. Tests and custom hosts ca

Call a LiteLLM gateway alias for a libsy target.

Table that maps model names to pre-built profile runtimes. Register one chain per model the proxy should handle explicitly. Unknown models ra

Policy for mapping :class:`RouteDecision` to backend tier labels. ``tier_mapping`` translates abstract classifier tiers such as ``RouteTier.S

Expose a Profile through the existing ``Switchyard.call`` protocol. Endpoints and route registries currently call ``obj.call(request, ctx=...)``

Provider request and metadata passed to a Python profile.

Python-only compatibility chain for the current FastAPI/recipe surface.

Run existing processor/backend components as one Profile runtime. This is intentionally private. It lets Profile configs own construction dir

Async LLM classifier — one call per invocation; fails open to ``None``.

Translate the response back to the inbound format the client expects. Reads ``ctx.metadata[CTX_ORIGINAL_FORMAT]`` (stamped by :class:`StampOr

Client that wraps the official OpenAI Python SDK. Works with any OpenAI-compatible API (OpenAI, NVIDIA NIM, Azure, vLLM, etc.) by accepting a

Wrap an Anthropic-format LLMBackend to inject ephemeral cache breakpoints. Drop-in around the inner backend. ``startup`` / ``shutdown`` / ``

Picks a tier and stamps it on the context. Policy lives in the picker.

Backend that calls an Anthropic-compatible Messages API.

Appends a guidance note to a tier-picked request driven by real signals. Stateless — no per-session tracking. On the capable tier the note fires

General-purpose signal record (default profile, backwards-compatible). Suited for mixed traffic — chat, summarization, extraction, generic coding

Append one JSON line per completed request to ``log_file``. Each record carries the routing decision (selected model and tier), the caller-su

Records the request handed to it and returns a canned response.

Mimics the OpenAI/Anthropic SDK ``AsyncStream``. Async-iterable and closable via an async ``close()`` (the SDK shape — not the async-generato

Configuration for :class:`EscalationJudgeRequestProcessor`. The judge call is OpenAI-chat-compatible; tests inject any object implementing th

Route weak until an LLM judge says the run is in trouble, then latch strong. Per-turn policy (the latch): a pinned conversation routes strong wit

Raised when an upstream request exceeds the context window.

Configuration for the deterministic LLM-classifier routing profile. A strong/weak tier pair plus a classifier LLM target. The classifier insp

Raised when a Python profile config declaration is invalid.

Normalize ``request.body["reasoning_effort"]`` to an upstream-valid value. No-op when the field is absent or already a valid value. Maps known

Shared, persistent pin store backed by a standalone Redis. Args: url: Redis connection URL (e.g. ``"redis://host:6379/0"``). ttl_

Snapshot the inbound request as an OpenAI-Chat body for RL trace logging. The response-side logger only receives ``(ctx, response)``, so the requ

Dataclass profile config for direct single-upstream passthrough profiles.

Write one ``message_history`` JSON trace per completed turn to ``log_dir``. Restores the pre-1.0 ``--enable-rl-logging`` local trace format: each

Thread-safe counter for stage_router decision sources.

Wrap a runtime, sending delegated sub-agent work to ``worker`` instead. Normal traffic runs the wrapped runtime unchanged. A request whose header

A request-shaped object unknown to either engine. Used to verify that NotImplementedError is raised with a useful message instead of silently

In-memory AffinityPinStore double with call counters.

Result of a single classifier LLM call. Carries the raw ``content`` (a JSON string to be parsed into :class:`RouteDecision`) and the raw SDK

A decision that reports a fixed selected model.

Live stats footer: aggregate row + one row per active model tier.

Look up the selected model's target format from the translate config. After a router picks a tier and stamps its model name into ``ctx.select

Host one TOML deployment through the PyO3 Rust server binding.

OpenAI-chat-compatible implementation of :class:`LLMClassifierClient`. Defaults to strict Structured Outputs (``response_format`` of type ``j

Backend that calls an OpenAI-compatible Chat Completions or Responses API.

Run a child process in a PTY with a live footer drawn below it. The terminal is split into two regions via DECSTBM (scroll-region): * rows 1

Model-to-format map used by IGW-owned translation processors.

Manually-advanced monotonic clock for deterministic breaker tests.

Failing store that counts attempts and can be healed mid-test.

A ChainRuntime stand-in that records the calls routed to it.

Composable endpoint that exposes ``POST /v1/messages``.

Concrete backend format selected for a generic tier.

Dispatch to the tier picked by the upstream router processor. Args: tiers: Mapping of tier label to ``(LLMBackend, model_name)``.

Renders every field type into a string map so assertions can use `contains`.

Raised when the classifier LLM cannot produce valid route signals.

A bundle pairing a classifier prompt with its schema and routing policy. Treat this as the indivisible unit. Don't mix-and-match a prompt from

Writes a tag into ctx.metadata to prove it ran.

Mutates the model field on the request body.

Composable endpoint that exposes ``POST /v1/chat/completions``. Reads the raw JSON body, wraps it in a Rust-backed OpenAI chat request (no va

Request metadata available to Python profile runtimes.

Periodic liveness probe for the in-process proxy. ``poll()`` is designed to run from a footer-render thread. It performs a quick ``GET /healt

Rewrite requests to the randomly selected strong or weak target. This is a compatibility component for the current Python profile chain.

Composable endpoint that exposes ``POST /v1/responses``.

Raised when a processor fails.

Raised when an upstream call fails.

Audit record for one signal-to-tier decision. Captures both the LLM's own vote (``llm_recommended_tier``) and the Python policy's computed ve

Loopback OpenAI-compatible server that streams SSE chunks slowly. Streams many chunks with a delay so a client that reads one frame and aband