smart-router-ns 0.1.0__tar.gz

smart_router_ns-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nishant Shinde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smart_router_ns-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: smart-router-ns
+Version: 0.1.0
+Summary: Plug-and-play LLM router for agents, MCP tools, and models
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm
+Requires-Dist: instructor[litellm]
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: python-dotenv
+Dynamic: license-file
+
+# Smart Router
+
+Plug-and-play LLM router for agents, MCP tools, and models. The Python import
+package is named `src`.
+
+## Install
+
+```bash
+pip install smart-router-ns
+```
+
+Set the API key for the provider used by the model in your routes file. For the
+Gemini model below:
+
+```bash
+export GEMINI_API_KEY="your-gemini-api-key"
+```
+
+Alternatively, create a `.env` file in your working directory with that setting.
+Do not commit or share your `.env` file.
+
+## Configure routes
+
+Create a `routes.yaml` file in your working directory. This minimal example
+shows the supported structure and route types:
+
+```yaml
+version: 1
+default_route: general_chat
+confidence_threshold: 0.70
+max_history_messages: 10
+model: "gemini/gemini-3.5-flash-lite"
+temperature: 0.0
+
+routes:
+	- id: general_chat
+		type: model
+		description: Handles general questions and conversation.
+		examples:
+			- "Explain vector databases simply."
+
+	- id: web_research
+		type: mcp
+		description: Finds current information on the public web.
+		examples:
+			- "Find the latest Azure AI Search pricing."
+
+	- id: clarify
+		type: fallback
+		description: Asks for clarification when a request is ambiguous.
+```
+
+Route `type` must be `agent`, `mcp`, `model`, or `fallback`. Use a LiteLLM
+model identifier and configure the corresponding provider API key in your
+environment.
+
+## Use
+
+```python
+from src import SmartRouter
+
+router = SmartRouter(routes_file="routes.yaml")
+decision = router.route("What is the latest Azure AI Search pricing?")
+print(decision.model_dump_json(indent=2))
+```
+
+The routes file path is relative to the current working directory. Decisions
+are appended to `router_logs.jsonl` in that directory.
+
+## Build and publish
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token in your PyPI account before uploading. When prompted by
+Twine, use `__token__` as the username and paste the token as the password.
+Never put the token in this README, source code, or a committed file. PyPI does
+not allow reusing a published version number; increment `version` in
+`pyproject.toml` for every new release.

smart_router_ns-0.1.0/README.md

@@ -0,0 +1,83 @@
+# Smart Router
+
+Plug-and-play LLM router for agents, MCP tools, and models. The Python import
+package is named `src`.
+
+## Install
+
+```bash
+pip install smart-router-ns
+```
+
+Set the API key for the provider used by the model in your routes file. For the
+Gemini model below:
+
+```bash
+export GEMINI_API_KEY="your-gemini-api-key"
+```
+
+Alternatively, create a `.env` file in your working directory with that setting.
+Do not commit or share your `.env` file.
+
+## Configure routes
+
+Create a `routes.yaml` file in your working directory. This minimal example
+shows the supported structure and route types:
+
+```yaml
+version: 1
+default_route: general_chat
+confidence_threshold: 0.70
+max_history_messages: 10
+model: "gemini/gemini-3.5-flash-lite"
+temperature: 0.0
+
+routes:
+	- id: general_chat
+		type: model
+		description: Handles general questions and conversation.
+		examples:
+			- "Explain vector databases simply."
+
+	- id: web_research
+		type: mcp
+		description: Finds current information on the public web.
+		examples:
+			- "Find the latest Azure AI Search pricing."
+
+	- id: clarify
+		type: fallback
+		description: Asks for clarification when a request is ambiguous.
+```
+
+Route `type` must be `agent`, `mcp`, `model`, or `fallback`. Use a LiteLLM
+model identifier and configure the corresponding provider API key in your
+environment.
+
+## Use
+
+```python
+from src import SmartRouter
+
+router = SmartRouter(routes_file="routes.yaml")
+decision = router.route("What is the latest Azure AI Search pricing?")
+print(decision.model_dump_json(indent=2))
+```
+
+The routes file path is relative to the current working directory. Decisions
+are appended to `router_logs.jsonl` in that directory.
+
+## Build and publish
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token in your PyPI account before uploading. When prompted by
+Twine, use `__token__` as the username and paste the token as the password.
+Never put the token in this README, source code, or a committed file. PyPI does
+not allow reusing a published version number; increment `version` in
+`pyproject.toml` for every new release.

