tensorfeed 2.0.0__tar.gz → 2.2.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tensorfeed
-Version: 2.0.0
-Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, agent payments via USDC on Base (optional web3 auto-send)
+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
 Project-URL: Homepage, https://tensorfeed.ai
@@ -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
@@ -197,6 +255,34 @@ print(tf.balance())
 rec = tf.routing(task="code")
 ```
 
+## Framework Tools (LangChain, CrewAI)
+
+Drop TensorFeed into an agent framework as ready-made tools.
+
+```bash
+pip install 'tensorfeed[langchain]'   # or 'tensorfeed[crewai]'
+```
+
+```python
+from tensorfeed.langchain import tensorfeed_tools, tensorfeed_premium_tools
+
+# Five free tools (news, status, attention, harnesses, routing preview)
+free = tensorfeed_tools()
+
+# Free plus the paid catalog (whats_new, full routing, compare models,
+# cost projection, news search, provider deep dive, status leaderboard)
+all_tools = tensorfeed_tools(token="YOUR_TOKEN", include_premium=True)
+
+# Just the paid catalog
+paid = tensorfeed_premium_tools(token="YOUR_TOKEN")
+```
+
+CrewAI is identical: `from tensorfeed.crewai import tensorfeed_tools, tensorfeed_premium_tools`.
+
+The default `tensorfeed_tools()` stays free-only and unchanged, so existing code keeps working. Premium is opt-in via `include_premium=True`.
+
+**Payment posture.** The premium tools never move funds. Attach them with or without a token: called without spendable credits they return a short, actionable guidance string (explaining that an operator provisions credits out of band) instead of paying or raising. There is no code path from a tool call to the wallet or the web3 signer. Credit purchases stay an explicit, per-action operator decision, by design. This is enforced in one shared module and covered by tests, including a static guard that fails if a future change introduces an autonomous-payment path.
+
 ## Error Handling
 
 ```python

