tensorfeed 2.1.0__tar.gz → 2.2.0__tar.gz

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfeed
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)
 Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
 License-Expression: MIT
@@ -37,6 +37,64 @@ Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
 
 Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
 
+## Featured: Route Verdict
+
+The single best model to use right now, as one signed call. Route Verdict fuses live pricing, contamination-discounted benchmark capability, real production usage, measured p95 latency probes, live incident state, and deprecation flags into one ranked decision, with an AFTA-signed receipt over the exact inputs. Instead of stitching together pricing pages, benchmark leaderboards, status dashboards, and your own latency tests, you get a current, defensible routing answer in one request.
+
+### Zero install, no key, one command (works today)
+
+```bash
+curl -s -A "tensorfeed-cc-quickstart" "https://tensorfeed.ai/api/preview/route-verdict?task=code"
+```
+
+Swap `task` for `reasoning`, `creative`, or `general`, or pass `?model=<id-or-name>` to score a specific model. The free preview is 10 calls per day per IP, no token. Abridged real response:
+
+```json
+{
+  "verdict": {
+    "rank": 1,
+    "model": { "name": "Gemini 2.5 Pro", "provider": "google" },
+    "pricing": { "blended": 5.625, "unit": "per 1M tokens" },
+    "latency": { "measured_p95_ms": 1223, "source": "measured_probe" },
+    "operational": { "ok": true, "status": "operational" },
+    "composite_score": 0.8449,
+    "why": "code quality 0.6498 after trust discount; corroborated by real usage (rank 5, 6.5% share, flat); measured p95 1223 ms; operational; blended $5.625 / 1M"
+  },
+  "rate_limit": { "limit": 10, "remaining": 9, "scope": "per IP per UTC day" },
+  "upgrade": { "premium_endpoint": "/api/premium/route-verdict", "adds": ["runners_up", "AFTA-signed receipt", "filter params", "no rate limit"] }
+}
+```
+
+The premium version (`/api/premium/route-verdict`, 1 credit) adds ranked runners-up, the constraint filters (`max_latency_p95_ms`, `budget`, `min_quality`, `require_operational`, `exclude_deprecated`), the AFTA-signed receipt, and no rate limit. It needs a token; credits come from [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
+
+### Native SDK call
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# Free preview: the top verdict only, no token. 10 calls/day per IP.
+preview = tf.route_verdict_preview(task="code")
+print(preview["verdict"]["model"]["name"], preview["verdict"]["why"])
+
+# Premium: runners-up, constraint filters, and the AFTA-signed receipt.
+# Needs a token (see the payment quickstart below).
+tf_paid = TensorFeed(token="YOUR_TOKEN")
+verdict = tf_paid.route_verdict(task="code", max_latency_p95_ms=1500)
+print(verdict["verdict"], verdict["runners_up"])
+```
+
+Pass `model="<id-or-name>"` instead of `task=` to score one model. Both methods accept exactly one of the two selectors.
+
+### The agent path (MCP)
+
+With the [`@tensorfeed/mcp-server`](https://www.npmjs.com/package/@tensorfeed/mcp-server) MCP server installed, an agent gets two tools: `route_verdict_preview` (free, the pick plus reasoning) and `route_verdict` (1 credit, ranked runners-up, constraint filters, and the AFTA-signed receipt it can audit).
+
+### Why it matters
+
+Models, prices, and latency move week to week. Route Verdict is one signed call an agent can act on now and later prove why it routed the way it did, without rebuilding the comparison from scratch each time.
+
 ## Install
 
 ```bash

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/README.md

@@ -4,6 +4,64 @@ Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
 
 Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
 
+## Featured: Route Verdict
+
+The single best model to use right now, as one signed call. Route Verdict fuses live pricing, contamination-discounted benchmark capability, real production usage, measured p95 latency probes, live incident state, and deprecation flags into one ranked decision, with an AFTA-signed receipt over the exact inputs. Instead of stitching together pricing pages, benchmark leaderboards, status dashboards, and your own latency tests, you get a current, defensible routing answer in one request.
+
+### Zero install, no key, one command (works today)
+
+```bash
+curl -s -A "tensorfeed-cc-quickstart" "https://tensorfeed.ai/api/preview/route-verdict?task=code"
+```
+
+Swap `task` for `reasoning`, `creative`, or `general`, or pass `?model=<id-or-name>` to score a specific model. The free preview is 10 calls per day per IP, no token. Abridged real response:
+
+```json
+{
+  "verdict": {
+    "rank": 1,
+    "model": { "name": "Gemini 2.5 Pro", "provider": "google" },
+    "pricing": { "blended": 5.625, "unit": "per 1M tokens" },
+    "latency": { "measured_p95_ms": 1223, "source": "measured_probe" },
+    "operational": { "ok": true, "status": "operational" },
+    "composite_score": 0.8449,
+    "why": "code quality 0.6498 after trust discount; corroborated by real usage (rank 5, 6.5% share, flat); measured p95 1223 ms; operational; blended $5.625 / 1M"
+  },
+  "rate_limit": { "limit": 10, "remaining": 9, "scope": "per IP per UTC day" },
+  "upgrade": { "premium_endpoint": "/api/premium/route-verdict", "adds": ["runners_up", "AFTA-signed receipt", "filter params", "no rate limit"] }
+}
+```
+
+The premium version (`/api/premium/route-verdict`, 1 credit) adds ranked runners-up, the constraint filters (`max_latency_p95_ms`, `budget`, `min_quality`, `require_operational`, `exclude_deprecated`), the AFTA-signed receipt, and no rate limit. It needs a token; credits come from [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
+
+### Native SDK call
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# Free preview: the top verdict only, no token. 10 calls/day per IP.
+preview = tf.route_verdict_preview(task="code")
+print(preview["verdict"]["model"]["name"], preview["verdict"]["why"])
+
+# Premium: runners-up, constraint filters, and the AFTA-signed receipt.
+# Needs a token (see the payment quickstart below).
+tf_paid = TensorFeed(token="YOUR_TOKEN")
+verdict = tf_paid.route_verdict(task="code", max_latency_p95_ms=1500)
+print(verdict["verdict"], verdict["runners_up"])
+```
+
+Pass `model="<id-or-name>"` instead of `task=` to score one model. Both methods accept exactly one of the two selectors.
+
+### The agent path (MCP)
+
+With the [`@tensorfeed/mcp-server`](https://www.npmjs.com/package/@tensorfeed/mcp-server) MCP server installed, an agent gets two tools: `route_verdict_preview` (free, the pick plus reasoning) and `route_verdict` (1 credit, ranked runners-up, constraint filters, and the AFTA-signed receipt it can audit).
+
+### Why it matters
+
+Models, prices, and latency move week to week. Route Verdict is one signed call an agent can act on now and later prove why it routed the way it did, without rebuilding the comparison from scratch each time.
+
 ## Install
 
 ```bash

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tensorfeed"
-version = "2.1.0"
+version = "2.2.0"
 description = "Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)"
 readme = "README.md"
 license = "MIT"

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/tensorfeed/_premium_tools.py

@@ -243,14 +243,15 @@ def format_compare_models(r: dict[str, Any]) -> str:
     models = r.get("models", []) or []
     lines = [f"Compared {len(models)} model(s):"]
     for m in models[:5]:
-        name = m.get("name") or m.get("id") or "?"
-        if m.get("unmatched"):
-            lines.append(f"  {name}: (no match)")
+        if m.get("matched") is False:
+            label = m.get("query") or m.get("name") or m.get("id") or "?"
+            lines.append(f"  {label}: (no match)")
             continue
+        name = m.get("name") or m.get("id") or "?"
         pricing = m.get("pricing", {}) or {}
         lines.append(
-            f"  {name}: in {pricing.get('inputPrice', '?')} / "
-            f"out {pricing.get('outputPrice', '?')} per 1M, "
+            f"  {name}: in {pricing.get('input', '?')} / "
+            f"out {pricing.get('output', '?')} per 1M, "
             f"ctx {m.get('context_window', '?')}"
         )
     rankings = r.get("rankings", {}) or {}
@@ -266,7 +267,7 @@ def format_cost_projection(r: dict[str, Any]) -> str:
     lines = ["Cost projection (per model):"]
     for p in proj[:10]:
         name = p.get("model", "?")
-        monthly = p.get("monthly", p.get("monthly_cost"))
+        monthly = p.get("monthly_total")
         lines.append(f"  {name}: ~{monthly}/month")
     ranked = r.get("ranked_cheapest_monthly", []) or []
     if ranked:

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/tensorfeed/client.py

@@ -18,7 +18,7 @@ from typing import Any  # noqa: F401  (re-exported by purchase_credits return ty
 
 
 DEFAULT_BASE_URL = "https://tensorfeed.ai/api"
-DEFAULT_USER_AGENT = "TensorFeed-SDK-Python/1.19"
+DEFAULT_USER_AGENT = "TensorFeed-SDK-Python/2.2"
 
 
 class TensorFeedError(Exception):
@@ -554,6 +554,39 @@ class TensorFeed:
             min_quality=min_quality,
         )
 
+    # ── Free: route verdict preview (rate-limited) ─────────────────
+
+    def route_verdict_preview(
+        self,
+        *,
+        task: str | None = None,
+        model: str | None = None,
+    ) -> dict[str, Any]:
+        """The signed Route Verdict, free preview. 10 calls/day per IP.
+
+        Route Verdict is TensorFeed's single signed model-routing
+        decision: the one best model to use right now plus the reasoning,
+        fusing live pricing, contamination-discounted benchmark
+        capability, real production usage, measured p95 latency probes,
+        live incident state, and deprecation flags into one ranked
+        answer. This free preview returns the top verdict only (no
+        runners-up and no AFTA receipt), so an agent can taste the shape
+        before paying. For ranked runners-up, the constraint filters, and
+        the AFTA-signed receipt, use ``route_verdict()`` with credits.
+
+        Exactly one of ``task`` or ``model`` is required.
+
+        Args:
+            task: code, reasoning, creative, or general. The task to
+                route for.
+            model: a model id or display name (e.g. "claude-opus-4-7")
+                to score a single model instead of routing a task.
+
+        Raises:
+            RateLimited: after 10 free preview calls per UTC day from an IP
+        """
+        return self._get("/preview/route-verdict", task=task, model=model)
+
     # ── Payment flow ───────────────────────────────────────────────
 
     def payment_info(self) -> dict[str, Any]:
@@ -755,6 +788,76 @@ class TensorFeed:
             "GET", "/premium/routing", params=params, require_token=True
         )
 