smart_router_ns-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "smart-router-ns"
+version = "0.1.0"
+description = "Plug-and-play LLM router for agents, MCP tools, and models"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+dependencies = [
+  "litellm",
+  "instructor[litellm]",
+  "pydantic",
+  "pyyaml",
+  "python-dotenv"
+]
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["src*"]

smart_router_ns-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smart_router_ns-0.1.0/smart_router_ns.egg-info/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: smart-router-ns
+Version: 0.1.0
+Summary: Plug-and-play LLM router for agents, MCP tools, and models
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: litellm
+Requires-Dist: instructor[litellm]
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Requires-Dist: python-dotenv
+Dynamic: license-file
+
+# Smart Router
+
+Plug-and-play LLM router for agents, MCP tools, and models. The Python import
+package is named `src`.
+
+## Install
+
+```bash
+pip install smart-router-ns
+```
+
+Set the API key for the provider used by the model in your routes file. For the
+Gemini model below:
+
+```bash
+export GEMINI_API_KEY="your-gemini-api-key"
+```
+
+Alternatively, create a `.env` file in your working directory with that setting.
+Do not commit or share your `.env` file.
+
+## Configure routes
+
+Create a `routes.yaml` file in your working directory. This minimal example
+shows the supported structure and route types:
+
+```yaml
+version: 1
+default_route: general_chat
+confidence_threshold: 0.70
+max_history_messages: 10
+model: "gemini/gemini-3.5-flash-lite"
+temperature: 0.0
+
+routes:
+	- id: general_chat
+		type: model
+		description: Handles general questions and conversation.
+		examples:
+			- "Explain vector databases simply."
+
+	- id: web_research
+		type: mcp
+		description: Finds current information on the public web.
+		examples:
+			- "Find the latest Azure AI Search pricing."
+
+	- id: clarify
+		type: fallback
+		description: Asks for clarification when a request is ambiguous.
+```
+
+Route `type` must be `agent`, `mcp`, `model`, or `fallback`. Use a LiteLLM
+model identifier and configure the corresponding provider API key in your
+environment.
+
+## Use
+
+```python
+from src import SmartRouter
+
+router = SmartRouter(routes_file="routes.yaml")
+decision = router.route("What is the latest Azure AI Search pricing?")
+print(decision.model_dump_json(indent=2))
+```
+
+The routes file path is relative to the current working directory. Decisions
+are appended to `router_logs.jsonl` in that directory.
+
+## Build and publish
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+python -m twine upload dist/*
+```
+
+Create a PyPI API token in your PyPI account before uploading. When prompted by
+Twine, use `__token__` as the username and paste the token as the password.
+Never put the token in this README, source code, or a committed file. PyPI does
+not allow reusing a published version number; increment `version` in
+`pyproject.toml` for every new release.

smart_router_ns-0.1.0/smart_router_ns.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+smart_router_ns.egg-info/PKG-INFO
+smart_router_ns.egg-info/SOURCES.txt
+smart_router_ns.egg-info/dependency_links.txt
+smart_router_ns.egg-info/requires.txt
+smart_router_ns.egg-info/top_level.txt
+src/__init__.py
+src/config.py
+src/prompts.py
+src/router.py
+src/schemas.py
+src/telemetry.py
+tests/test_router.py

smart_router_ns-0.1.0/smart_router_ns.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smart_router_ns-0.1.0/smart_router_ns.egg-info/requires.txt

@@ -0,0 +1,5 @@
+litellm
+instructor[litellm]
+pydantic
+pyyaml
+python-dotenv

smart_router_ns-0.1.0/smart_router_ns.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

smart_router_ns-0.1.0/src/__init__.py

@@ -0,0 +1,4 @@
+from .router import SmartRouter
+from .schemas import RoutingDecision
+
+__all__ = ["SmartRouter", "RoutingDecision"]

smart_router_ns-0.1.0/src/config.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+import yaml
+
+from .schemas import RouterConfig
+
+
+def load_router_config(path:str | Path) -> RouterConfig:
+    path = Path(path)
+
+    if not path.exists():
+        raise FileNotFoundError(f"Routes file not found: {path}")
+
+    with path.open("r", encoding="utf-8") as f:
+        raw = yaml.safe_load(f)
+
+    config = RouterConfig(**raw)
+    validate_config(config)
+    return config
+
+
+def validate_config(config: RouterConfig) -> None:
+    route_ids = [route.id for route in config.routes]
+
+    if len(route_ids) != len(set(route_ids)):
+        raise ValueError("Duplicates route IDs found in routes.yaml")
+
+    enabled_route_ids = {route.id for route in config.routes if route.enabled}
+
+    if config.default_route not in enabled_route_ids:
+        raise ValueError(
+            f"default_route '{config.default_route}' is not an enabled route"
+        )

smart_router_ns-0.1.0/src/prompts.py

@@ -0,0 +1,34 @@
+from .schemas import RouterConfig
+
+def build_route_catalog(config: RouterConfig) -> str:
+    lines = []
+
+    for route in config.routes:
+        if not route.enabled:
+            continue
+
+        examples = "\n".join(f"  - {example}" for example in route.examples)
+        lines.append(
+            f"- id: {route.id}\n"
+            f" type: {route.type.value}\n"
+            f" description: {route.description.strip()}\n"
+            f" examples:\n{examples}"
+        )
+
+    return "\n".join(lines)
+
+SYSTEM_PROMPT = """You are a precise router for an AI chat system
+
+Your only job is to choose the best destination for the user's latest request.
+
+Rules:
+1. Use conversation history only to resolve references and follow-ups.
+2. Return a self-contained resolved_query for the selected destination.
+3. Select exactly one primary route.
+4. If the latest request contains multiple independent tasks, set multi_step=true and return ordered steps.
+5. Confidence must reflect genuine uncertainty. Use 1.0 only for an unambiguous request, 0.7–0.9 for a clear but paraphrased request, and below 0.7 when intent is unclear.
+6. If intent is unclear or confidence is below the configured threshold, select the clarify route when available and set fallback=true; otherwise use the default route.
+7. Never invent a route ID.
+8. Do not answer the user's question.
+9. Return only the required structured routing decision.
+"""

smart_router_ns-0.1.0/src/router.py

@@ -0,0 +1,129 @@
+import os
+import time
+from typing import Optional
+
+import instructor
+from dotenv import load_dotenv
+from litellm import completion
+
+from .config import load_router_config
+from .prompts import SYSTEM_PROMPT, build_route_catalog
+from .schemas import RouterConfig, RoutingDecision
+from .telemetry import log_decision
+
+
+class SmartRouter:
+    def __init__(
+        self,
+        routes_file: str = "routes.yaml",
+        api_key: Optional[str] = None,
+        max_retries: int = 2,
+    ):
+        load_dotenv()
+        self.routes_file = str(routes_file)
+        self.config: RouterConfig = load_router_config(routes_file)
+        self.client = instructor.from_litellm(completion)
+        self.max_retries = max_retries
+
+        if api_key:
+            os.environ["GEMINI_API_KEY"] = api_key
+
+    def route(
+        self,
+        query: str,
+        history: Optional[list[dict]] = None,
+    ) -> RoutingDecision:
+        started = time.perf_counter()
+        history = self._normalize_history(history)
+
+        messages = self._build_messages(query, history)
+
+        decision = self.client.chat.completions.create(
+            model=self.config.model,
+            response_model=RoutingDecision,
+            messages=messages,
+            temperature=self.config.temperature,
+            max_retries=self.max_retries,
+        )
+
+        decision = self._apply_guardrails(decision)
+        decision.router_latency_ms = int((time.perf_counter() - started) * 1000)
+
+        log_decision(
+            query=query,
+            history=history,
+            decision=decision,
+            model=self.config.model,
+            routes_file=self.routes_file,
+        )
+        return decision
+
+    def _build_messages(self, query: str, history: list[dict]) -> list[dict]:
+        route_catalog = build_route_catalog(self.config)
+
+        system_content = (
+            f"{SYSTEM_PROMPT}\n\n"
+            f"Default route: {self.config.default_route}\n"
+            f"Confidence threshold: {self.config.confidence_threshold}\n\n"
+            f"Available routes:\n{route_catalog}"
+        )
+
+        messages = [{"role": "system", "content": system_content}]
+        messages.extend(history)
+        messages.append({"role": "user", "content": query})
+        return messages
+
+    def _normalize_history(
+        self,
+        history: Optional[list[dict]],
+    ) -> list[dict]:
+        if not history:
+            return []
+
+        allowed_roles = {"user", "assistant", "system"}
+        normalized = []
+
+        for message in history:
+            role = message.get("role")
+            content = message.get("content")
+
+            if role not in allowed_roles or not isinstance(content, str):
+                raise ValueError(
+                    "History messages must contain role and content"
+                )
+
+            normalized.append({"role": role, "content": content})
+
+        limit = self.config.max_history_messages
+        return normalized[-limit:] if limit else []
+
+    def _apply_guardrails(self, decision: RoutingDecision) -> RoutingDecision:
+        valid_routes = {route.id for route in self.config.routes if route.enabled}
+        clarification_route = "clarify" if "clarify" in valid_routes else self.config.default_route
+
+        if decision.selected_route not in valid_routes:
+            decision.selected_route = self.config.default_route
+            decision.fallback = True
+            decision.confidence = min(decision.confidence, 0.5)
+            decision.reasoning = (
+                "Model selected an unknown route; fallback applied. "
+                + decision.reasoning
+            )
+
+        if decision.confidence < self.config.confidence_threshold:
+            decision.selected_route = clarification_route
+            decision.fallback = True
+
+        for step in decision.steps:
+            if step.route not in valid_routes:
+                step.route = self.config.default_route
+
+        expected_orders = list(range(1, len(decision.steps) + 1))
+        actual_orders = [step.order for step in decision.steps]
+        if decision.multi_step and (not decision.steps or actual_orders != expected_orders):
+            decision.multi_step = False
+            decision.steps = []
+        elif not decision.multi_step:
+            decision.steps = []
+
+        return decision

smart_router_ns-0.1.0/src/schemas.py

@@ -0,0 +1,47 @@
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class RouterType(str, Enum):
+    AGENT = "agent"
+    MCP = "mcp"
+    MODEL = "model"
+    FALLBACK = "fallback"
+
+class RouteStep(BaseModel):
+    order: int
+    route: str
+    resolved_query: str
+
+class RoutingDecision(BaseModel):
+    selected_route: str
+    confidence: float = Field(ge=0, le=1)
+    reasoning: str
+    resolved_query: str
+    requires_history: bool
+    multi_step: bool
+    steps: list[RouteStep] = Field(default_factory=list)
+    fallback: bool = False
+    router_latency_ms: int = 0
+
+class RouteDefinition(BaseModel):
+    id: str
+    type: RouterType
+    description: str
+    examples: list[str] = Field(default_factory=list)
+    keywords: list[str] = Field(default_factory=list)
+    enabled: bool = True
+
+class RouterConfig(BaseModel):
+    version: int = 1
+    default_route: str
+    confidence_threshold: float = Field(default=0.70, ge=0, le=1)
+    max_history_messages: int = Field(default=10, ge=0)
+    model: str
+    temperature: float = Field(default=0.0, ge=0, le=2)
+    routes: list[RouteDefinition]
+
+
+
+    

smart_router_ns-0.1.0/src/telemetry.py

@@ -0,0 +1,26 @@
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .schemas import RoutingDecision
+
+LOG_FILE = Path("router_logs.jsonl")
+
+def log_decision(
+    query: str,
+    history: list[dict],
+    decision: RoutingDecision,
+    model: str,
+    routes_file: str,
+):
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "query": query,
+        "history_message_count": len(history),
+        "model": model,
+        "routes_file": routes_file,
+        **decision.model_dump(),
+    }
+
+    with LOG_FILE.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")

smart_router_ns-0.1.0/tests/test_router.py

@@ -0,0 +1,193 @@
+from types import SimpleNamespace
+
+import pytest
+
+from src.config import load_router_config
+from src.router import SmartRouter
+from src.schemas import RouteStep, RoutingDecision
+
+
+def _make_router(monkeypatch, decision):
+    captured = {}
+
+    def create(**kwargs):
+        captured["request"] = kwargs
+        return decision
+
+    fake_client = SimpleNamespace(
+        chat=SimpleNamespace(completions=SimpleNamespace(create=create))
+    )
+    monkeypatch.setattr("src.router.instructor.from_litellm", lambda _: fake_client)
+    monkeypatch.setattr(
+        "src.router.log_decision",
+        lambda **kwargs: captured.setdefault("log", kwargs),
+    )
+    return SmartRouter(routes_file="routes.yaml"), captured
+
+
+def _decision(
+    route,
+    query,
+    *,
+    confidence=0.9,
+    requires_history=False,
+    multi_step=False,
+    steps=None,
+    fallback=False,
+):
+    return RoutingDecision(
+        selected_route=route,
+        confidence=confidence,
+        reasoning="Test fixture decision",
+        resolved_query=query,
+        requires_history=requires_history,
+        multi_step=multi_step,
+        steps=steps or [],
+        fallback=fallback,
+    )
+
+
+def test_yaml_loads_with_clarification_route():
+    config = load_router_config("routes.yaml")
+
+    assert config.default_route == "general_chat"
+    assert {route.id for route in config.routes} >= {
+        "calendar_mcp",
+        "clarify",
+        "web_research",
+    }
+    assert next(route for route in config.routes if route.id == "clarify").type.value == "fallback"
+
+
+def test_history_trimming(monkeypatch):
+    router, _ = _make_router(monkeypatch, _decision("general_chat", "Hello"))
+    history = [{"role": "user", "content": f"message {i}"} for i in range(20)]
+
+    trimmed = router._normalize_history(history)
+
+    assert len(trimmed) == router.config.max_history_messages
+
+
+def test_explicit_calendar_request(monkeypatch):
+    router, captured = _make_router(
+        monkeypatch,
+        _decision("calendar_mcp", "Schedule a meeting with Rahul tomorrow at 4 PM"),
+    )
+
+    result = router.route("Schedule a meeting with Rahul tomorrow at 4 PM")
+
+    assert result.selected_route == "calendar_mcp"
+    assert result.requires_history is False
+    assert "Rahul" in result.resolved_query
+    assert captured["log"]["model"] == router.config.model
+    assert captured["log"]["routes_file"] == "routes.yaml"
+
+
+def test_history_dependent_yes_resolves_booking(monkeypatch):
+    history = [
+        {"role": "user", "content": "Can you help me book a meeting with Rahul?"},
+        {"role": "assistant", "content": "What time should I schedule it?"},
+    ]
+    router, captured = _make_router(
+        monkeypatch,
+        _decision(
+            "calendar_mcp",
+            "Schedule a meeting with Rahul tomorrow at 4 PM",
+            requires_history=True,
+        ),
+    )
+
+    result = router.route("yes, do that", history=history)
+
+    assert result.selected_route == "calendar_mcp"
+    assert result.requires_history is True
+    assert "Rahul" in result.resolved_query
+    assert captured["request"]["messages"][1:3] == history
+    assert captured["request"]["messages"][-1]["content"] == "yes, do that"
+
+
+def test_multi_step_pricing_and_document_request(monkeypatch):
+    router, _ = _make_router(
+        monkeypatch,
+        _decision(
+            "web_research",
+            "Find current Azure AI Search pricing and summarize the product PDF",
+            multi_step=True,
+            steps=[
+                RouteStep(
+                    order=1,
+                    route="web_research",
+                    resolved_query="Find the latest Azure AI Search pricing",
+                ),
+                RouteStep(
+                    order=2,
+                    route="document_qa",
+                    resolved_query="Summarize the uploaded product PDF",
+                ),
+            ],
+        ),
+    )
+
+    result = router.route("Find the latest Azure AI Search pricing and summarize my product PDF")
+
+    assert result.selected_route == "web_research"
+    assert result.multi_step is True
+    assert [step.order for step in result.steps] == [1, 2]
+    assert [step.route for step in result.steps] == ["web_research", "document_qa"]
+
+
+def test_unclear_request_uses_clarification_fallback(monkeypatch):
+    router, _ = _make_router(
+        monkeypatch,
+        _decision("general_chat", "asdf qwerty thing", confidence=0.2),
+    )
+
+    result = router.route("asdf qwerty thing")
+
+    assert result.selected_route == "clarify"
+    assert result.fallback is True
+    assert result.confidence < router.config.confidence_threshold
+
+
+def test_cancel_request_keeps_calendar_route_and_changes_action(monkeypatch):
+    history = [
+        {"role": "user", "content": "Schedule a meeting with Rahul tomorrow at 4 PM"},
+        {"role": "assistant", "content": "I can help schedule that meeting."},
+    ]
+    router, _ = _make_router(
+        monkeypatch,
+        _decision(
+            "calendar_mcp",
+            "Cancel the meeting with Rahul scheduled for tomorrow at 4 PM",
+            requires_history=True,
+        ),
+    )
+
+    result = router.route("actually, cancel that meeting", history=history)
+
+    assert result.selected_route == "calendar_mcp"
+    assert "cancel" in result.resolved_query.lower()
+    assert "Rahul" in result.resolved_query
+
+
+@pytest.mark.parametrize(
+    "steps",
+    [
+        [],
+        [RouteStep(order=2, route="web_research", resolved_query="Step")],
+        [
+            RouteStep(order=1, route="web_research", resolved_query="First"),
+            RouteStep(order=3, route="document_qa", resolved_query="Third"),
+        ],
+    ],
+)
+def test_invalid_multi_step_payload_is_disabled(monkeypatch, steps):
+    router, _ = _make_router(
+        monkeypatch,
+        _decision("web_research", "combined request", multi_step=True, steps=steps),
+    )
+
+    result = router.route("combined request")
+
+    assert result.multi_step is False
+    assert result.steps == []