{tensorfeed-2.0.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
@@ -164,6 +222,34 @@ print(tf.balance())
 rec = tf.routing(task="code")
 ```
 
+## Framework Tools (LangChain, CrewAI)
+
+Drop TensorFeed into an agent framework as ready-made tools.
+
+```bash
+pip install 'tensorfeed[langchain]'   # or 'tensorfeed[crewai]'
+```
+
+```python
+from tensorfeed.langchain import tensorfeed_tools, tensorfeed_premium_tools
+
+# Five free tools (news, status, attention, harnesses, routing preview)
+free = tensorfeed_tools()
+
+# Free plus the paid catalog (whats_new, full routing, compare models,
+# cost projection, news search, provider deep dive, status leaderboard)
+all_tools = tensorfeed_tools(token="YOUR_TOKEN", include_premium=True)
+
+# Just the paid catalog
+paid = tensorfeed_premium_tools(token="YOUR_TOKEN")
+```
+
+CrewAI is identical: `from tensorfeed.crewai import tensorfeed_tools, tensorfeed_premium_tools`.
+
+The default `tensorfeed_tools()` stays free-only and unchanged, so existing code keeps working. Premium is opt-in via `include_premium=True`.
+
+**Payment posture.** The premium tools never move funds. Attach them with or without a token: called without spendable credits they return a short, actionable guidance string (explaining that an operator provisions credits out of band) instead of paying or raising. There is no code path from a tool call to the wallet or the web3 signer. Credit purchases stay an explicit, per-action operator decision, by design. This is enforced in one shared module and covered by tests, including a static guard that fails if a future change introduces an autonomous-payment path.
+
 ## Error Handling
 
 ```python

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

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tensorfeed"
-version = "2.0.0"
-description = "Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, agent payments via USDC on Base (optional web3 auto-send)"
+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"
 requires-python = ">=3.9"

{tensorfeed-2.0.0 → tensorfeed-2.2.0}/tensorfeed/__init__.py

@@ -21,4 +21,4 @@ __all__ = [
     "PaymentRequired",
     "RateLimited",
 ]
-__version__ = "1.29.0"
+__version__ = "2.1.0"

tensorfeed-2.2.0/tensorfeed/_premium_tools.py

@@ -0,0 +1,342 @@
+"""Shared premium-tool plumbing for the framework adapters.
+
+Internal module. Powers ``tensorfeed.langchain.tensorfeed_premium_tools()``
+and ``tensorfeed.crewai.tensorfeed_premium_tools()``. It is framework
+agnostic: it owns the canonical tool descriptions, the result
+formatters, and the one piece of behavior that must never drift between
+frameworks, the payment posture.
+
+Payment posture (load-bearing, do not weaken):
+
+  These tools never move funds. A premium call made without a valid
+  token returns a clear, actionable guidance string explaining how an
+  operator provisions credits out of band. The tool does not, and will
+  not, initiate a USDC transfer on its own. Autonomous payment from
+  inside a tool call is a deliberate non-feature: credit purchases stay
+  an explicit, per-action operator decision. Centralizing this here (and
+  testing it once) keeps every framework binding honest.
+
+Each adapter writes its own thin, explicitly typed function or tool
+class so the framework gets a good argument schema for the model, then
+routes the call through ``safe_call`` with the shared formatter. The
+descriptions are shared verbatim so LangChain and CrewAI surface
+identical copy to the agent.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from .client import PaymentRequired, RateLimited, TensorFeedError
+
+
+# The exact, actionable message an agent sees when a premium tool is
+# called without spendable credits. It tells the model what is true
+# (this needs credits), what will not happen (no automatic payment),
+# and what the path is (an operator provisions a token out of band).
+PREMIUM_PAYMENT_GUIDANCE = (
+    "This is a paid TensorFeed endpoint (1 credit) and no spendable "
+    "credit token is available. This tool will not buy credits or move "
+    "any funds on its own, by design. To enable it, an operator must "
+    "provision credits out of band (buy_credits() then confirm() with a "
+    "USDC payment on Base, or the documented x402 flow) and pass the "
+    "resulting token when constructing the tools, for example "
+    "tensorfeed_premium_tools(token='...'). Until then, prefer the free "
+    "TensorFeed tools (news, status, attention, harnesses, routing "
+    "preview) for this question."
+)
+
+
+def _billing_line(result: dict[str, Any]) -> str:
+    """One-line cost footer if the response carries billing metadata."""
+    billing = result.get("billing")
+    if not isinstance(billing, dict):
+        return ""
+    charged = billing.get("credits_charged")
+    remaining = billing.get("balance")
+    bits = []
+    if charged is not None:
+        bits.append(f"{charged} credit(s) charged")
+    if remaining is not None:
+        bits.append(f"{remaining} remaining")
+    return f"\n[{', '.join(bits)}]" if bits else ""
+
+
+def safe_call(
+    invoke: Callable[[], dict[str, Any]],
+    formatter: Callable[[dict[str, Any]], str],
+) -> str:
+    """Run a premium client call and return agent-readable text.
+
+    Never raises for the expected money and quota cases. A raised
+    exception inside an agent tool call usually aborts the agent or
+    produces an opaque trace; a structured guidance string lets the
+    model reason about what to do next (typically: tell the user it
+    needs credits, or fall back to a free tool).
+
+      * no token / token rejected (402): the payment guidance string
+      * rate limited (429): a short back-off message
+      * other API error: a concise one-line error
+      * success: the tool's own formatter output
+
+    The PaymentRequired and missing-token paths are exactly where an
+    autonomous-payment bug would hide. There is intentionally no code
+    path here that touches the wallet or the web3 signer.
+    """
+    try:
+        result = invoke()
+    except PaymentRequired as e:
+        hint = ""
+        payload = getattr(e, "payload", None)
+        if isinstance(payload, dict):
+            need = payload.get("credits_required")
+            if need is not None:
+                hint = f" (endpoint requires {need} credit(s))"
+        return PREMIUM_PAYMENT_GUIDANCE + hint
+    except ValueError:
+        # client raises ValueError when no token is set on the client
+        return PREMIUM_PAYMENT_GUIDANCE
+    except RateLimited:
+        return (
+            "TensorFeed rate limit hit. Wait and retry, or reduce call "
+            "frequency. Free public endpoints allow 120 requests/minute "
+            "per IP; bearer tokens are exempt."
+        )
+    except TensorFeedError as e:
+        return f"TensorFeed API error {e.status_code}: {e}"
+    try:
+        return formatter(result) + _billing_line(result)
+    except Exception:  # defensive: a shape change must not break the agent
+        return (
+            "TensorFeed returned a response in an unexpected shape. Raw "
+            f"top-level keys: {sorted(result) if isinstance(result, dict) else type(result).__name__}."
+        )
+
+
+# ── Shared descriptions (identical copy across frameworks) ─────────────
+#
+# Every description states the credit cost up front so the model can
+# weigh it before calling, and what the tool is uniquely good for so it
+# is picked for the right question.
+
+DESCRIPTIONS: dict[str, str] = {
+    "tensorfeed_whats_new": (
+        "PAID, 1 credit. The agent boot brief: a single curated summary "
+        "of AI model pricing changes, new and removed models, service "
+        "incidents that started or resolved, current operational counts, "
+        "and the top news headlines, over the last 1 to 7 days. Call "
+        "this once at startup instead of polling many free endpoints. "
+        "Inputs: days (1-7, default 1), news_limit (1-25, default 10)."
+    ),
+    "tensorfeed_routing": (
+        "PAID, 1 credit. Full ranked model routing: the top-N AI models "
+        "for a task with a complete score breakdown (quality, "
+        "availability, cost, latency). Use this when the free top-1 "
+        "preview is not enough. Inputs: task (code|reasoning|creative|"
+        "general), budget (optional max blended USD per 1M tokens), "
+        "top_n (1-10, default 5)."
+    ),
+    "tensorfeed_compare_models": (
+        "PAID, 1 credit. Side-by-side comparison of 2 to 5 AI models: "
+        "pricing, normalized benchmarks, live provider status, context "
+        "window, capabilities, recent news, plus rankings for cheapest "
+        "blended and most context. Input: ids (comma-separated model "
+        "ids or display names, 2 to 5)."
+    ),
+    "tensorfeed_cost_projection": (
+        "PAID, 1 credit. Project the cost of a token-usage workload "
+        "across 1 to 10 models over day, week, month, and year, with a "
+        "cheapest-monthly ranking. Inputs: models (comma-separated), "
+        "input_tokens_per_day, output_tokens_per_day, horizon (optional)."
+    ),
+    "tensorfeed_news_search": (
+        "PAID, 1 credit. Full-text search over the TensorFeed AI news "
+        "corpus with relevance scoring and a recency boost. Filter by "
+        "query, date range, provider, and category. Use this instead of "
+        "the free latest-news feed when you need to find specific "
+        "coverage. Inputs: q, from_date, to_date, provider, category, "
+        "limit (1-100, default 25)."
+    ),
+    "tensorfeed_provider_deepdive": (
+        "PAID, 1 credit. One AI provider's full profile in a single "
+        "call: live status, every model with pricing and benchmarks "
+        "joined in, recent news, and agent-traffic attribution. Doing "
+        "this from free endpoints takes several round-trips and a "
+        "non-trivial join. Input: provider (id or display name)."
+    ),
+    "tensorfeed_status_leaderboard": (
+        "PAID, 1 credit. Cross-provider AI uptime leaderboard over the "
+        "full 90-day retention window, with incident_count and "
+        "mttr_minutes per provider. Built for vendor selection and "
+        "post-incident review. Inputs: from_date, to_date (optional, "
+        "default last 30 days)."
+    ),
+}
+
+PREMIUM_TOOL_NAMES: list[str] = list(DESCRIPTIONS)
+
+
+# ── Shared result formatters ───────────────────────────────────────────
+#
+# Compact, deterministic, defensive. They turn a response dict into a
+# short text block an LLM can read. Lists are truncated. Missing keys
+# degrade to a sane default rather than raising (safe_call also guards
+# the formatter, this is belt and suspenders).
+
+
+def format_whats_new(r: dict[str, Any]) -> str:
+    w = r.get("window", {})
+    s = r.get("summary", {})
+    lines = [f"What's new ({w.get('days', '?')}d window):"]
+    pricing = r.get("pricing", {}) or {}
+    changed = pricing.get("changes", []) or []
+    added = pricing.get("new_models", []) or []
+    removed = pricing.get("removed_models", []) or []
+    lines.append(
+        f"  pricing: {len(changed)} changes, {len(added)} new, "
+        f"{len(removed)} removed models"
+    )
+    for c in changed[:5]:
+        lines.append(
+            f"    {c.get('model', '?')} {c.get('field', '')}: "
+            f"{c.get('from')} -> {c.get('to')}"
+        )
+    status = r.get("status", {}) or {}
+    incidents = status.get("incidents", []) or []
+    lines.append(f"  status: {len(incidents)} incident(s) in window")
+    for i in incidents[:3]:
+        lines.append(
+            f"    {i.get('provider', '?')}: {i.get('state', i.get('status', ''))}"
+        )
+    news = r.get("news", []) or []
+    lines.append(f"  news: {len(news)} headlines")
+    for n in news[:5]:
+        lines.append(f"    - {n.get('title', '')} ({n.get('source', '')})")
+    if s:
+        lines.append(f"  counts: {s}")
+    return "\n".join(lines)
+
+
+def format_routing(r: dict[str, Any]) -> str:
+    recs = r.get("recommendations") or r.get("recommendation") or []
+    if isinstance(recs, dict):
+        recs = [recs]
+    if not recs:
+        return "No routing recommendation returned."
+    lines = ["Model routing (ranked):"]
+    for x in recs[:10]:
+        model = x.get("model", {})
+        name = model.get("name") if isinstance(model, dict) else model
+        score = x.get("composite_score", x.get("score"))
+        try:
+            score_s = f"{float(score):.3f}"
+        except (TypeError, ValueError):
+            score_s = str(score)
+        lines.append(
+            f"  #{x.get('rank', '?')} {name}  score={score_s}"
+            f"  provider={x.get('provider', model.get('provider') if isinstance(model, dict) else '')}"
+        )
+    return "\n".join(lines)
+
+
+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]:
+        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('input', '?')} / "
+            f"out {pricing.get('output', '?')} per 1M, "
+            f"ctx {m.get('context_window', '?')}"
+        )
+    rankings = r.get("rankings", {}) or {}
+    if rankings.get("cheapest_blended"):
+        lines.append(f"  cheapest blended: {rankings['cheapest_blended']}")
+    if rankings.get("most_context"):
+        lines.append(f"  most context: {rankings['most_context']}")
+    return "\n".join(lines)
+
+
+def format_cost_projection(r: dict[str, Any]) -> str:
+    proj = r.get("projections", []) or []
+    lines = ["Cost projection (per model):"]
+    for p in proj[:10]:
+        name = p.get("model", "?")
+        monthly = p.get("monthly_total")
+        lines.append(f"  {name}: ~{monthly}/month")
+    ranked = r.get("ranked_cheapest_monthly", []) or []
+    if ranked:
+        head = ranked[0]
+        name = head.get("model") if isinstance(head, dict) else head
+        lines.append(f"  cheapest monthly: {name}")
+    return "\n".join(lines)
+
+
+def format_news_search(r: dict[str, Any]) -> str:
+    results = r.get("results", []) or []
+    lines = [
+        f"News search: {r.get('matched', len(results))} matched, "
+        f"showing {len(results)}"
+    ]
+    for a in results[:10]:
+        lines.append(
+            f"  - {a.get('title', '')} ({a.get('source', '')}, "
+            f"{a.get('published_at', '')}) {a.get('url', '')}"
+        )
+    return "\n".join(lines)
+
+
+def format_provider_deepdive(r: dict[str, Any]) -> str:
+    prov = r.get("provider", "?")
+    status = r.get("status", {})
+    st = status.get("status") if isinstance(status, dict) else status
+    models = r.get("models", []) or []
+    lines = [
+        f"{prov}: status={st}, {len(models)} model(s), "
+        f"{r.get('recent_news_count', 0)} recent news, "
+        f"{r.get('agent_traffic_24h', 0)} agent hits/24h"
+    ]
+    for m in models[:6]:
+        lines.append(
+            f"  {m.get('name', m.get('id', '?'))}: "
+            f"tier {m.get('tier', '?')}, ctx {m.get('context_window', '?')}"
+        )
+    for n in (r.get("recent_news", []) or [])[:5]:
+        lines.append(f"  news: {n.get('title', '')} ({n.get('source', '')})")
+    return "\n".join(lines)
+
+
+def format_status_leaderboard(r: dict[str, Any]) -> str:
+    entries = r.get("entries", []) or []
+    if not entries:
+        return (
+            "No leaderboard data for the requested window "
+            f"({r.get('error', 'no_data')})."
+        )
+    lines = ["AI provider uptime leaderboard:"]
+    for e in entries[:15]:
+        lines.append(
+            f"  #{e.get('rank', '?')} {e.get('provider', '?')}: "
+            f"{e.get('uptime_pct', '?')}% uptime, "
+            f"{e.get('incident_count', 0)} incidents, "
+            f"MTTR {e.get('mttr_minutes', '?')}m"
+        )
+    return "\n".join(lines)
+
+
+# Maps tool name -> (client method name, formatter). The adapters use
+# this so the call target and the formatter never drift apart.
+FORMATTERS: dict[str, Callable[[dict[str, Any]], str]] = {
+    "tensorfeed_whats_new": format_whats_new,
+    "tensorfeed_routing": format_routing,
+    "tensorfeed_compare_models": format_compare_models,
+    "tensorfeed_cost_projection": format_cost_projection,
+    "tensorfeed_news_search": format_news_search,
+    "tensorfeed_provider_deepdive": format_provider_deepdive,
+    "tensorfeed_status_leaderboard": format_status_leaderboard,
+}