+    # ── Paid: route verdict (Tier 1, 1 credit/call) ────────────────
+
+    def route_verdict(
+        self,
+        *,
+        task: str | None = None,
+        model: str | None = None,
+        max_latency_p95_ms: float | None = None,
+        budget: float | None = None,
+        min_quality: float | None = None,
+        require_operational: bool | None = None,
+        exclude_deprecated: bool | None = None,
+    ) -> dict[str, Any]:
+        """The signed Route Verdict in full. 1 credit per call.
+
+        The decision layer on top of the free ``route_verdict_preview()``
+        taste. Returns the single best model to use right now plus ranked
+        runners-up, fusing live pricing, contamination-discounted
+        benchmark capability, real production usage, measured p95 latency
+        from the active probes, live incident-triage operational state,
+        and model deprecation flags into one verdict, with an AFTA-signed
+        receipt over the exact inputs so the routing decision is
+        cryptographically attestable.
+
+        Requires a token from ``confirm()`` or passed to the constructor.
+        Exactly one of ``task`` or ``model`` is required.
+
+        Args:
+            task: code, reasoning, creative, or general. The task to
+                route for.
+            model: a model id or display name to score a single model
+                instead of routing a task.
+            max_latency_p95_ms: drop candidates whose measured p95
+                exceeds this many milliseconds.
+            budget: optional max blended USD per 1M tokens.
+            min_quality: optional minimum quality score in [0, 1].
+            require_operational: default True server-side; drop candidates
+                known to be down or in failover.
+            exclude_deprecated: default True server-side; drop matched
+                deprecated or sunsetted models.
+
+        Returns:
+            Dict with ``query``, ``verdict``, ``runners_up``, ``trust``,
+            ``filters_applied``, ``data_freshness``, ``claim``, ``notes``,
+            ``attribution``, the AFTA ``receipt``, and ``billing``.
+
+        Raises:
+            ValueError: if no token is set on the client
+            PaymentRequired: if the token has insufficient credits
+        """
+        self._require_token("route_verdict")
+        params: dict[str, Any] = {}
+        if task is not None:
+            params["task"] = task
+        if model is not None:
+            params["model"] = model
+        if max_latency_p95_ms is not None:
+            params["max_latency_p95_ms"] = max_latency_p95_ms
+        if budget is not None:
+            params["budget"] = budget
+        if min_quality is not None:
+            params["min_quality"] = min_quality
+        if require_operational is not None:
+            params["require_operational"] = "true" if require_operational else "false"
+        if exclude_deprecated is not None:
+            params["exclude_deprecated"] = "true" if exclude_deprecated else "false"
+        return self._request(
+            "GET", "/premium/route-verdict", params=params, require_token=True
+        )
+
     # ── Paid: history series (Tier 1, 1 credit/call) ───────────────
 
     def _require_token(self, name: str) -> None:

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/tensorfeed.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfeed
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)
 Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
 License-Expression: MIT
