@tensorfeed/mcp-server 1.36.3 → 1.37.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the [TensorFeed.ai MCP server](https://github.com/RipperMercs/tensorfeed-mcp). Free tools work without configuration; premium tools require a bearer token via the `TENSORFEED_TOKEN` env var. Buy credits at [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
 
+## 1.36.4 - 2026-05-31
+
+Docs-only release. The README now opens with the Route Verdict quickstart: a
+zero-install curl against the free preview plus the `route_verdict_preview` and
+`route_verdict` tools. No tool, pricing, or behavior changes from 1.36.3.
+
 ## 1.36.3 - 2026-05-31
 
 Adds the Route Verdict wedge: TensorFeed's signed routing decision is now a

package/README.md

@@ -6,6 +6,59 @@
 
 This subfolder remains in the main `tensorfeed` repo as the **publishing source** for the npm package (`@tensorfeed/mcp-server`) and the [official MCP registry](https://registry.modelcontextprotocol.io/v0/servers/ai.tensorfeed/mcp-server) entry. Edits to `src/`, `server.json`, `package.json`, etc. happen here and get pushed to the standalone repo on release.
 
+## 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
+{
+  "ok": true,
+  "preview": true,
+  "query": { "task": "code", "model": null },
+  "verdict": {
+    "rank": 1,
+    "model": { "name": "Gemini 2.5 Pro", "provider": "google" },
+    "pricing": { "blended": 5.625, "unit": "per 1M tokens" },
+    "quality": { "trust_discounted": 0.6498 },
+    "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 agent path (MCP)
+
+With `@tensorfeed/mcp-server` installed, an agent gets two tools. Call the free one for the pick, then the paid one when it needs to defend the choice:
+
+```text
+# Free taste: the top pick + reasoning, no token (10/IP/day)
+route_verdict_preview({ task: "code" })
+
+# 1 credit: ranked runners-up, constraint filters, AFTA-signed receipt
+route_verdict({ task: "code", max_latency_p95_ms: 1500, budget: 8, min_quality: 0.6 })
+```
+
+`route_verdict` adds the ranked runners-up, the constraint filters (`max_latency_p95_ms`, `budget`, `min_quality`, `require_operational`, `exclude_deprecated`), and the AFTA-signed receipt the agent can audit later. Credits come from [tensorfeed.ai/developers/agent-payments](https://tensorfeed.ai/developers/agent-payments).
+
+### 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.
+
 ## Publish a new version
 
 From the main tensorfeed repo:

package/dist/index.js

@@ -226,6 +226,61 @@ registerTool('is_service_down', 'Check if a specific AI service is currently dow
             }]
     };
 });
+// Tool: check_agent_ready
+registerTool('check_agent_ready', 'Score how agent-ready a website is, 0 to 100, from its public surfaces: x402 payment manifest, /.well-known/agent.json, an OpenAPI spec, llms.txt, AI-bot crawlability, and ai.txt. Returns the score, the tier (closed, emerging, ready, or advanced), and exactly which surfaces the site exposes. Unlike single-site "is my site agent-ready" scanners, this reads from TensorFeed\'s daily-crawled cross-domain dataset, so the same call works for any tracked domain and the scoring rule is published and identical for every site. Free, no auth.', {
+    domain: z.string().describe('Bare domain to score, e.g. "stripe.com" (no scheme, no path)'),
+}, async ({ domain }) => {
+    const data = await fetchJSON(`/agent-ready/site?domain=${encodeURIComponent(domain)}`);
+    if (!data.found || !data.readiness) {
+        return { content: [{ type: 'text', text: `${data.domain} is not in TensorFeed's tracked set yet (no agent-readiness score). About 500 curated domains are tracked.` }] };
+    }
+    const r = data.readiness;
+    const present = Object.entries(r.surfaces).filter(([, v]) => v).map(([k]) => k);
+    const text = `${data.domain}: agent-readiness ${r.score}/100 (${r.tier})\n` +
+        `Surfaces present: ${present.length ? present.join(', ') : 'none'}\n` +
+        `x402=${r.surfaces.x402} agent.json=${r.surfaces.agentJson} openapi=${r.surfaces.openapi} llms.txt=${r.surfaces.llmsTxt} crawlable=${r.surfaces.crawlable} ai.txt=${r.surfaces.aiTxt}\n` +
+        `Last checked: ${data.captured_at ?? 'n/a'}`;
+    return { content: [{ type: 'text', text }] };
+});
+// Tool: agent_ready_summary
+registerTool('agent_ready_summary', 'Get the state of the agentic web. Across about 500 curated domains, returns the share exposing each agent surface (x402, agent.json, OpenAPI, llms.txt, crawlable, ai.txt), the readiness-tier distribution, and a top-10 leaderboard of the most agent-ready sites. This aggregate, cross-domain view is exactly what a single-site scanner cannot give you. Free, no auth.', {}, async () => {
+    const d = await fetchJSON('/agent-ready/summary.json');
+    const a = d.adoption_pct;
+    const lb = (d.leaderboard || []).slice(0, 10).map((e, i) => `${i + 1}. ${e.domain} (${e.score}, ${e.tier})`).join('\n');
+    const text = `Agentic web readiness, ${d.profiled}/${d.domains_tracked} domains profiled (captured ${d.captured_at ?? 'n/a'}):\n` +
+        `Surface adoption: x402 ${a.x402}%, agent.json ${a.agentJson}%, openapi ${a.openapi}%, llms.txt ${a.llmsTxt}%, crawlable ${a.crawlable}%, ai.txt ${a.aiTxt}%\n` +
+        `Tiers: ${Object.entries(d.tier_distribution || {}).map(([t, n]) => `${t} ${n}`).join(', ')}\n` +
+        `Most agent-ready:\n${lb}`;
+    return { content: [{ type: 'text', text }] };
+});
+// Tool: check_crawler_access
+registerTool('check_crawler_access', 'Check which AI bots a website allows or blocks in its robots.txt: GPTBot, ClaudeBot, PerplexityBot, CCBot, Google-Extended, Bytespider, and more, with a per-bot verdict (allowed, blocked, partial, or unknown), plus whether the site publishes llms.txt and ai.txt. Reports the site\'s stated policy, not enforcement (robots.txt compliance is voluntary). Free, no auth.', {
+    domain: z.string().describe('Bare domain to check, e.g. "nytimes.com" (no scheme, no path)'),
+}, async ({ domain }) => {
+    const data = await fetchJSON(`/ai-crawler-access/site?domain=${encodeURIComponent(domain)}`);
+    if (!data.found || !data.record) {
+        return { content: [{ type: 'text', text: `${data.domain} is not in TensorFeed's tracked set yet. About 500 curated domains are tracked for AI-crawler access.` }] };
+    }
+    const rec = data.record;
+    const bots = Object.entries(rec.bots).map(([b, v]) => `  ${b}: ${v}`).join('\n');
+    const text = `${data.domain} (robots.txt HTTP ${rec.robotsStatus ?? 'n/a'}) AI-bot access:\n${bots}\n` +
+        `llms.txt: ${rec.hasLlmsTxt ? 'yes' : 'no'}, ai.txt: ${rec.hasAiTxt ? 'yes' : 'no'}\n` +
+        `Stated policy only; compliance is voluntary. Last checked: ${data.captured_at ?? 'n/a'}`;
+    return { content: [{ type: 'text', text }] };
+});
+// Tool: crawler_access_summary
+registerTool('crawler_access_summary', 'Get the aggregate AI-crawler access map across about 500 curated domains: the percentage of sites that block each AI bot (the publisher-versus-AI-crawler picture), plus llms.txt and ai.txt adoption rates. Unlike a single-site robots.txt checker, this is the cross-domain trend view of who is shutting AI crawlers out. Free, no auth.', {}, async () => {
+    const d = await fetchJSON('/ai-crawler-access/summary.json');
+    const blocked = Object.entries(d.bot_blocked_pct || {})
+        .sort((x, y) => y[1] - x[1])
+        .slice(0, 8)
+        .map(([b, p]) => `  ${b}: ${p}% blocked`)
+        .join('\n');
+    const text = `AI-crawler access across ${d.domains_with_data}/${d.domains_tracked} tracked domains (captured ${d.captured_at ?? 'n/a'}):\n` +
+        `Most-blocked AI bots:\n${blocked}\n` +
+        `llms.txt adoption: ${d.llms_txt_adoption_pct}%, ai.txt adoption: ${d.ai_txt_adoption_pct}%`;
+    return { content: [{ type: 'text', text }] };
+});
 // ── Tool: get_model_pricing ─────────────────────────────────────────
 registerTool('get_model_pricing', 'Get AI model pricing comparison across all major providers (Anthropic, OpenAI, Google, Meta, Mistral, Cohere). Prices per 1M tokens.', {}, async () => {
     const data = await fetchJSON('/models');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensorfeed/mcp-server",
-  "version": "1.36.3",
+  "version": "1.37.0",
   "mcpName": "ai.tensorfeed/mcp-server",
   "description": "MCP server for TensorFeed.ai - AI news, status, model data, and premium endpoints (routing, cost projection, forecast, history series, news search, webhook watches with digest tier, enriched directory) for AI agents",
   "main": "dist/index.js",

package/server.json

@@ -3,7 +3,7 @@
   "name": "ai.tensorfeed/mcp-server",
   "title": "TensorFeed",
   "description": "AI news, model pricing, service status, and machine-payable premium tools. AFTA-certified.",
-  "version": "1.36.3",
+  "version": "1.37.0",
   "websiteUrl": "https://tensorfeed.ai/developers/agent-payments",
   "repository": {
     "url": "https://github.com/RipperMercs/tensorfeed-mcp",
@@ -20,7 +20,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@tensorfeed/mcp-server",
-      "version": "1.36.3",
+      "version": "1.37.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"