Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.
Rust
chore(routing): remove public noop and passthrough route types (#148)
Elyas Mehtabuddin9762a070e3d9
diff --git a/.github/workflows/getting-started.yml b/.github/workflows/getting-started.ymlindex be8fb0169..748929ec1 100644--- a/.github/workflows/getting-started.yml+++ b/.github/workflows/getting-started.yml@@ -51,15 +51,15 @@ jobs:- name: Exercise the guide# Single invocation: pytest picks up tests/getting_started/ (CLI, YAML,# serve lifecycle) AND --markdown-docs execs the Python snippet from- # the guide. The passthrough→noop fixture lives in+ # the guide. The local mock-upstream fixture lives in# tests/getting_started/conftest.py so it only loads when collecting# from that subtree.run: uv run pytest tests/getting_started --markdown-docs docs/getting_started.md -venv:- # The server-lifecycle test interpolates ${OPENAI_API_KEY} into a- # noop-backed routes.yaml; the value is never sent upstream. Stub- # so the bundle loader's env-var resolution doesn't fail on a- # clean runner.+ # The server-lifecycle test serves a type: model route pointed at a+ # local in-process mock OpenAI upstream; these keys are never sent+ # upstream. Stub so the bundle loader's env-var resolution doesn't+ # fail on a clean runner.OPENAI_API_KEY: sk-testNVIDIA_API_KEY: nvapi-testANTHROPIC_API_KEY: sk-ant-testdiff --git a/.github/workflows/perf.yml b/.github/workflows/perf.ymlindex a71312169..8b988c57e 100644--- a/.github/workflows/perf.yml+++ b/.github/workflows/perf.yml@@ -23,12 +23,15 @@ permissions:jobs:proxy-perf:- name: Proxy overhead (No-Op backend)+ name: Proxy overhead (local stub backend)runs-on: ubuntu-latestenv:PROXY_PORT: 4000- PERF_MODEL: noop+ STUB_PORT: 9000+ # A local zero-latency stub replaces the removed noop route; the proxy+ # forwards to it over loopback, which adds a small constant overhead.+ PERF_MODEL: mock-model# gpt2 tokenizer is ~500 KB and downloads in < 2 s on Actions runners.# It is only used for dataset-manager token counting; actual inference# token counts come from the server (--use-server-token-count).@@ -52,14 +55,91 @@ jobs:run: uv pip install aiperf# ------------------------------------------------------------------- # Start the proxy with the No-Op backend+ # Start a local zero-latency mock OpenAI upstream. This replaces the+ # removed noop route: the proxy serves a real `type: model` chain that+ # forwards to this loopback stub, which returns a fixed completion+ # instantly. The extra loopback hop adds a small constant overhead.# ------------------------------------------------------------------- - name: Start switchyard noop proxy+ - name: Start local mock OpenAI upstreamrun: |- cat > bench.yaml <<'YAML'+ cat > perf_stub.py <<'PY'+ """Zero-latency OpenAI-compatible chat.completions stub (loopback only)."""+ import json+ import os+ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer++ _COMPLETION = {+ "id": "chatcmpl-perf-stub",+ "object": "chat.completion",+ "created": 1700000000,+ "model": "mock-model",+ "choices": [+ {+ "index": 0,+ "message": {"role": "assistant", "content": "4"},+ "finish_reason": "stop",+ }+ ],+ "usage": {"prompt_tokens": 5, "completion_tokens": 1, "total_tokens": 6},+ }++ _CHUNK = {+ "id": "chatcmpl-perf-stub",+ "object": "chat.completion.chunk",+ "created": 1700000000,+ "model": "mock-model",+ "choices": [+ {"index": 0, "delta": {"content": "4"}, "finish_reason": "stop"}+ ],+ "usage": {"prompt_tokens": 5, "completion_tokens": 1, "total_tokens": 6},+ }+++ class Handler(BaseHTTPRequestHandler):+ protocol_version = "HTTP/1.1"++ def do_POST(self):+ length = int(self.headers.get("content-length", "0"))+ body = json.loads(self.rfile.read(length) or b"{}")+ if body.get("stream"):+ payload = (+ f"data: {json.dumps(_CHUNK)}\n\n".encode()+ + b"data: [DONE]\n\n"+ )+ content_type = "text/event-stream"+ else:+ payload = json.dumps(_COMPLETION).encode()+ content_type = "application/json"+ self.send_response(200)+ self.send_header("content-type", content_type)+ self.send_header("content-length", str(len(payload)))+ self.end_headers()+ self.wfile.write(payload)++ def log_message(self, *_args):+ return None+++ port = int(os.environ["STUB_PORT"])+ ThreadingHTTPServer(("127.0.0.1", port), Handler).serve_forever()+ PY+ python3 perf_stub.py &+ echo "STUB_PID=$!" >> "$GITHUB_ENV"++ # ------------------------------------------------------------------+ # Start the proxy: a `type: model` route pointed at the local stub.+ # ------------------------------------------------------------------+ - name: Start switchyard proxy+ run: |+ cat > bench.yaml <<YAML+ defaults:+ api_key: dummy+ base_url: http://localhost:$STUB_PORT/v1+ format: openairoutes:- noop:- type: noop+ mock-model:+ type: model+ model: mock-modelYAMLuv run switchyard --routing-profiles bench.yaml -- serve --port $PROXY_PORT &echo "PROXY_PID=$!" >> "$GITHUB_ENV"@@ -128,11 +208,13 @@ jobs:--output-artifact-dir perf-results/streaming# ------------------------------------------------------------------- # Stop proxy+ # Stop proxy and local stub# ------------------------------------------------------------------- - name: Stop proxy+ - name: Stop proxy and stubif: always()- run: kill "$PROXY_PID" || true+ run: |+ kill "$PROXY_PID" || true+ kill "$STUB_PID" || true# ------------------------------------------------------------------# Upload results as a build artifact for comparison over timediff --git a/.github/workflows/readme.yml b/.github/workflows/readme.ymlindex e21912be8..b0bb4a7f6 100644--- a/.github/workflows/readme.yml+++ b/.github/workflows/readme.yml@@ -51,8 +51,8 @@ jobs:- name: Exercise the README# Single invocation: pytest picks up tests/readme/ (YAML schema + CLI# checks) AND --markdown-docs execs the Python snippet from the README.- # The passthrough→noop fixture lives in tests/readme/conftest.py so it- # only loads when collecting from that subtree.+ # The local mock-upstream fixture lives in tests/readme/conftest.py so+ # it only loads when collecting from that subtree.run: uv run pytest tests/readme --markdown-docs README.md -venv:# The YAML examples reference ${NVIDIA_API_KEY} etc.; stub so thediff --git a/CHANGELOG.md b/CHANGELOG.mdindex bd9d04b45..56661edfd 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -17,6 +17,11 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).KV-cache-aware routing with request failover) or an external load balancersuch as [Traefik](https://doc.traefik.io/traefik/reference/routing-configuration/http/load-balancing/service/)or HAProxy.+- **Public `type: noop` and `type: passthrough` route types** — removed from+ route bundles. Use `type: model` to register a single explicit model target.+ Catalog auto-discovery via a bare `type: passthrough` route is gone; there is+ no `type: model` equivalent, so list the model ids you want as explicit+ `type: model` routes.## [0.1.0] — Initial releasediff --git a/docs/cli_reference.md b/docs/cli_reference.mdindex 618942b25..bc4df7274 100644--- a/docs/cli_reference.md+++ b/docs/cli_reference.md@@ -67,7 +67,7 @@ on the launchers; `serve` uses `--routing-profiles`:| Flag | Purpose ||---|---|| `--model ID` | Single-model passthrough. Every request is rewritten to `model=ID` and forwarded to `--base-url`. |-| `--routing-profiles PATH` | Path to a routing-profile YAML bundle. Each entry under `routes:` builds its own chain. Public route types are `model`, `passthrough`, `random_routing`, `stage_router`, `escalation_router`, and `deterministic`. Falls back to the path persisted by `switchyard --routing-profiles PATH -- configure` when omitted. |+| `--routing-profiles PATH` | Path to a routing-profile YAML bundle. Each entry under `routes:` builds its own chain. Public route types are `model`, `random_routing`, `stage_router`, `escalation_router`, and `deterministic`. Falls back to the path persisted by `switchyard --routing-profiles PATH -- configure` when omitted. |On the launchers, the two flags are mutually exclusive: pass one or the other, not both.diff --git a/docs/core_concepts.md b/docs/core_concepts.mdindex 739c70a73..3e452ab8c 100644--- a/docs/core_concepts.md+++ b/docs/core_concepts.md@@ -37,7 +37,8 @@ has a complete runnable bundle.Every route name is registered as a model ID and listed on `GET /v1/models`.Clients select a route by putting that name in the request's `model` field.-Some route types also discover or register direct upstream model IDs.+Some route types also discover a tier's upstream catalog from its+`GET /v1/models` and register those model IDs directly.## Tiers and routing strategies@@ -46,7 +47,7 @@ is more capable and more expensive, and a weak target that is cheaper andfaster. A tier is a role assigned inside a route, not a fixed property of amodel.-A route's `type` sets the strategy. `model` and `passthrough` call one target.+A route's `type` sets the strategy. `model` calls one target.`random_routing` splits traffic on a fixed probability. `deterministic` asks aclassifier model to pick a tier. `stage_router` uses agent-progress signals,with an optional classifier fallback. `escalation_router` starts on the weakdiff --git a/docs/operations/context_window.md b/docs/operations/context_window.mdindex 1b9e50c57..a6504e157 100644--- a/docs/operations/context_window.md+++ b/docs/operations/context_window.md@@ -8,7 +8,7 @@ format.Any multi-target route (stage-router, random_routing, or deterministic) supportsthis. Set `fallback_target_on_evict` on the route. Single-target routes-(`type: passthrough`, `type: model`) have no alternative target, so the original+(`type: model`) have no alternative target, so the originaloverflow propagates unchanged.## Configurationdiff --git a/docs/routing_algorithms/overview.md b/docs/routing_algorithms/overview.mdindex 75dfcdb40..96b8d4cb2 100644--- a/docs/routing_algorithms/overview.md+++ b/docs/routing_algorithms/overview.md@@ -56,14 +56,13 @@ The examples use model IDs from the[OpenRouter model catalog](https://openrouter.ai/api/v1/models). Select IDsavailable to your account before deploying; catalog availability can change.-## Model and passthrough routes+## Model routes- `type: model` registers one explicit model alias without model discovery.-- `type: passthrough` queries the upstream model catalog and registers the- discovered models.-Both create direct, single-target chains. Use a routing policy when requests-must be split or classified across targets.+This creates a direct, single-target chain. Use a routing policy when requests+must be split or classified across targets. There is no catalog auto-discovery,+so to expose several upstream models, add one `type: model` route per model id.## Self-hosted targets@@ -133,7 +132,7 @@ Claude Code lineage signals in either direction: `false` keeps the request onnormal routing even when delegated-work headers are present, and `true` marks arequest as a sub-agent even when no harness headers appear.-The key applies to `model`, `passthrough`, `deterministic`, `escalation_router`,+The key applies to `model`, `deterministic`, `escalation_router`,and `stage_router` routes. `random_routing` expands into its table entries on aseparate path and does not consume it.diff --git a/docs/routing_algorithms/stage_router_routing.md b/docs/routing_algorithms/stage_router_routing.mdindex be8b6ddec..589e9cff3 100644--- a/docs/routing_algorithms/stage_router_routing.md+++ b/docs/routing_algorithms/stage_router_routing.md@@ -280,7 +280,7 @@ curl -s http://localhost:4000/v1/stats > routing_stats_final.json## When *not* to use stage-router-- **Single-model deployments.** Use a `model` or `passthrough` route instead.+- **Single-model deployments.** Use a `model` route instead.- **Probabilistic A/B splits.** Use[Random Routing](random_routing.md) (`type: random_routing`).The stage-router's signals are wasted on a fixed traffic ratio.diff --git a/examples/route.yaml b/examples/route.yamlindex 9575ab5e1..df468ce44 100644--- a/examples/route.yaml+++ b/examples/route.yaml@@ -8,9 +8,6 @@ routes:type: modeltarget: moonshotai/kimi-k2.6- openrouter-catalog: # `type: passthrough` — auto-discovers available models via GET /v1/models- type: passthrough-random-router: # `type: random_routing` — weighted cointype: random_routingstrong: anthropic/claude-opus-4.7@@ -18,9 +15,6 @@ routes:strong_probability: 0.3fallback_target_on_evict: strong- bench: # `type: noop` — for benchmarking- type: noop-llm-classifier: # `type: deterministic` — LLM-as-classifiertype: deterministicprofile: coding_agent # general | coding_agent | openclawdiff --git a/switchyard/__init__.py b/switchyard/__init__.pyindex 5fc93f89e..c64530efa 100644--- a/switchyard/__init__.py+++ b/switchyard/__init__.py@@ -52,8 +52,6 @@ from switchyard.lib.profiles import (DeterministicRoutingProfileConfig,EscalationRouterConfig,EscalationRouterProfileConfig,- NoopProfile,- NoopProfileConfig,PassthroughProfileConfig,Profile,ProfileConfig,@@ -138,8 +136,6 @@ __all__ = [# Chain infrastructure"Switchyard","LLMBackend",- "NoopProfile",- "NoopProfileConfig","StageRouterConfig","StageRouterProfileConfig","ClassifierConfig",diff --git a/switchyard/cli/launchers/launcher_runtime.py b/switchyard/cli/launchers/launcher_runtime.pyindex 6d862bc47..c40367415 100644--- a/switchyard/cli/launchers/launcher_runtime.py+++ b/switchyard/cli/launchers/launcher_runtime.py@@ -274,7 +274,7 @@ def _route_type_summary(route_type: str, route: object, route_key: str) -> str:if route_type == "random_routing":p = r.get("strong_probability", "")return f"random-routing: strong={_model(r.get('strong'))}, weak={_model(r.get('weak'))}, p_strong={p}"- if route_type in ("model", "passthrough"):+ if route_type == "model":target = r.get("model") or r.get("target") or route_keyreturn f"passthrough → {target}"return f"{route_type}: {route_key}"diff --git a/switchyard/cli/route_bundle.py b/switchyard/cli/route_bundle.pyindex a465a3906..9e9b454af 100644--- a/switchyard/cli/route_bundle.py+++ b/switchyard/cli/route_bundle.py@@ -180,18 +180,6 @@ _RANDOM_ROUTING_ROUTE_KEYS = _ROUTE_METADATA_KEYS | _TARGET_DEFAULT_ROUTE_KEYS |"preset","fallback_target_on_evict",})-_PASSTHROUGH_SETTING_KEYS = frozenset({- "api_key",- "base_url",- "timeout",- "timeout_secs",-})-_PASSTHROUGH_ROUTE_KEYS = (- _ROUTE_METADATA_KEYS- | frozenset({"defaults", "enable_stats"})- | _PASSTHROUGH_SETTING_KEYS-)-_NOOP_ROUTE_KEYS = _ROUTE_METADATA_KEYS_DETERMINISTIC_ROUTE_KEYS = (_ROUTE_METADATA_KEYS| _TARGET_DEFAULT_ROUTE_KEYS@@ -290,8 +278,6 @@ _CLASSIFIER_DEFAULT_KEYS = frozenset({_ROUTE_KEYS_BY_TYPE: Mapping[str, frozenset[str]] = {"model": _MODEL_ROUTE_KEYS,"random_routing": _RANDOM_ROUTING_ROUTE_KEYS,- "noop": _NOOP_ROUTE_KEYS,- "passthrough": _PASSTHROUGH_ROUTE_KEYS,"deterministic": _DETERMINISTIC_ROUTE_KEYS,"escalation_router": _ESCALATION_ROUTE_KEYS,"stage_router": _STAGE_ROUTER_ROUTE_KEYS,@@ -299,8 +285,6 @@ _ROUTE_KEYS_BY_TYPE: Mapping[str, frozenset[str]] = {_DEFAULT_KEYS_BY_TYPE: Mapping[str, frozenset[str]] = {"model": _TARGET_DEFAULT_KEYS,"random_routing": _TARGET_DEFAULT_KEYS,- "passthrough": _PASSTHROUGH_SETTING_KEYS,- "noop": frozenset(),"deterministic": _TARGET_DEFAULT_KEYS,"escalation_router": _TARGET_DEFAULT_KEYS,"stage_router": _TARGET_DEFAULT_KEYS,@@ -365,7 +349,7 @@ def routing_profile_model_ids(Returns each route's YAML key followed by its tier ``model`` fields(``strong`` / ``weak`` for stage_router/deterministic/random_routing,- ``target`` for ``model`` / ``passthrough``). Declaration order, later+ ``target`` for ``model``). Declaration order, laterduplicates dropped.Returns ``[]`` for a ``None`` or empty bundle.@@ -519,22 +503,6 @@ def build_table_from_bundle()continue- # `passthrough` routes hydrate their single tier's catalog into the- # table alongside the configured target model. (`model` routes are- # pure aliases — they register under the route key only, no catalog.)- if route_type == "passthrough":- _merge_discovered_single_tier(- table,- model_id,- route,- route_type=route_type,- target_defaults=route_defaults,- stats=stats,- pre_routing_request_processors=pre_routing_request_processors,- extra_response_processors=extra_response_processors,- )- continue-# `stage_router` and `deterministic` routes register the routing-policy chain# at the route key AND hydrate each tier's catalog (`strong` + `weak`)# into the table as direct passthroughs — same client-facing@@ -626,69 +594,6 @@ def _merge_random_routing_route(table.set_default_model(default_model)-def _merge_discovered_single_tier(- table: RouteTable,- model_id: str,- route: Mapping[str, object],- route_type: str,- target_defaults: Mapping[str, object],- stats: StatsAccumulator,- pre_routing_request_processors: Sequence[Any] = (),- extra_response_processors: Sequence[Any] = (),-) -> None:- """Expand a ``passthrough`` route with catalog discovery.-- Builds a single ``LlmTarget`` from the route's fields, then goes through- :func:`build_passthrough_table` with the shared- :func:`_default_discovery_fn` — the same path the launcher's per-tier- passthrough registration takes. Follows the unified ordering rule:-- - The YAML route key registered first (aliasing the tier's chain when- the key differs from ``tier.model``).- - The tier's configured model registered next.- - Every catalog entry from the tier's ``GET /v1/models`` after that.- """- tier = _passthrough_target(model_id, route, target_defaults, route_type)- sub_table = build_passthrough_table(- (tier,),- stats,- enable_stats=_optional_bool(route.get("enable_stats"), default=True),- discovery_fn=_default_discovery_fn,- pre_routing_request_processors=pre_routing_request_processors,- extra_response_processors=extra_response_processors,- )- was_empty = not table.registered_models()- items = list(sub_table.items())- alias_registered = False- if model_id != tier.model:- tier_chain, tier_metadata = next(- ((ch, md) for mid, ch, md in items if mid == tier.model),- (None, {}),- )- if tier_chain is not None:- # YAML key first as an alias to the tier's chain so- # `registered_models()[0]` is always the user-declared route key.- table.register(- model_id,- tier_chain,- metadata={**dict(tier_metadata), "display_name": model_id},- )- alias_registered = True- for sub_model, sub_chain, sub_metadata in items:- if sub_model == model_id:- if alias_registered:- continue- # When YAML key == tier.model this entry is the route key itself;- # let it register here so it lands at position 0 of the table.- table.register(sub_model, sub_chain, metadata=sub_metadata)- continue- table.register(sub_model, sub_chain, metadata=sub_metadata)- for warning in sub_table.model_listing_warnings():- table.add_model_listing_warning(warning)- if was_empty and model_id in table.registered_models():- table.set_default_model(model_id)--def _merge_multi_target_discovery(table: RouteTable,model_id: str,@@ -825,12 +730,10 @@ def _build_route_chain(pre_routing_request_processors: Sequence[Any] = (),extra_response_processors: Sequence[Any] = (),) -> ChainRuntime:- if route_type in ("model", "passthrough"):- # Both kinds resolve to a single-tier passthrough chain — same shape the- # launcher produces via build_passthrough_table's per-tier registration.- # The "passthrough" kind synthesizes a target whose model defaults to the- # route's table key when no explicit target/model is given.- target = _passthrough_target(model_id, route, target_defaults, route_type)+ if route_type == "model":+ # Resolves to a single-tier passthrough chain — same shape the launcher+ # produces via build_passthrough_table's per-tier registration.+ target = _passthrough_target(model_id, route, target_defaults)return build_tier_passthrough_switchyard(target,stats,@@ -839,19 +742,6 @@ def _build_route_chain(extra_response_processors=extra_response_processors,)- if route_type == "noop":- from switchyard.lib.profiles.noop import NoopProfileConfig-- return ProfileSwitchyard(- NoopProfileConfig()- .build()- .with_runtime_components(- stats_accumulator=stats,- pre_request_processors=pre_routing_request_processors,- response_processors=extra_response_processors,- )- )-if route_type == "deterministic":return _deterministic_switchyard(model_id,@@ -1245,20 +1135,15 @@ def _passthrough_target(model_id: str,route: Mapping[str, object],target_defaults: Mapping[str, object],- route_type: str,) -> LlmTarget:- """Resolve the LlmTarget for a ``model`` or ``passthrough`` route.+ """Resolve the LlmTarget for a ``model`` route.- ``model`` routes require an explicit ``target`` or ``model`` field. The- ``passthrough`` kind is permissive: if no target is given, the route's- table key becomes the model name and the rest of the target is- populated from defaults plus inline route fields.+ A ``model`` route requires an explicit ``target`` or ``model`` field; the+ target is built from that plus the route defaults and inline fields."""target_raw = route.get("target", route.get("model"))if target_raw is None:- if route_type == "model":- raise RouteBundleConfigError(f"route {model_id!r} requires target or model")- target_raw = model_id+ raise RouteBundleConfigError(f"route {model_id!r} requires target or model")return coerce_llm_target(_target_mapping(target_raw, target_defaults, default_id=model_id, where="target"),default_id=model_id,@@ -1368,7 +1253,7 @@ def _route_type(model_id: str, route: Mapping[str, object]) -> str:raw_type = route.get("type", route.get("kind"))if raw_type is None:if not route:- return "noop"+ raise RouteBundleConfigError(f"route {model_id!r}: missing 'type'")if "strong" in route and "weak" in route:return "random_routing"if "target" in route or "model" in route:@@ -1387,9 +1272,6 @@ def _route_type(model_id: str, route: Mapping[str, object]) -> str:"target": "model","random": "random_routing","random_routing": "random_routing",- "noop": "noop",- "no_op": "noop",- "passthrough": "passthrough","deterministic": "deterministic","llm_classifier": "deterministic","llm_classifier_routing": "deterministic",diff --git a/switchyard/cli/switchyard_cli.py b/switchyard/cli/switchyard_cli.pyindex b0fdaf781..b56856e88 100644--- a/switchyard/cli/switchyard_cli.py+++ b/switchyard/cli/switchyard_cli.py@@ -933,7 +933,7 @@ def _build_parser() -> argparse.ArgumentParser:" --model X single-model passthrough — every request ""is rewritten to model=X. Falls back to the saved configure default.\n"" --routing-profiles PATH serve a YAML bundle of routes (random, "- "stage_router, passthrough, …); the first declared route "+ "stage_router, …); the first declared route ""is the initial model.\n\n""With neither flag, the saved routing bundle from ""`switchyard configure` is used."@@ -1032,7 +1032,7 @@ def _build_parser() -> argparse.ArgumentParser:" --model X single-model passthrough — every request ""is rewritten to model=X. Falls back to the saved configure default.\n"" --routing-profiles PATH serve a YAML bundle of routes (random, "- "stage_router, passthrough, …); the first declared route "+ "stage_router, …); the first declared route ""is the initial model.\n\n""With neither flag, the saved routing bundle from ""`switchyard configure` is used."@@ -1127,7 +1127,7 @@ def _build_parser() -> argparse.ArgumentParser:" --model X single-model passthrough — every request ""is rewritten to model=X. Falls back to the saved configure default.\n"" --routing-profiles PATH serve a YAML bundle of routes (random, "- "stage_router, passthrough, …); the first declared route "+ "stage_router, …); the first declared route ""is the initial model.\n\n""With neither flag, the saved routing bundle from ""`switchyard configure` is used."diff --git a/switchyard/lib/profiles/__init__.py b/switchyard/lib/profiles/__init__.pyindex 1b06d983f..c4058a562 100644--- a/switchyard/lib/profiles/__init__.py+++ b/switchyard/lib/profiles/__init__.py@@ -21,7 +21,6 @@ from switchyard.lib.profiles.header_routing import (HeaderRoutingDecision,HeaderRoutingProfile,)-from switchyard.lib.profiles.noop import NoopProfile, NoopProfileConfigfrom switchyard.lib.profiles.passthrough import PassthroughProfileConfigfrom switchyard.lib.profiles.protocols import (ContextAwareProfile,@@ -60,8 +59,6 @@ __all__ = ["HeaderRoutingConfig","HeaderRoutingDecision","HeaderRoutingProfile",- "NoopProfile",- "NoopProfileConfig","PassthroughProfileConfig","ContextAwareProfile","Profile",diff --git a/switchyard/lib/profiles/noop.py b/switchyard/lib/profiles/noop.pydeleted file mode 100644index 16580589a..000000000--- a/switchyard/lib/profiles/noop.py+++ /dev/null@@ -1,251 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Profile-backed no-op runtime for proxy overhead benchmarking."""--import time-import uuid-from collections.abc import AsyncIterator, Sequence-from dataclasses import dataclass-from typing import Any, cast--from openai.types import CompletionUsage-from openai.types.chat import ChatCompletion, ChatCompletionChunk-from openai.types.chat.chat_completion import Choice-from openai.types.chat.chat_completion_chunk import Choice as ChunkChoice-from openai.types.chat.chat_completion_chunk import ChoiceDelta-from openai.types.chat.chat_completion_message import ChatCompletionMessage--from switchyard.lib.chat_response.openai_chat import ResponseStream-from switchyard.lib.profiles.chain import _context_from_input-from switchyard.lib.profiles.table import profile_config-from switchyard.lib.proxy_context import ProxyContext-from switchyard.lib.stats_accumulator import StatsAccumulator-from switchyard_rust.core import (- ChatRequest,- ChatRequestType,- ChatResponse,- SwitchyardProcessorError,-)-from switchyard_rust.profiles import ProfileInput-from switchyard_rust.translation import TranslationEngine--_NOOP_SUPPORTED_TYPES = [ChatRequestType.OPENAI_CHAT]-_NOOP_CONTENT = "pong"-_NOOP_MODEL = "noop"---def _make_completion(request_id: str, created: int) -> ChatCompletion:- """Build the fixed no-op non-streaming completion."""- return ChatCompletion(- id=f"chatcmpl-{request_id}",- object="chat.completion",- created=created,- model=_NOOP_MODEL,- choices=[- Choice(- index=0,- message=ChatCompletionMessage(role="assistant", content=_NOOP_CONTENT),- finish_reason="stop",- )- ],- usage=CompletionUsage(prompt_tokens=1, completion_tokens=1, total_tokens=2),- )---async def _noop_stream(- request_id: str,- created: int,-) -> AsyncIterator[ChatCompletionChunk]:- """Yield the fixed no-op streaming completion chunks."""- yield ChatCompletionChunk(- id=f"chatcmpl-{request_id}",- object="chat.completion.chunk",- created=created,- model=_NOOP_MODEL,- choices=[- ChunkChoice(- index=0,- delta=ChoiceDelta(role="assistant", content=_NOOP_CONTENT),- finish_reason=None,- )- ],- )- yield ChatCompletionChunk(- id=f"chatcmpl-{request_id}",- object="chat.completion.chunk",- created=created,- model=_NOOP_MODEL,- choices=[- ChunkChoice(- index=0,- delta=ChoiceDelta(),- finish_reason="stop",- )- ],- )---@profile_config("noop")-class NoopProfileConfig:- """Dataclass config for the no-op profile."""-- def build(self) -> "NoopProfile":- """Build a no-op runtime profile."""- return NoopProfile()---@dataclass(frozen=True, slots=True)-class NoopProcessedRequest:- """Request-side state carried from no-op ``process`` into ``rprocess``."""-- input: ProfileInput- ctx: ProxyContext- request: ChatRequest---class NoopProfile:- """Profile that immediately returns a fixed minimal response.-- No network call is made. The response is always ``"pong"`` for both- streaming and non-streaming requests. Non-OpenAI inbound requests are- translated to OpenAI Chat before the profile reads the streaming flag.- """-- def __init__(- self,- request_processors: tuple[Any, ...] = (),- response_processors: tuple[Any, ...] = (),- stats_accumulator: StatsAccumulator | None = None,- ) -> None:- """Create a no-op profile with a local translation helper."""- self._translation = TranslationEngine()- self._request_processors = request_processors- self._response_processors = response_processors- self._stats_accumulator = stats_accumulator-- def iter_components(self) -> list[object]:- """Return lifecycle components in startup order."""- return [- *self._request_processors,- self,- *self._response_processors,- ]-- def with_runtime_components(- self,- stats_accumulator: StatsAccumulator | None = None,- enable_stats: bool = True,- pre_request_processors: Sequence[Any] = (),- post_request_processors: Sequence[Any] = (),- response_processors: Sequence[Any] = (),- ) -> "NoopProfile":- """Return a no-op profile with route-table processors attached."""- from switchyard.lib.processors.stats_request_processor import (- StatsRequestProcessor,- )- from switchyard.lib.processors.stats_response_processor_accumulator import (- StatsResponseProcessor,- )-- request_chain: list[Any] = []- response_chain: list[Any] = list(self._response_processors)- if enable_stats:- stats = stats_accumulator or StatsAccumulator()- request_chain.append(StatsRequestProcessor())- response_chain.append(StatsResponseProcessor(stats))-- request_chain.extend(pre_request_processors)- request_chain.extend(self._request_processors)- request_chain.extend(post_request_processors)- response_chain.extend(response_processors)- return NoopProfile(- request_processors=tuple(request_chain),- response_processors=tuple(response_chain),- stats_accumulator=stats if enable_stats else None,- )-- async def process(self, input: ProfileInput) -> NoopProcessedRequest:- """Run request-side processors with a context derived from metadata."""- return await self.process_with_context(input, _context_from_input(input))-- async def process_with_context(- self,- input: ProfileInput,- ctx: ProxyContext,- ) -> NoopProcessedRequest:- """Run request-side processors against the caller-supplied context."""- current: Any = input.request- for processor in self._request_processors:- try:- current = await processor.process(ctx, current)- except Exception as error:- raise SwitchyardProcessorError(str(error)) from error- if not isinstance(current, ChatRequest):- actual = type(current).__name__- raise SwitchyardProcessorError(- f"Request processor returned {actual}, expected ChatRequest"- )- return NoopProcessedRequest(input=input, ctx=ctx, request=current)-- async def rprocess(- self,- processed: NoopProcessedRequest,- response: ChatResponse,- ) -> ChatResponse:- """Run response-side processors for the fixed no-op response."""- current: Any = response- for processor in self._response_processors:- try:- current = await processor.process(processed.ctx, current)- except Exception as error:- raise SwitchyardProcessorError(str(error)) from error- if not isinstance(current, ChatResponse):- actual = type(current).__name__- raise SwitchyardProcessorError(- f"Response processor returned {actual}, expected ChatResponse"- )- return cast(ChatResponse, current)-- async def run(self, input: ProfileInput) -> ChatResponse:- """Execute no-op response generation with a derived context."""- return await self.run_with_context(input, _context_from_input(input))-- async def run_with_context(- self,- input: ProfileInput,- ctx: ProxyContext,- ) -> ChatResponse:- """Execute no-op response generation with an existing context."""- processed = await self.process_with_context(input, ctx)- # Stamp ctx.selected_model so the stats response processor attributes- # the response tokens to "noop" instead of "<unknown>".- ctx.selected_model = _NOOP_MODEL- openai_request = self._translation.request_to_any_of(- processed.request,- _NOOP_SUPPORTED_TYPES,- )- body: dict[str, object] = dict(openai_request.body)- is_streaming = bool(body.get("stream", False))-- request_id = uuid.uuid4().hex[:16]- created = int(time.time())-- if is_streaming:- response = ChatResponse.openai_stream(- ResponseStream(_noop_stream(request_id=request_id, created=created))- )- else:- response = ChatResponse.openai_completion(- _make_completion(request_id=request_id, created=created)- )- # Count the request only after the response is built, so a translation- # failure does not leave a spurious success in /v1/routing/stats. Record- # success before rprocess records tokens, which is the order the stats- # response processor's record_usage_after_success_attribution expects.- if self._stats_accumulator is not None:- await self._stats_accumulator.record_success(_NOOP_MODEL)- return await self.rprocess(processed, response)---__all__ = ["NoopProcessedRequest", "NoopProfile", "NoopProfileConfig"]diff --git a/tests/_mock_openai_server.py b/tests/_mock_openai_server.pynew file mode 100644index 000000000..0ef05ce29--- /dev/null+++ b/tests/_mock_openai_server.py@@ -0,0 +1,137 @@+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.+# SPDX-License-Identifier: Apache-2.0++"""Local in-process mock OpenAI upstream shared by the markdown-docs fixtures.++The getting-started and README doc tests both redirect a passthrough profile at+a loopback server returning a fixed ``chat.completion`` so the guide snippets+exercise the real backend, openai SDK, and httpx code without touching the+network. This module holds the single copy both fixtures use: the mock server+and the ``redirect_passthrough_to_local_mock`` helper that points+``PassthroughProfileConfig.build`` at it.+"""++from __future__ import annotations++import dataclasses+import json+import threading+from collections.abc import Iterator+from contextlib import contextmanager+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer++import pytest++#: Fixed OpenAI Chat Completion the mock upstream returns for every request.+_CANNED_COMPLETION: dict[str, object] = {+ "id": "chatcmpl-hermetic",+ "object": "chat.completion",+ "created": 1700000000,+ "model": "hermetic-mock",+ "choices": [+ {+ "index": 0,+ "message": {"role": "assistant", "content": "4"},+ "finish_reason": "stop",+ }+ ],+ "usage": {"prompt_tokens": 5, "completion_tokens": 1, "total_tokens": 6},+}+++class _MockOpenAIServer:+ """In-process OpenAI-compatible upstream returning a fixed completion.++ Loopback-only ``ThreadingHTTPServer`` so the doc snippets exercise the real+ passthrough backend, openai SDK, and httpx code without touching the network.+ """++ def __init__(self) -> None:+ self._server: ThreadingHTTPServer | None = None+ self._thread: threading.Thread | None = None++ def __enter__(self) -> _MockOpenAIServer:+ class Handler(BaseHTTPRequestHandler):+ protocol_version = "HTTP/1.1"++ def do_POST(self) -> None:+ length = int(self.headers.get("content-length", "0"))+ self.rfile.read(length)+ content = json.dumps(_CANNED_COMPLETION).encode("utf-8")+ self.send_response(200)+ self.send_header("content-type", "application/json")+ self.send_header("content-length", str(len(content)))+ self.send_header("connection", "close")+ self.end_headers()+ self.wfile.write(content)++ def log_message(self, _format: str, *_args: object) -> None:+ return None++ self._server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)+ self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)+ self._thread.start()+ return self++ def __exit__(self, *_args: object) -> None:+ if self._server is not None:+ self._server.shutdown()+ self._server.server_close()+ if self._thread is not None:+ self._thread.join(timeout=2)++ @property+ def base_url(self) -> str:+ if self._server is None:+ raise RuntimeError("mock server is not running")+ host, port = self._server.server_address+ return f"http://{host}:{port}/v1"+++def markdown_docs_active(config: pytest.Config) -> bool:+ """Return whether the run enabled the ``--markdown-docs`` flag."""+ try:+ return bool(config.getoption("markdowndocs", default=False))+ except (KeyError, ValueError):+ return False+++@contextmanager+def redirect_passthrough_to_local_mock(*, stub_uvicorn: bool = False) -> Iterator[None]:+ """Point ``PassthroughProfileConfig.build`` at a local mock OpenAI upstream.++ Starts a loopback :class:`_MockOpenAIServer` and patches the passthrough+ profile's ``build`` so a guide snippet's ``switchyard.call`` runs the real+ backend, openai SDK, and httpx code fully offline, keeping any other fields+ the snippet set on its config. With ``stub_uvicorn=True`` it also replaces+ ``uvicorn.run`` with a no-op so a "host as HTTP server" snippet returns+ instead of blocking the test session forever.+ """+ from switchyard import PassthroughProfileConfig++ real_build = PassthroughProfileConfig.build+ monkeypatch = pytest.MonkeyPatch()+ with _MockOpenAIServer() as upstream:++ def _hermetic_build(_self: PassthroughProfileConfig) -> object:+ return real_build(+ dataclasses.replace(_self, api_key="test-key", base_url=upstream.base_url)+ )++ monkeypatch.setattr(PassthroughProfileConfig, "build", _hermetic_build)+ if stub_uvicorn:+ import uvicorn++ monkeypatch.setattr(uvicorn, "run", lambda *_args, **_kwargs: None)+ try:+ yield+ finally:+ monkeypatch.undo()+++__all__ = [+ "_CANNED_COMPLETION",+ "_MockOpenAIServer",+ "markdown_docs_active",+ "redirect_passthrough_to_local_mock",+]diff --git a/tests/getting_started/conftest.py b/tests/getting_started/conftest.pyindex 23547eed0..7a46aaedc 100644--- a/tests/getting_started/conftest.py+++ b/tests/getting_started/conftest.py@@ -3,7 +3,8 @@"""Markdown-docs fixtures for executing the guide's Python snippets safely.-Aliases passthrough profile builds to no-op profiles (no live backend) and+Points the guide's passthrough profile at a local in-process mock OpenAI+server (loopback, a fixed ``chat.completion``) instead of a live backend, andstubs ``uvicorn.run`` to a no-op — the "host as HTTP server" snippet wouldotherwise block the test session forever. Both are gated on the``--markdown-docs`` flag so regular runs are untouched.@@ -12,66 +13,29 @@ otherwise block the test session forever. Both are gated on thefrom __future__ import annotationsfrom collections.abc import Iterator-from typing import Anyimport pytest+from tests._mock_openai_server import (+ _MockOpenAIServer,+ markdown_docs_active,+ redirect_passthrough_to_local_mock,+)-class _NoopProfileFixture:- """No-op profile that preserves optional route-table decoration hooks."""- def __init__(self) -> None:- """Build the real no-op runtime used by guide snippet execution."""- from switchyard import NoopProfileConfig-- self._inner = NoopProfileConfig().build()-- def with_runtime_components(self, **_kwargs: Any) -> _NoopProfileFixture:- """Accept route-table runtime components while staying hermetic."""- return self-- async def process(self, input: Any) -> Any:- """Delegate request-side profile work to the no-op runtime."""- return await self._inner.process(input)-- async def rprocess(self, processed: Any, response: Any) -> Any:- """Delegate response-side profile work to the no-op runtime."""- return await self._inner.rprocess(processed, response)-- async def run(self, input: Any) -> Any:- """Run the no-op runtime instead of making a real backend call."""- return await self._inner.run(input)---def _markdown_docs_active(config: pytest.Config) -> bool:- try:- return bool(config.getoption("markdowndocs", default=False))- except (KeyError, ValueError):- return False+def local_mock_openai_server() -> Iterator[_MockOpenAIServer]:+ """A running local mock OpenAI upstream for hermetic serve tests."""+ with _MockOpenAIServer() as server:+ yield server@pytest.fixture(autouse=True, scope="session")-def _markdown_docs_passthrough_to_noop(+def _markdown_docs_hermetic_upstream(request: pytest.FixtureRequest,) -> Iterator[None]:- if not _markdown_docs_active(request.config):+ if not markdown_docs_active(request.config):yieldreturn-- import uvicorn-- from switchyard import PassthroughProfileConfig-- monkeypatch = pytest.MonkeyPatch()- monkeypatch.setattr(- PassthroughProfileConfig,- "build",- lambda _self: _NoopProfileFixture(),- )- # The "host as HTTP server" snippet ends in a blocking uvicorn.run(); stub it- # so the snippet still exercises build_switchyard_app() without serving.- monkeypatch.setattr(uvicorn, "run", lambda *_args, **_kwargs: None)- try:+ with redirect_passthrough_to_local_mock(stub_uvicorn=True):yield- finally:- monkeypatch.undo()diff --git a/tests/getting_started/test_getting_started.py b/tests/getting_started/test_getting_started.pyindex 0c6b1f0b4..2d5608463 100644--- a/tests/getting_started/test_getting_started.py+++ b/tests/getting_started/test_getting_started.py@@ -12,6 +12,7 @@ import textwrapfrom collections.abc import Iteratorfrom contextlib import contextmanagerfrom pathlib import Path+from typing import TYPE_CHECKINGimport httpximport pytest@@ -25,6 +26,9 @@ from switchyard.cli.launchers.launcher_runtime import (from switchyard.cli.route_bundle import RouteBundleConfigError, build_route_bundle_tablefrom switchyard.cli.switchyard_cli import _build_parser+if TYPE_CHECKING:+ from tests._mock_openai_server import _MockOpenAIServer+REPO_ROOT = Path(__file__).resolve().parents[2]GUIDE_PATH = REPO_ROOT / "docs" / "getting_started.md"@@ -158,28 +162,31 @@ def test_all_yaml_blocks_in_guide_validate_as_route_bundles(@pytest.fixture-def noop_routes_yaml(tmp_path: Path) -> Path:+def model_routes_yaml(tmp_path: Path, local_mock_openai_server: _MockOpenAIServer) -> Path:# Same shape as the guide's Step 3 YAML (defaults + a single named route),- # but `type: noop` so the lifecycle test runs without an upstream.+ # but a `type: model` route pointed at a local in-process mock OpenAI+ # server so the lifecycle test serves a real chain fully offline.+ base_url = local_mock_openai_server.base_urlpath = tmp_path / "routes.yaml"path.write_text(- textwrap.dedent("""\+ textwrap.dedent(f"""\defaults:api_key: dummy- base_url: https://upstream.invalid/v1+ base_url: {base_url}format: openairoutes:gpt-4o:- type: noop+ type: model+ model: gpt-4o"""))return path-def test_step3_and_step4_serve_lifecycle_with_noop(noop_routes_yaml: Path) -> None:+def test_step3_and_step4_serve_lifecycle_with_local_mock(model_routes_yaml: Path) -> None:port = find_free_port()- with _serve_in_background(noop_routes_yaml, port):+ with _serve_in_background(model_routes_yaml, port):health_status, health_body = _http_get(f"http://127.0.0.1:{port}/health")assert health_status == 200, f"GET /health → {health_status}: {health_body!r}"diff --git a/tests/readme/conftest.py b/tests/readme/conftest.pyindex 3a09e3b2e..f7a9763cb 100644--- a/tests/readme/conftest.py+++ b/tests/readme/conftest.py@@ -1,72 +1,34 @@# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.# SPDX-License-Identifier: Apache-2.0-"""Markdown-docs fixture: alias passthrough profile builds to no-op profiles.+"""Markdown-docs fixture: run the README snippet against a local mock upstream.Mirrors ``tests/getting_started/conftest.py``: the README's "Use as a Pythonlibrary" snippet builds a passthrough profile and calls ``switchyard.call``,-which would otherwise hit a real backend. Gated on the ``--markdown-docs`` flag+which would otherwise hit a real backend. The fixture points that passthrough+profile at a local in-process mock OpenAI server (loopback, a fixed+``chat.completion``) so it runs offline. Gated on the ``--markdown-docs`` flagso regular runs are untouched."""from __future__ import annotationsfrom collections.abc import Iterator-from typing import Anyimport pytest--class _NoopProfileFixture:- """No-op profile that preserves optional route-table decoration hooks."""-- def __init__(self) -> None:- """Build the real no-op runtime used by README snippet execution."""- from switchyard import NoopProfileConfig-- self._inner = NoopProfileConfig().build()-- def with_runtime_components(self, **_kwargs: Any) -> _NoopProfileFixture:- """Accept route-table runtime components while staying hermetic."""- return self-- async def process(self, input: Any) -> Any:- """Delegate request-side profile work to the no-op runtime."""- return await self._inner.process(input)-- async def rprocess(self, processed: Any, response: Any) -> Any:- """Delegate response-side profile work to the no-op runtime."""- return await self._inner.rprocess(processed, response)-- async def run(self, input: Any) -> Any:- """Run the no-op runtime instead of making a real backend call."""- return await self._inner.run(input)---def _markdown_docs_active(config: pytest.Config) -> bool:- try:- return bool(config.getoption("markdowndocs", default=False))- except (KeyError, ValueError):- return False+from tests._mock_openai_server import (+ markdown_docs_active,+ redirect_passthrough_to_local_mock,+)@pytest.fixture(autouse=True, scope="session")-def _markdown_docs_passthrough_to_noop(+def _markdown_docs_hermetic_upstream(request: pytest.FixtureRequest,) -> Iterator[None]:- if not _markdown_docs_active(request.config):+ if not markdown_docs_active(request.config):yieldreturn-- from switchyard import PassthroughProfileConfig-- monkeypatch = pytest.MonkeyPatch()- monkeypatch.setattr(- PassthroughProfileConfig,- "build",- lambda _self: _NoopProfileFixture(),- )- try:+ with redirect_passthrough_to_local_mock():yield- finally:- monkeypatch.undo()diff --git a/tests/readme/test_readme.py b/tests/readme/test_readme.pyindex b1686e62e..788312b8a 100644--- a/tests/readme/test_readme.py+++ b/tests/readme/test_readme.py@@ -6,7 +6,7 @@Companion to ``tests/getting_started/``. Three guards:* the "Use as a Python library" snippet executes (via ``--markdown-docs`` +- the passthrough→noop fixture in ``conftest.py``);+ the local mock-upstream fixture in ``conftest.py``);* README and routing-guide examples validate against the route-bundle schema;* every CLI subcommand / flag the README names still exists."""@@ -50,8 +50,8 @@ def _code_blocks(text: str, lang: str) -> list[str]:def test_python_snippet_tripwire(readme_text: str) -> None:- # Guards the shape the conftest's passthrough-profile→noop fixture depends on, plus- # the dict-access fix (call() returns a dict, not an object with `.body`).+ # Guards the shape the conftest's passthrough-profile→local-mock fixture depends on,+ # plus the dict-access fix (call() returns a dict, not an object with `.body`).assert ("from switchyard import ChatRequest, PassthroughProfileConfig, ProfileSwitchyard"in readme_text@@ -106,8 +106,9 @@ def test_route_block_validation_rejects_invalid_bundle_defaults() -> None:defaults:unsupported: trueroutes:- noop:- type: noop+ gpt-4o:+ type: model+ model: gpt-4o```"""with pytest.raises(AssertionError, match="unknown key.*defaults: unsupported"):diff --git a/tests/test_launch_claude.py b/tests/test_launch_claude.pyindex 929622505..6bee53ba1 100644--- a/tests/test_launch_claude.py+++ b/tests/test_launch_claude.py@@ -1133,10 +1133,10 @@ class TestResolveInitialFromProfiles:def test_empty_bundle_raises(self, tmp_path):from switchyard.cli.launch_command import _resolve_initial_from_profilesyaml_path = tmp_path / "empty.yaml"- yaml_path.write_text("routes:\n noop:\n type: noop\n")+ yaml_path.write_text("routes:\n direct:\n type: model\n target: some/model\n")assert (_resolve_initial_from_profiles(target="codex", routing_profiles=str(yaml_path))- == "noop"+ == "direct")def test_model_and_profiles_mutually_exclusive(self):diff --git a/tests/test_launch_openclaw_deterministic.py b/tests/test_launch_openclaw_deterministic.pyindex 8484b552a..215208a70 100644--- a/tests/test_launch_openclaw_deterministic.py+++ b/tests/test_launch_openclaw_deterministic.py@@ -68,7 +68,8 @@ class TestMutualExclusion:" format: openai\n""routes:\n"" bench:\n"- " type: noop\n"+ " type: model\n"+ " target: some/model\n")parser = _build_parser()args = parser.parse_args([diff --git a/tests/test_noop_llm_backend.py b/tests/test_noop_llm_backend.pydeleted file mode 100644index 0a5c4a362..000000000--- a/tests/test_noop_llm_backend.py+++ /dev/null@@ -1,128 +0,0 @@-# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.-# SPDX-License-Identifier: Apache-2.0--"""Unit tests for the no-op profile."""--from switchyard.lib.profiles import NoopProfile, NoopProfileConfig, ProfileSwitchyard-from switchyard.lib.stats_accumulator import StatsAccumulator-from switchyard_rust.core import ChatRequest, ChatResponseType, response_type_matches-from switchyard_rust.profiles import ProfileInput---def _openai_request(stream: bool = False) -> ChatRequest:- return ChatRequest.openai_chat(- {"model": "noop", "messages": [{"role": "user", "content": "ping"}], "stream": stream}- )---def _anthropic_request() -> ChatRequest:- return ChatRequest.anthropic(- {"model": "claude-3", "messages": [{"role": "user", "content": "ping"}], "max_tokens": 10}- )---class TestNoOpProfileNonStreaming:- async def test_returns_completion_response(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=False)))- assert response_type_matches(resp, ChatResponseType.OPENAI_COMPLETION)-- async def test_completion_has_pong_content(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=False)))- assert response_type_matches(resp, ChatResponseType.OPENAI_COMPLETION)- assert resp.body["choices"][0]["message"]["content"] == "pong"-- async def test_completion_is_valid_chat_completion(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=False)))- assert response_type_matches(resp, ChatResponseType.OPENAI_COMPLETION)- assert resp.body["object"] == "chat.completion"- assert resp.body["choices"][0]["finish_reason"] == "stop"-- async def test_accepts_anthropic_request(self) -> None:- """Translates non-OpenAI request formats before generating the response."""- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_anthropic_request()))- assert response_type_matches(resp, ChatResponseType.OPENAI_COMPLETION)- assert resp.body["choices"][0]["message"]["content"] == "pong"---class TestNoOpProfileStreaming:- async def test_returns_streaming_response(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=True)))- assert response_type_matches(resp, ChatResponseType.OPENAI_STREAM)-- async def test_stream_yields_chunks(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=True)))- chunks = [chunk async for chunk in resp.stream]- assert len(chunks) >= 1-- async def test_stream_contains_pong(self) -> None:- profile = NoopProfileConfig().build()- resp = await profile.run(ProfileInput(_openai_request(stream=True)))- contents: list[str] = []- async for chunk in resp.stream:- for choice in chunk.choices:- if choice.delta.content:- contents.append(choice.delta.content)- assert "".join(contents) == "pong"---class TestNoOpRecipe:- def test_noop_recipe_returns_profile_backed_switchyard_adapter(self) -> None:- sy = ProfileSwitchyard(NoopProfileConfig().build())- assert isinstance(sy, ProfileSwitchyard)-- async def test_noop_recipe_end_to_end(self) -> None:- sy = ProfileSwitchyard(NoopProfileConfig().build())- # ``sy.call()`` preserves the serving contract while no-op construction- # now goes through the Profile abstraction instead of a backend pipeline.- resp = await sy.call(_openai_request(stream=False))- assert resp["choices"][0]["message"]["content"] == "pong"---class TestNoOpProfile:- def test_config_builds_noop_profile(self) -> None:- profile = NoopProfileConfig().build()- assert isinstance(profile, NoopProfile)-- async def test_profile_run_returns_completion_response(self) -> None:- profile = NoopProfileConfig().build()-- resp = await profile.run(ProfileInput(_openai_request(stream=False)))-- assert response_type_matches(resp, ChatResponseType.OPENAI_COMPLETION)- assert resp.body["choices"][0]["message"]["content"] == "pong"-- async def test_profile_process_and_rprocess_are_explicit_hooks(self) -> None:- profile = NoopProfileConfig().build()- profile_input = ProfileInput(_openai_request(stream=False))- response = await profile.run(profile_input)-- processed = await profile.process(profile_input)- processed_response = await profile.rprocess(processed, response)-- assert processed.request.model == "noop"- assert processed_response is response-- async def test_noop_call_reports_routing_stats(self) -> None:- """The no-op profile self-reports its call and model to the stats accumulator."""- stats = StatsAccumulator()- profile = NoopProfileConfig().build().with_runtime_components(- stats_accumulator=stats- )-- await ProfileSwitchyard(profile).call(_openai_request(stream=False))-- snap = stats.snapshot_sync()- assert snap["total_requests"] == 1- assert "noop" in snap["models"]- assert snap["models"]["noop"]["calls"] == 1- assert "<unknown>" not in snap["models"]- # Response tokens land on "noop", not "<unknown>".- assert snap["models"]["noop"]["prompt_tokens"] == 1- assert snap["models"]["noop"]["completion_tokens"] == 1- assert snap["models"]["noop"]["total_tokens"] == 2diff --git a/tests/test_resolve_classifier_prompts.py b/tests/test_resolve_classifier_prompts.pyindex f5134a15a..f65b72884 100644--- a/tests/test_resolve_classifier_prompts.py+++ b/tests/test_resolve_classifier_prompts.py@@ -107,7 +107,7 @@ def test_non_deterministic_routes_are_skipped(tmp_path: Path) -> None:module = _load_resolver_module()bundle = {"routes": {- "r/pass": {"type": "passthrough"},+ "r/pass": {"type": "model", "target": "some/model"},"r/rand": {"type": "random_routing"},},}diff --git a/tests/test_route_bundle.py b/tests/test_route_bundle.pyindex 2f7365544..3eef241ee 100644--- a/tests/test_route_bundle.py+++ b/tests/test_route_bundle.py@@ -140,7 +140,6 @@ def test_route_bundle_rejects_missing_environment_variable() -> None:},"strong_probablity",),- ({"type": "passthrough", "model": "gpt-4o"}, "model"),({"type": "model", "target": {"modle": "gpt-4o"}}, "modle"),],)@@ -152,11 +151,24 @@ def test_route_bundle_rejects_unknown_route_keys(build_route_bundle_table({"routes": {"bad": route}})-def test_empty_route_mapping_registers_noop() -> None:- table = build_route_bundle_table({"routes": {"noop": {}}})[email protected]("route_type", ["passthrough", "noop"])+def test_removed_route_types_are_rejected(route_type: str) -> None:+ """``type: passthrough`` and ``type: noop`` are no longer valid route types."""+ with pytest.raises(RouteBundleConfigError, match="unsupported route type"):+ build_route_bundle_table({"routes": {"r": {"type": route_type}}})- assert table.registered_models() == ["noop"]- assert table.registered_model_entries()[0]["switchyard"]["profile"] == "noop"++def test_empty_route_mapping_is_rejected() -> None:+ """An empty ``{}`` route no longer defaults to a noop; it is rejected."""+ with pytest.raises(RouteBundleConfigError, match="missing 'type'"):+ build_route_bundle_table({"routes": {"r": {}}})+++def test_model_route_requires_target() -> None:+ """``type: model`` is the only single-upstream route, so it fails closed+ when no ``target``/``model`` is given rather than inventing a default."""+ with pytest.raises(RouteBundleConfigError, match="requires target or model"):+ build_route_bundle_table({"routes": {"m": {"type": "model"}}})def test_random_routing_hydrates_tier_and_catalog_models(@@ -241,86 +253,6 @@ def test_model_route_aliases_under_route_key(assert table.default_model() == "configured-route"-def test_passthrough_route_hydrates_catalog(- monkeypatch: pytest.MonkeyPatch,-) -> None:- """A ``passthrough`` route hydrates the catalog under the route id.-- The route's YAML key becomes the tier's configured model name (passthrough- routes don't take an explicit target); catalog entries register alongside.- """- monkeypatch.setattr(- "switchyard.cli.route_bundle.fetch_model_ids",- lambda base_url, api_key: ["catalog/x", "catalog/y"],- )-- table = build_route_bundle_table({- "routes": {- "openai-passthrough": {- "type": "passthrough",- "api_key": "k",- "base_url": "https://example/v1",- },- },- })-- assert table.registered_models() == [- "openai-passthrough",- "catalog/x",- "catalog/y",- ]- assert table.default_model() == "openai-passthrough"---def test_route_bundle_keeps_first_passthrough_route_as_default() -> None:- """Later discovered-route merges must not override the advertised default."""- table = build_route_bundle_table({- "routes": {- "first-route": {- "type": "passthrough",- "api_key": "k-first",- "base_url": "https://first.example/v1",- },- "second-route": {- "type": "passthrough",- "api_key": "k-second",- "base_url": "https://second.example/v1",- },- },- })-- assert table.registered_models() == ["first-route", "second-route"]- assert table.default_model() == "first-route"---def test_passthrough_route_preserves_warning_when_catalog_fetch_fails(- monkeypatch: pytest.MonkeyPatch,-) -> None:- def fail_catalog(_base_url: str, _api_key: str) -> list[str]:- raise RuntimeError("catalog timed out")-- monkeypatch.setattr(- "switchyard.cli.route_bundle.fetch_model_ids",- fail_catalog,- )-- table = build_route_bundle_table({- "routes": {- "configured-route": {- "type": "passthrough",- "api_key": "k",- "base_url": "https://primary.example/v1",- },- },- })-- assert table.registered_models() == ["configured-route"]- assert table.default_model() == "configured-route"- assert table.model_listing_warnings() == [- "Model discovery failed for https://primary.example/v1: catalog timed out"- ]--def test_random_routing_with_empty_catalog_registers_only_tier_passthroughs() -> None:"""When discovery yields an empty catalog, only tier passthroughs register.@@ -362,12 +294,12 @@ def test_route_bundle_threads_extra_processors_through_routes() -> None:response_processor = _NoopResponseProcessor()table = build_route_bundle_table(- {"routes": {"noop": {"type": "noop"}}},+ {"routes": {"direct": {"type": "model", "target": "some/model"}}},pre_routing_request_processors=[request_processor],extra_response_processors=[response_processor],)- components = table.lookup_switchyard("noop").iter_components()+ components = table.lookup_switchyard("direct").iter_components()assert request_processor in componentsassert response_processor in components@@ -379,7 +311,7 @@ def test_serve_subcommand_hands_table_to_server(import switchyard.cli.switchyard_cli as cliyaml_path = tmp_path / "routes.yaml"- yaml_path.write_text("routes:\n noop:\n type: noop\n")+ yaml_path.write_text("routes:\n direct:\n type: model\n target: some/model\n")captured: dict[str, Any] = {}def _fake_serve(@@ -404,7 +336,7 @@ def test_serve_subcommand_hands_table_to_server(args.func(args)assert isinstance(captured["switchyard"], RouteTable)- assert captured["switchyard"].registered_models() == ["noop"]+ assert captured["switchyard"].registered_models() == ["direct"]assert captured["args"].port == 4555assert captured["inbound_default"] == "both"@@ -500,7 +432,7 @@ def test_main_accepts_routing_profiles_flag(capsys: pytest.CaptureFixture[str],) -> None:yaml_path = tmp_path / "routes.yaml"- yaml_path.write_text("routes:\n noop:\n type: noop\n")+ yaml_path.write_text("routes:\n direct:\n type: model\n target: some/model\n")monkeypatch.setattr(sys, "argv", ["switchyard", "--routing-profiles", str(yaml_path), "serve"]@@ -529,7 +461,9 @@ def test_serve_accepts_saved_route_bundle(from switchyard.cli.config.user_config import UserConfig, save_user_configmonkeypatch.setenv("SWITCHYARD_CONFIG_DIR", str(tmp_path))- save_user_config(UserConfig(routing_profiles={"routes": {"noop": {"type": "noop"}}}))+ save_user_config(UserConfig(routing_profiles={"routes": {+ "direct": {"type": "model", "target": "some/model"},+ }}))def _fake_serve(args: argparse.Namespace,@@ -560,8 +494,9 @@ def test_serve_subcommand_enables_intake_from_cli_args(yaml_path = tmp_path / "routes.yaml"yaml_path.write_text("routes:\n"- " noop:\n"- " type: noop\n"+ " direct:\n"+ " type: model\n"+ " target: some/model\n")captured: dict[str, Any] = {}@@ -589,7 +524,7 @@ def test_serve_subcommand_enables_intake_from_cli_args(])args.func(args)- components = captured["switchyard"].lookup_switchyard("noop").iter_components()+ components = captured["switchyard"].lookup_switchyard("direct").iter_components()assert any(isinstance(component, IntakeRequestProcessor) for component in components)assert any(isinstance(component, IntakeResponseProcessor) for component in components)diff --git a/tests/test_routing_banner.py b/tests/test_routing_banner.pyindex 390db9331..0a6d96d35 100644--- a/tests/test_routing_banner.py+++ b/tests/test_routing_banner.py@@ -35,11 +35,11 @@ _STAGE_ROUTER_YAML = textwrap.dedent("""\model: clf-model/v1""")-_PASSTHROUGH_YAML = textwrap.dedent("""\+_MODEL_ROUTE_YAML = textwrap.dedent("""\routes:my_route:- type: passthrough- model: some/model+ type: model+ target: some/model""")@@ -55,10 +55,10 @@ class TestStrategyHelpers:result = routing_profiles_strategy_summary(str(p), "my_route")assert result == "stage_router: strong=strong-model/v1, weak=weak-model/v1, llm-classifier=clf-model/v1, confidence_threshold=0.7"- def test_routing_profiles_passthrough_type(self, tmp_path):- """routing_profiles_strategy_summary describes a passthrough-type route."""+ def test_routing_profiles_model_type(self, tmp_path):+ """routing_profiles_strategy_summary renders a model-type route as passthrough."""p = tmp_path / "profiles.yaml"- p.write_text(_PASSTHROUGH_YAML)+ p.write_text(_MODEL_ROUTE_YAML)result = routing_profiles_strategy_summary(str(p), "my_route")assert result == "passthrough → some/model"diff --git a/tests/test_run_manifest.py b/tests/test_run_manifest.pyindex a94ec9dce..e920ac26d 100644--- a/tests/test_run_manifest.py+++ b/tests/test_run_manifest.py@@ -122,7 +122,9 @@ def test_cli_write_records_routing_profile_digest(tmp_path: Path) -> None:out = tmp_path / "run_manifest.json"run_dir = tmp_path / "run"profile = tmp_path / "routes.yaml"- profile.write_text("routes:\n tb-lite-random-routing:\n type: noop\n")+ profile.write_text(+ "routes:\n tb-lite-random-routing:\n type: model\n target: some/model\n"+ )dataset = tmp_path / "dataset"dataset.mkdir()diff --git a/tests/test_user_config.py b/tests/test_user_config.pyindex 4c19cf835..0357312d1 100644--- a/tests/test_user_config.py+++ b/tests/test_user_config.py@@ -570,7 +570,7 @@ def test_redacted_snapshot_surfaces_only_route_ids(tmp_path):save_user_config(UserConfig(routing_profiles={"routes": {"alpha/model": {"type": "model"},- "beta/model": {"type": "passthrough"},+ "beta/model": {"type": "model", "target": "other/model"},}}),config_dir=tmp_path,)