@@ -37,6 +37,64 @@ Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
 
 Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
 
+## Featured: Route Verdict
+
+The single best model to use right now, as one signed call. Route Verdict fuses live pricing, contamination-discounted benchmark capability, real production usage, measured p95 latency probes, live incident state, and deprecation flags into one ranked decision, with an AFTA-signed receipt over the exact inputs. Instead of stitching together pricing pages, benchmark leaderboards, status dashboards, and your own latency tests, you get a current, defensible routing answer in one request.
+
+### Zero install, no key, one command (works today)
+
+```bash
+curl -s -A "tensorfeed-cc-quickstart" "https://tensorfeed.ai/api/preview/route-verdict?task=code"
+```
+
+Swap `task` for `reasoning`, `creative`, or `general`, or pass `?model=<id-or-name>` to score a specific model. The free preview is 10 calls per day per IP, no token. Abridged real response:
+
+```json
+{
+  "verdict": {
+    "rank": 1,
+    "model": { "name": "Gemini 2.5 Pro", "provider": "google" },
+    "pricing": { "blended": 5.625, "unit": "per 1M tokens" },
+    "latency": { "measured_p95_ms": 1223, "source": "measured_probe" },
+    "operational": { "ok": true, "status": "operational" },
+    "composite_score": 0.8449,
+    "why": "code quality 0.6498 after trust discount; corroborated by real usage (rank 5, 6.5% share, flat); measured p95 1223 ms; operational; blended $5.625 / 1M"
+  },
+  "rate_limit": { "limit": 10, "remaining": 9, "scope": "per IP per UTC day" },
+  "upgrade": { "premium_endpoint": "/api/premium/route-verdict", "adds": ["runners_up", "AFTA-signed receipt", "filter params", "no rate limit"] }
+}
+```
+
+The premium version (`/api/premium/route-verdict`, 1 credit) adds ranked runners-up, the constraint filters (`max_latency_p95_ms`, `budget`, `min_quality`, `require_operational`, `exclude_deprecated`), the AFTA-signed receipt, and no rate limit. It needs a token; credits come from [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
+
+### Native SDK call
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# Free preview: the top verdict only, no token. 10 calls/day per IP.
+preview = tf.route_verdict_preview(task="code")
+print(preview["verdict"]["model"]["name"], preview["verdict"]["why"])
+
+# Premium: runners-up, constraint filters, and the AFTA-signed receipt.
+# Needs a token (see the payment quickstart below).
+tf_paid = TensorFeed(token="YOUR_TOKEN")
+verdict = tf_paid.route_verdict(task="code", max_latency_p95_ms=1500)
+print(verdict["verdict"], verdict["runners_up"])
+```
+
+Pass `model="<id-or-name>"` instead of `task=` to score one model. Both methods accept exactly one of the two selectors.
+
+### The agent path (MCP)
+
+With the [`@tensorfeed/mcp-server`](https://www.npmjs.com/package/@tensorfeed/mcp-server) MCP server installed, an agent gets two tools: `route_verdict_preview` (free, the pick plus reasoning) and `route_verdict` (1 credit, ranked runners-up, constraint filters, and the AFTA-signed receipt it can audit).
+
+### Why it matters
+
+Models, prices, and latency move week to week. Route Verdict is one signed call an agent can act on now and later prove why it routed the way it did, without rebuilding the comparison from scratch each time.
+
 ## Install
 
 ```bash

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/tensorfeed.egg-info/SOURCES.txt

@@ -12,4 +12,5 @@ tensorfeed.egg-info/SOURCES.txt
 tensorfeed.egg-info/dependency_links.txt
 tensorfeed.egg-info/requires.txt
 tensorfeed.egg-info/top_level.txt
-tests/test_premium_tools.py
+tests/test_premium_tools.py
+tests/test_route_verdict.py

{tensorfeed-2.1.0 → tensorfeed-2.2.0}/tests/test_premium_tools.py

@@ -32,10 +32,10 @@ class SafeCallBehavior(unittest.TestCase):
 
     def test_payment_required_appends_credits_hint(self):
         def boom():
-            raise PaymentRequired(402, {"credits_required": 2})
+            raise PaymentRequired(402, {"credits_required": 1})
 
         out = pt.safe_call(boom, lambda r: "unreachable")
-        self.assertIn("2 credit", out)
+        self.assertIn("1 credit", out)
 
     def test_missing_token_value_error_returns_guidance(self):
         def boom():
@@ -119,12 +119,15 @@ class Formatters(unittest.TestCase):
                 ]
             },
             "tensorfeed_compare_models": {
-                "models": [{"name": "A", "pricing": {"inputPrice": 1, "outputPrice": 2},
-                            "context_window": 200000}],
+                "models": [
+                    {"name": "A", "pricing": {"input": 1, "output": 2, "blended": 1.5},
+                     "context_window": 200000},
+                    {"matched": False, "query": "ghost-model", "reason": "model_not_found"},
+                ],
                 "rankings": {"cheapest_blended": "A"},
             },
             "tensorfeed_cost_projection": {
-                "projections": [{"model": "A", "monthly": 12.5}],
+                "projections": [{"model": "A", "monthly_total": 12.5}],
                 "ranked_cheapest_monthly": [{"model": "A"}],
             },
             "tensorfeed_news_search": {
@@ -155,6 +158,26 @@ class Formatters(unittest.TestCase):
         out = pt.format_status_leaderboard({"entries": [], "error": "no_data"})
         self.assertIn("no_data", out)
 
+    def test_cost_projection_reads_monthly_total(self):
+        out = pt.format_cost_projection(
+            {"projections": [{"model": "A", "monthly_total": 12.5}]}
+        )
+        self.assertIn("12.5", out)
+        self.assertNotIn("None", out)
+
+    def test_model_comparison_pricing_fields_and_no_match(self):
+        out = pt.format_compare_models(
+            {
+                "models": [
+                    {"name": "A", "pricing": {"input": 1, "output": 2}, "context_window": 200000},
+                    {"matched": False, "query": "ghost-model", "reason": "model_not_found"},
+                ]
+            }
+        )
+        self.assertIn("in 1 / out 2", out)
+        self.assertIn("ghost-model: (no match)", out)
+        self.assertNotIn("?", out)
+
     def test_names_and_descriptions_and_formatters_align(self):
         self.assertEqual(set(pt.DESCRIPTIONS), set(pt.FORMATTERS))
         self.assertEqual(set(pt.PREMIUM_TOOL_NAMES), set(pt.DESCRIPTIONS))

tensorfeed-2.2.0/tests/test_route_verdict.py

@@ -0,0 +1,152 @@
+"""Tests for the native Route Verdict client methods.
+
+Network-free. Patches urllib.request.urlopen so each method runs through
+the real client plumbing (URL building, auth header logic, param
+serialization) without a socket. Asserts that:
+
+  - route_verdict_preview hits /preview/route-verdict with NO auth header
+  - route_verdict hits /premium/route-verdict WITH the bearer auth header
+  - optional params serialize only when provided
+  - exactly the task / model selector is forwarded
+
+Run from sdk/python::
+
+    python -m unittest discover -s tests -t .
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import unittest
+import urllib.parse
+import urllib.request
+from typing import Any
+from unittest import mock
+
+from tensorfeed import TensorFeed
+
+
+def _capture(client: TensorFeed) -> dict[str, Any]:
+    """Patch urlopen, return a dict that the patched call fills in.
+
+    The fake urlopen records the outgoing Request (full URL and headers)
+    and returns a minimal JSON body so the method completes normally.
+    """
+    captured: dict[str, Any] = {}
+
+    class _FakeResp:
+        def __init__(self, body: bytes) -> None:
+            self._body = body
+
+        def read(self) -> bytes:
+            return self._body
+
+        def __enter__(self) -> "_FakeResp":
+            return self
+
+        def __exit__(self, *exc: object) -> None:
+            return None
+
+    def fake_urlopen(req: urllib.request.Request, timeout: float = 0.0) -> _FakeResp:
+        full_url = req.full_url
+        parsed = urllib.parse.urlparse(full_url)
+        captured["url"] = full_url
+        captured["path"] = parsed.path
+        captured["params"] = dict(urllib.parse.parse_qsl(parsed.query))
+        # Header keys are normalized to Capitalized form by urllib.
+        captured["headers"] = {k.lower(): v for k, v in req.header_items()}
+        captured["method"] = req.get_method()
+        return _FakeResp(io.BytesIO(b'{"ok": true}').read())
+
+    client._patch = mock.patch.object(  # type: ignore[attr-defined]
+        urllib.request, "urlopen", side_effect=fake_urlopen
+    )
+    client._patch.start()  # type: ignore[attr-defined]
+    return captured
+
+
+class RouteVerdictPreview(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tf = TensorFeed()  # no token: free preview
+        self.captured = _capture(self.tf)
+
+    def tearDown(self) -> None:
+        self.tf._patch.stop()  # type: ignore[attr-defined]
+
+    def test_preview_hits_free_path_with_task(self) -> None:
+        out = self.tf.route_verdict_preview(task="code")
+        self.assertEqual(out, {"ok": True})
+        self.assertEqual(self.captured["path"], "/api/preview/route-verdict")
+        self.assertEqual(self.captured["params"], {"task": "code"})
+
+    def test_preview_has_no_auth_header(self) -> None:
+        # Even if a token is present, the free preview must not advertise it.
+        tf = TensorFeed(token="tok_secret")
+        captured = _capture(tf)
+        try:
+            tf.route_verdict_preview(model="claude-opus-4-7")
+        finally:
+            tf._patch.stop()  # type: ignore[attr-defined]
+        self.assertEqual(captured["path"], "/api/preview/route-verdict")
+        self.assertEqual(captured["params"], {"model": "claude-opus-4-7"})
+        self.assertNotIn("authorization", captured["headers"])
+
+    def test_preview_omits_unset_selector(self) -> None:
+        self.tf.route_verdict_preview(task="reasoning")
+        self.assertNotIn("model", self.captured["params"])
+
+
+class RouteVerdictPremium(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tf = TensorFeed(token="tok_abc123")
+        self.captured = _capture(self.tf)
+
+    def tearDown(self) -> None:
+        self.tf._patch.stop()  # type: ignore[attr-defined]
+
+    def test_premium_hits_paid_path_with_auth(self) -> None:
+        out = self.tf.route_verdict(task="code")
+        self.assertEqual(out, {"ok": True})
+        self.assertEqual(self.captured["path"], "/api/premium/route-verdict")
+        self.assertEqual(self.captured["headers"]["authorization"], "Bearer tok_abc123")
+        self.assertEqual(self.captured["params"], {"task": "code"})
+
+    def test_premium_serializes_optional_params(self) -> None:
+        self.tf.route_verdict(
+            task="code",
+            max_latency_p95_ms=1500,
+            budget=5.0,
+            min_quality=0.6,
+            require_operational=True,
+            exclude_deprecated=False,
+        )
+        params = self.captured["params"]
+        self.assertEqual(params["task"], "code")
+        self.assertEqual(params["max_latency_p95_ms"], "1500")
+        self.assertEqual(params["budget"], "5.0")
+        self.assertEqual(params["min_quality"], "0.6")
+        self.assertEqual(params["require_operational"], "true")
+        self.assertEqual(params["exclude_deprecated"], "false")
+
+    def test_premium_omits_unset_optional_params(self) -> None:
+        self.tf.route_verdict(model="gpt-5")
+        params = self.captured["params"]
+        self.assertEqual(params, {"model": "gpt-5"})
+        for key in (
+            "max_latency_p95_ms",
+            "budget",
+            "min_quality",
+            "require_operational",
+            "exclude_deprecated",
+        ):
+            self.assertNotIn(key, params)
+
+    def test_premium_requires_token(self) -> None:
+        tf = TensorFeed()  # no token
+        with self.assertRaises(ValueError):
+            tf.route_verdict(task="code")
+
+
+if __name__ == "__main__":
+    unittest.main()