@tensorfeed/mcp-server 1.13.0 → 1.21.0

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 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.21.0 - 2026-05-04
+
+### Added
+- Three free history-series tools: `pricing_series_free`, `benchmark_series_free`, `status_uptime_free`. Each returns up to 7 days of daily snapshots (price/score/uptime) for one model or provider. Max range capped at 7 days; for the full 90-day window keep using the paid `pricing_series`, `benchmark_series`, `status_uptime` tools (1 credit each). Reason for the split: agents discovering the data need a free way to see "yes, TensorFeed actually has historical pricing for this model" before deciding to spend a credit. The 7-day teaser shows the trend without giving away the long tail.
+
+## 1.20.0 - 2026-05-04
+
+### Changed
+- `get_ai_ecosystem_today` now calls the new `/api/today` worker endpoint (single fetch) instead of fanning out 9 individual fetches client-side. Behavior is unchanged from the agent's perspective: same args, same text-rendered output. The win is that the worker's edge cache absorbs the load: a thousand agents calling `get_ai_ecosystem_today` per minute now hit the worker once for 5 minutes (cache TTL) instead of 9000 times. Net cost on the worker stays constant.
+
+## 1.19.0 - 2026-05-04
+
+### Added
+- `get_ai_ecosystem_today` tool. One-shot composite AI morning brief that internally fans out across 9 free TensorFeed endpoints in parallel (news, 3 paper feeds, HF models/datasets/Spaces, hot GitHub issues, Reddit threads, OpenRouter catalog summary, provider status) and returns a single synthesized text response. Optional `sections` arg (any subset of news / papers / hf / community / inference / status) and `limit_per_section` arg. Graceful degradation: any one feed failing just drops its section. Designed for agents that want a fast snapshot without 8 separate tool calls. Free.
+
+## 1.18.0 - 2026-05-04
+
+### Added
+- `get_hf_daily_papers` tool. Hugging Face Daily Papers (editor-curated AI/ML papers with community upvotes and discussion counts). Different signal from `get_arxiv_recent` and `get_ai_papers_trending`. Optional `limit` arg. Free.
+
+## 1.17.0 - 2026-05-04
+
+### Added
+- `get_openrouter_models` tool. OpenRouter cross-provider model catalog (200+ models across 50+ inference providers) with comparable per-token pricing, context window, modality, and provider metadata. Optional `namespace` filter, `free_only` flag for free-tier models, `cheapest` sort by ascending input price, and `limit` for the rendered list. Companion to `get_model_pricing` (curated frontier-lab catalog) by surfacing the long tail of OSS models on cloud inference. Free.
+
+## 1.16.0 - 2026-05-04
+
+### Added
+- `get_reddit_trending` tool. Currently-hot threads from 7 AI-relevant subreddits (LocalLLaMA, MachineLearning, ClaudeAI, OpenAI, singularity, artificial, AI_Agents), ranked by score, top 30. Optional `subreddit` arg to filter to one sub, optional `limit` for the rendered list. Companion to `get_hot_issues`: GitHub developer conversation vs Reddit community conversation. Titles pass through the worker's prompt-injection sanitizer at capture time. Free.
+
+## 1.15.0 - 2026-05-04
+
+### Changed
+- `get_hf_trending` tool now covers Hugging Face Spaces in addition to models and datasets. Spaces are ranked by likes (the right signal for hosted apps where downloads is meaningless) and the rendered entry shows id, sdk, likes, runtime stage when available, and hardware tier when available. New `section` enum values: `'spaces'` (just spaces), `'all'` (all three sections, the new default). `'both'` continues to mean models+datasets for backward compat. Output also surfaces top Space SDKs (gradio / streamlit / docker / static) in the header.
+
+## 1.14.0 - 2026-05-04
+
+### Added
+- `get_hot_issues` tool. Currently-hot GitHub issues across the AI ecosystem, ranked by comment count. Five fan-out search queries on AI topics (llm, ai-agents, large-language-models, machine-learning, transformer), filtered to is:issue is:open archived:false comments>=10 with activity in the last 7 days, deduped, top 30. Optional `limit` arg for the rendered list. Free.
+
+Companion to `get_trending_repos`: that surfaces repos gaining stars, this surfaces repos where the active conversations are happening.
+
 ## 1.13.0 - 2026-05-04
 
 ### Added

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { sanitizeToolResponse } from './sanitize.js';
 const API_BASE = 'https://tensorfeed.ai/api';
-const SDK_VERSION = '1.9.0';
+const SDK_VERSION = '1.10.0';
 async function fetchJSON(path, opts = {}) {
     const headers = {
         'User-Agent': `TensorFeed-MCP/${SDK_VERSION}`,
@@ -235,6 +235,69 @@ registerTool('premium_routing', 'Get a ranked list of recommended AI models for
         : '';
     return { content: [{ type: 'text', text: `Routing for "${data.task}":\n\n${list}${billing}` }] };
 });
+// ── Tool: pricing_series_free (free, 7-day cap) ─────────────────────
+registerTool('pricing_series_free', 'Daily price points for one AI model over the last 1 to 7 days, free. For windows up to 90 days use pricing_series (1 credit).', {
+    model: z.string().describe('Model id or display name (e.g. "Claude Opus 4.7" or "claude-opus-4-7")'),
+    days: z.number().min(1).max(7).optional().describe('Rolling window length 1 to 7 days (default 7)'),
+}, async ({ model, days }) => {
+    const params = new URLSearchParams({ model });
+    if (typeof days === 'number')
+        params.set('days', String(days));
+    const data = (await fetchJSON(`/history/pricing/series?${params}`));
+    const s = data.summary;
+    const summary = s.first && s.latest
+        ? `${s.first.date} blended $${s.first.blended} -> ${s.latest.date} blended $${s.latest.blended} (${s.delta_pct_blended}%, min $${s.min_blended}, max $${s.max_blended})`
+        : 'no data points in range';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${data.model} (${data.provider ?? 'unknown'}) ${data.points.length} points over ${data.points.length} days\n${summary}\nFor up to 90 days, use the pricing_series tool (1 credit).`,
+            },
+        ],
+    };
+});
+// ── Tool: benchmark_series_free (free, 7-day cap) ───────────────────
+registerTool('benchmark_series_free', 'Daily benchmark scores for one model+benchmark over the last 1 to 7 days, free. Benchmark keys: swe_bench, mmlu_pro, gpqa_diamond, math, human_eval. For windows up to 90 days use benchmark_series (1 credit).', {
+    model: z.string().describe('Model id or display name'),
+    benchmark: z.string().describe('Benchmark key'),
+    days: z.number().min(1).max(7).optional().describe('Rolling window length 1 to 7 days (default 7)'),
+}, async ({ model, benchmark, days }) => {
+    const params = new URLSearchParams({ model, benchmark });
+    if (typeof days === 'number')
+        params.set('days', String(days));
+    const data = (await fetchJSON(`/history/benchmarks/series?${params}`));
+    const s = data.summary;
+    const summary = s.first && s.latest
+        ? `${s.first.date} score ${s.first.score} -> ${s.latest.date} score ${s.latest.score} (delta ${s.delta_pp} pp)`
+        : 'no data in range';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${data.model} on ${data.benchmark}: ${data.points.length} points\n${summary}`,
+            },
+        ],
+    };
+});
+// ── Tool: status_uptime_free (free, 7-day cap) ──────────────────────
+registerTool('status_uptime_free', 'Daily uptime rollup for one provider over the last 1 to 7 days, free. For windows up to 90 days use status_uptime (1 credit).', {
+    provider: z.string().describe('Provider name (e.g. anthropic, openai, google)'),
+    days: z.number().min(1).max(7).optional().describe('Rolling window length 1 to 7 days (default 7)'),
+}, async ({ provider, days }) => {
+    const params = new URLSearchParams({ provider });
+    if (typeof days === 'number')
+        params.set('days', String(days));
+    const data = (await fetchJSON(`/history/status/uptime?${params}`));
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${data.provider} over ${data.days_total} days: ${data.uptime_pct ?? '?'}% uptime (${data.days_operational} operational, ${data.days_degraded} degraded, ${data.days_down} down)`,
+            },
+        ],
+    };
+});
 // ── Tool: pricing_series (1 credit) ─────────────────────────────────
 registerTool('pricing_series', 'Daily price points for one AI model with min/max/delta summary. Default range = last 30 days, max 90 days. Costs 1 credit.', {
     model: z.string().describe('Model id or display name (e.g. "Claude Opus 4.7" or "claude-opus-4-7")'),
@@ -775,13 +838,13 @@ registerTool('get_arxiv_recent', 'Most recent arXiv submissions in cs.AI / cs.LG
     };
 });
 // ── Tool: get_hf_trending (free) ────────────────────────────────────
-registerTool('get_hf_trending', 'Top 30 most-downloaded models and top 30 most-downloaded datasets on Hugging Face. Captured daily at 12:00 UTC against the public HF API (no auth). Each entry carries id, downloads, likes, pipeline_tag (models), tags, lastModified, private, gated. Use this when an agent wants the current shape of the open model/dataset ecosystem. Once enough daily snapshots accumulate, day-over-day download deltas become a real trending signal. Free, no auth.', {
-    section: z.enum(['models', 'datasets', 'both']).optional().describe('Which to include in the rendered output (default both)'),
+registerTool('get_hf_trending', 'Top Hugging Face models, datasets, and Spaces. Models + datasets ranked by downloads (top 30 each); Spaces ranked by likes (top 30, since downloads is meaningless for hosted apps). Captured daily at 12:00 UTC against the public HF API (no auth). Each model entry carries id, downloads, likes, pipeline_tag, tags, lastModified, private, gated. Each space entry carries id, author, sdk (gradio/streamlit/static/docker), likes, tags, lastModified, private, runtime_stage, hardware. Use this when an agent wants the current shape of the open model + dataset + app ecosystem. Once enough daily snapshots accumulate, day-over-day deltas become a real trending signal. Free, no auth.', {
+    section: z.enum(['models', 'datasets', 'spaces', 'all', 'both']).optional().describe('Which to include in the rendered output (default all). "both" is accepted as alias for "models+datasets" for backward compat.'),
     limit: z.number().min(1).max(30).optional().describe('Max items per section (default 15, max 30)'),
 }, async ({ section, limit }) => {
     const data = (await fetchJSON('/hf/trending'));
     const s = data.snapshot;
-    const sec = section ?? 'both';
+    const sec = section ?? 'all';
     const n = Math.min(limit ?? 15, 30);
     const fmtCount = (x) => x >= 1_000_000 ? `${(x / 1_000_000).toFixed(1)}M` : x >= 1_000 ? `${(x / 1_000).toFixed(1)}K` : String(x);
     const modelLines = s.models.items.slice(0, n).map((m, i) => {
@@ -789,20 +852,298 @@ registerTool('get_hf_trending', 'Top 30 most-downloaded models and top 30 most-d
         return `${i + 1}. ${m.id}${tag}  ${fmtCount(m.downloads)} downloads, ${fmtCount(m.likes)} likes`;
     }).join('\n');
     const datasetLines = s.datasets.items.slice(0, n).map((d, i) => `${i + 1}. ${d.id}  ${fmtCount(d.downloads)} downloads, ${fmtCount(d.likes)} likes`).join('\n');
+    const spaceLines = (s.spaces?.items ?? []).slice(0, n).map((sp, i) => {
+        const sdk = sp.sdk ? ` [${sp.sdk}]` : '';
+        const hw = sp.hardware ? `, hw: ${sp.hardware}` : '';
+        const stage = sp.runtime_stage ? `, ${sp.runtime_stage.toLowerCase()}` : '';
+        return `${i + 1}. ${sp.id}${sdk}  ${fmtCount(sp.likes)} likes${stage}${hw}`;
+    }).join('\n');
     const pipelines = s.summary.top_pipeline_tags.slice(0, 5).map(t => `${t.tag} (${t.count})`).join(', ');
     const namespaces = s.summary.top_namespaces.slice(0, 5).map(n => `${n.namespace} (${n.count})`).join(', ');
-    let text = `Hugging Face top-downloaded. ${s.date}.\n`;
+    const sdks = (s.summary.top_space_sdks ?? []).slice(0, 5).map(t => `${t.sdk} (${t.count})`).join(', ');
+    let text = `Hugging Face top assets. ${s.date}.\n`;
     if (pipelines)
         text += `Top pipeline tags (models): ${pipelines}\n`;
+    if (sdks)
+        text += `Top Space SDKs: ${sdks}\n`;
     if (namespaces)
         text += `Top namespaces: ${namespaces}\n`;
-    if (sec === 'models' || sec === 'both')
-        text += `\nModels:\n${modelLines}\n`;
-    if (sec === 'datasets' || sec === 'both')
-        text += `\nDatasets:\n${datasetLines}\n`;
+    const includeModels = sec === 'models' || sec === 'all' || sec === 'both';
+    const includeDatasets = sec === 'datasets' || sec === 'all' || sec === 'both';
+    const includeSpaces = sec === 'spaces' || sec === 'all';
+    if (includeModels)
+        text += `\nModels (by downloads):\n${modelLines}\n`;
+    if (includeDatasets)
+        text += `\nDatasets (by downloads):\n${datasetLines}\n`;
+    if (includeSpaces)
+        text += `\nSpaces (by likes):\n${spaceLines || '  (none returned)'}\n`;
     text += `\nSource: huggingface.co. Captured ${s.capturedAt}.`;
     return { content: [{ type: 'text', text }] };
 });
+// ── Tool: get_hot_issues (free) ─────────────────────────────────────
+registerTool('get_hot_issues', 'Currently-hot GitHub issues across the AI ecosystem. Five fan-out keyword-phrase searches ("large language model", "AI agent", transformer, "machine learning", LLM) for is:issue is:open archived:false comments>=10 updated within the last 7 days. Deduped by URL, top 30 by comment count. Each issue carries url, repo, number, title, author, state, comments, reactions_total, labels, created_at, updated_at, and matched_topic (the keyword phrase that found it). Refreshed daily at 12:30 UTC. Companion to get_trending_repos: that shows which AI repos are gaining stars, this shows where the active conversations are. Free, no auth.', {
+    limit: z.number().min(1).max(30).optional().describe('Max issues to render (default 15, max 30)'),
+}, async ({ limit }) => {
+    const data = (await fetchJSON('/issues/hot'));
+    const s = data.snapshot;
+    const cap = Math.min(limit ?? 15, s.issues.length);
+    const lines = s.issues.slice(0, cap).map((i, n) => {
+        const meta = `${i.comments} comments, ${i.reactions_total} reactions  [${i.matched_topic}]`;
+        const author = i.author ? ` by ${i.author}` : '';
+        const updated = i.updated_at ? `  updated ${i.updated_at.slice(0, 10)}` : '';
+        return `${n + 1}. ${i.repo}: ${i.title}\n     ${meta}${updated}${author}\n     ${i.url}`;
+    }).join('\n\n');
+    const repos = s.summary.top_repos.slice(0, 5).map(r => `${r.repo} (${r.count})`).join(', ');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Hot AI GitHub issues. ${s.date}, showing ${cap} of ${s.total_issues}.\n` +
+                    `Window: last ${s.recent_window_days} days, comments threshold ${s.comments_threshold}.\n` +
+                    (repos ? `Most-active repos: ${repos}\n\n` : '\n') +
+                    lines +
+                    `\n\nSource: GitHub Search API. Captured ${s.capturedAt}.`,
+            },
+        ],
+    };
+});
+// ── Tool: get_reddit_trending (free) ────────────────────────────────
+registerTool('get_reddit_trending', 'Currently-hot threads in 7 AI-relevant subreddits (LocalLLaMA, MachineLearning, ClaudeAI, OpenAI, singularity, artificial, AI_Agents). Stickied and NSFW posts filtered, deduped by post id, ranked by score, top 30. Each post carries id, subreddit, title, author, score, upvote_ratio, num_comments, permalink, url, created_utc, flair, is_self, is_video. Refreshed daily at 13:00 UTC. Companion to get_hot_issues: that surfaces developer conversation on GitHub, this surfaces community conversation on Reddit. Titles are sanitized at capture time against prompt-injection tokens. Free, no auth.', {
+    subreddit: z.string().optional().describe('Optional filter to a single subreddit name (e.g. "LocalLLaMA"). Case-insensitive. If absent, returns posts from all 7.'),
+    limit: z.number().min(1).max(30).optional().describe('Max posts to render (default 15, max 30)'),
+}, async ({ subreddit, limit }) => {
+    const data = (await fetchJSON('/reddit/trending'));
+    const s = data.snapshot;
+    const subFilter = subreddit?.trim().toLowerCase();
+    const filtered = subFilter
+        ? s.posts.filter(p => p.subreddit.toLowerCase() === subFilter)
+        : s.posts;
+    const cap = Math.min(limit ?? 15, filtered.length);
+    const fmtCount = (x) => x >= 1_000 ? `${(x / 1_000).toFixed(1)}K` : String(x);
+    const lines = filtered.slice(0, cap).map((p, i) => {
+        const author = p.author ? ` by ${p.author}` : '';
+        const flair = p.flair ? ` [${p.flair}]` : '';
+        return `${i + 1}. r/${p.subreddit}: ${p.title}${flair}\n     ${fmtCount(p.score)} pts, ${fmtCount(p.num_comments)} comments${author}\n     ${p.permalink}`;
+    }).join('\n\n');
+    const subs = Object.entries(s.summary.by_subreddit)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([sub, n]) => `r/${sub} (${n})`)
+        .join(', ');
+    let text = `Hot AI Reddit threads. ${s.date}, showing ${cap} of ${filtered.length}`;
+    if (subFilter)
+        text += ` (filtered to r/${subreddit})`;
+    text += '.\n';
+    if (subs && !subFilter)
+        text += `Most-active subreddits: ${subs}\n`;
+    text += '\n' + (lines || '  (no posts)');
+    text += `\n\nSource: reddit.com. Captured ${s.capturedAt}.`;
+    return { content: [{ type: 'text', text }] };
+});
+// ── Tool: get_openrouter_models (free) ──────────────────────────────
+registerTool('get_openrouter_models', 'OpenRouter cross-provider model catalog (200+ models normalized across 50+ inference providers). Each entry has per-token pricing (prompt + completion + image + request), context window, modality (e.g. text+image->text), instruct_type, tokenizer, top provider metadata (max_completion_tokens, moderation flag), and supported_parameters. Use this to find the long tail of OSS models on cloud inference, including the cheapest model for a given workload, the model with the largest context window, or the free-tier set. Pairs with get_model_pricing (curated frontier-lab catalog). Refreshed daily at 14:00 UTC. Free, no auth.', {
+    namespace: z.string().optional().describe('Optional filter to a single provider namespace (e.g. "anthropic", "openai", "meta-llama"). Case-insensitive.'),
+    free_only: z.boolean().optional().describe('If true, return only models with prompt+completion both 0 (free-tier).'),
+    cheapest: z.boolean().optional().describe('If true, sort by cheapest input price ascending. Free-tier models excluded from this sort.'),
+    limit: z.number().min(1).max(50).optional().describe('Max models to render (default 20, max 50)'),
+}, async ({ namespace, free_only, cheapest, limit }) => {
+    const data = (await fetchJSON('/openrouter/models'));
+    const s = data.snapshot;
+    const ns = namespace?.trim().toLowerCase();
+    let list = s.models;
+    if (ns)
+        list = list.filter(m => m.id.toLowerCase().startsWith(ns + '/'));
+    if (free_only)
+        list = list.filter(m => m.pricing.prompt === 0 && m.pricing.completion === 0);
+    if (cheapest) {
+        list = list
+            .filter(m => typeof m.pricing.prompt === 'number' && m.pricing.prompt > 0)
+            .sort((a, b) => (a.pricing.prompt ?? 0) - (b.pricing.prompt ?? 0));
+    }
+    const cap = Math.min(limit ?? 20, list.length);
+    const fmtPrice = (p) => p === null ? '?' : p === 0 ? 'free' : `$${(p * 1_000_000).toFixed(2)}/Mtok`;
+    const fmtCtx = (c) => c === null ? 'unknown' : c >= 1_000_000 ? `${(c / 1_000_000).toFixed(0)}M` : `${(c / 1_000).toFixed(0)}K`;
+    const lines = list.slice(0, cap).map((m, i) => {
+        const modality = m.modality ? ` ${m.modality}` : '';
+        return `${i + 1}. ${m.id}${modality}\n     in ${fmtPrice(m.pricing.prompt)}, out ${fmtPrice(m.pricing.completion)}, ctx ${fmtCtx(m.context_length)}`;
+    }).join('\n\n');
+    const namespaces = s.summary.by_namespace.slice(0, 5).map(n => `${n.namespace} (${n.count})`).join(', ');
+    let header = `OpenRouter catalog. ${s.date}. ${s.total_models} models total, ${list.length} after filters, showing ${cap}.\n`;
+    header += `Top provider namespaces: ${namespaces}\n`;
+    if (s.summary.cheapest_input)
+        header += `Cheapest input (paid): ${s.summary.cheapest_input.id} at $${s.summary.cheapest_input.usd_per_million.toFixed(2)}/Mtok\n`;
+    if (s.summary.largest_context)
+        header += `Largest context: ${s.summary.largest_context.id} at ${fmtCtx(s.summary.largest_context.tokens)} tokens\n`;
+    header += `Free-tier models available: ${s.summary.free_tier_count}\n`;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: header + '\n' + (lines || '  (no models match the filters)') + `\n\nSource: openrouter.ai. Captured ${s.capturedAt}.`,
+            },
+        ],
+    };
+});
+// ── Tool: get_hf_daily_papers (free) ────────────────────────────────
+registerTool('get_hf_daily_papers', 'Hugging Face Daily Papers: editor-curated AI/ML papers from huggingface.co/papers, layered with community upvotes and discussion counts. Different signal from get_arxiv_recent (firehose) and get_ai_papers_trending (citation-ranked all-time): this is editor picks of-the-day with engagement signal. Each paper carries paperId, title, summary, authors, upvotes, num_comments, hf_url, arxiv_url (when applicable), github_repo, github_stars, ai_keywords. Refreshed daily at 14:15 UTC. Titles sanitized at capture time. Free, no auth.', {
+    limit: z.number().min(1).max(30).optional().describe('Max papers to render (default 15, max 30)'),
+}, async ({ limit }) => {
+    const data = (await fetchJSON('/papers/hf-daily'));
+    const s = data.snapshot;
+    const cap = Math.min(limit ?? 15, s.papers.length);
+    const lines = s.papers.slice(0, cap).map((p, i) => {
+        const authors = p.authors.slice(0, 3).join(', ') + (p.authors.length > 3 ? ' et al.' : '');
+        const kw = p.ai_keywords.length > 0 ? `\n     keywords: ${p.ai_keywords.slice(0, 5).join(', ')}` : '';
+        const arxiv = p.arxiv_url ? `\n     arxiv: ${p.arxiv_url}` : '';
+        return `${i + 1}. ${p.title}\n     ${authors}\n     ${p.upvotes} upvotes, ${p.num_comments} comments\n     ${p.hf_url}${arxiv}${kw}`;
+    }).join('\n\n');
+    const kw = s.summary.by_keyword.slice(0, 5).map(k => `${k.keyword} (${k.count})`).join(', ');
+    let text = `HF Daily Papers (editor-curated). ${s.date}, showing ${cap} of ${s.total_papers}.\n`;
+    if (kw)
+        text += `Top keywords: ${kw}\n`;
+    if (s.summary.most_upvoted)
+        text += `Most upvoted: "${s.summary.most_upvoted.title}" (${s.summary.most_upvoted.upvotes})\n`;
+    text += '\n' + lines + `\n\nSource: huggingface.co/papers. Captured ${s.capturedAt}.`;
+    return { content: [{ type: 'text', text }] };
+});
+// ── Tool: get_ai_ecosystem_today (free, composite) ──────────────────
+// Single fetch to /api/today which fans out worker-side. The previous
+// implementation made 9 separate fetches per agent invocation; now
+// the worker's edge cache absorbs the load and serves one cached
+// response to all concurrent agents. Output stays text-rendered
+// (MCP returns text content) but the wire shape is the structured
+// JSON the worker produces.
+registerTool('get_ai_ecosystem_today', 'One-shot composite AI morning brief. Calls /api/today which fans out across all daily TensorFeed feeds (news, 3 paper feeds, HF models/datasets/Spaces, hot GitHub issues, Reddit threads, OpenRouter catalog summary, provider status) and returns a single synthesized text response. Optional sections filter (any subset of news, papers, hf, community, inference, status) and limit_per_section (1-10, default 3). Captured-at timestamps from each underlying snapshot are surfaced so the agent knows recency. Free, no auth.', {
+    sections: z.array(z.enum([
+        'news', 'papers', 'hf', 'community', 'inference', 'status',
+    ])).optional().describe('Which subsections to include (default: all six). "papers" covers all 3 paper feeds; "hf" covers models + datasets + spaces; "community" covers hot GitHub issues + Reddit threads; "inference" is the OpenRouter catalog summary.'),
+    limit_per_section: z.number().min(1).max(10).optional().describe('Max items per subsection (default 3, max 10). The output is intentionally terse so an agent can call this without burning context.'),
+}, async ({ sections, limit_per_section }) => {
+    const params = new URLSearchParams();
+    if (sections && sections.length > 0)
+        params.set('sections', sections.join(','));
+    if (typeof limit_per_section === 'number')
+        params.set('limit', String(limit_per_section));
+    const path = `/today${params.toString() ? `?${params.toString()}` : ''}`;
+    let brief;
+    try {
+        brief = (await fetchJSON(path));
+    }
+    catch (err) {
+        return {
+            content: [{ type: 'text', text: `Failed to fetch /api/today: ${err.message}` }],
+        };
+    }
+    const fmtCount = (x) => x >= 1_000_000 ? `${(x / 1_000_000).toFixed(1)}M`
+        : x >= 1_000 ? `${(x / 1_000).toFixed(1)}K`
+            : String(x);
+    const sectionTexts = [];
+    if (brief.news.available && brief.news.data && brief.news.data.items.length > 0) {
+        const lines = brief.news.data.items.map((a, i) => `  ${i + 1}. ${a.title} (${a.source})\n     ${a.url}`).join('\n');
+        sectionTexts.push(`📰 NEWS\n${lines}`);
+    }
+    if (brief.papers.available && brief.papers.data) {
+        const bits = [];
+        const ai = brief.papers.data.ai_trending;
+        if (ai.available && ai.data && ai.data.items.length > 0) {
+            const lines = ai.data.items.map((p, i) => {
+                const authors = p.authors.slice(0, 2).join(', ') + (p.authors.length > 2 ? ' et al.' : '');
+                const venue = p.venue ? ` ${p.venue}.` : '';
+                return `    ${i + 1}. ${p.title}${venue} ${authors}. ${fmtCount(p.citationCount)} citations`;
+            }).join('\n');
+            bits.push(`  By citation count (Semantic Scholar):\n${lines}`);
+        }
+        const ax = brief.papers.data.arxiv_recent;
+        if (ax.available && ax.data && ax.data.items.length > 0) {
+            const lines = ax.data.items.map((p, i) => {
+                const date = p.publishedAt ? p.publishedAt.slice(0, 10) : '';
+                const authors = p.authors.slice(0, 2).join(', ') + (p.authors.length > 2 ? ' et al.' : '');
+                return `    ${i + 1}. ${p.title} (arXiv:${p.arxivId}, ${date}). ${authors}`;
+            }).join('\n');
+            bits.push(`  Just submitted (arXiv recent):\n${lines}`);
+        }
+        const hd = brief.papers.data.hf_daily;
+        if (hd.available && hd.data && hd.data.items.length > 0) {
+            const lines = hd.data.items.map((p, i) => `    ${i + 1}. ${p.title} (${p.upvotes} upvotes, ${p.num_comments} comments)`).join('\n');
+            bits.push(`  HF editor picks today:\n${lines}`);
+        }
+        if (bits.length > 0)
+            sectionTexts.push(`📄 PAPERS\n${bits.join('\n')}`);
+    }
+    if (brief.hf.available && brief.hf.data) {
+        const bits = [];
+        const { models, datasets, spaces } = brief.hf.data;
+        if (models.length > 0) {
+            bits.push(`  Models (top by downloads):\n` + models.map((x, i) => `    ${i + 1}. ${x.id} (${fmtCount(x.downloads)} downloads)`).join('\n'));
+        }
+        if (datasets.length > 0) {
+            bits.push(`  Datasets (top by downloads):\n` + datasets.map((x, i) => `    ${i + 1}. ${x.id} (${fmtCount(x.downloads)} downloads)`).join('\n'));
+        }
+        if (spaces.length > 0) {
+            bits.push(`  Spaces (top by likes):\n` + spaces.map((x, i) => `    ${i + 1}. ${x.id} (${fmtCount(x.likes)} likes)`).join('\n'));
+        }
+        if (bits.length > 0)
+            sectionTexts.push(`🤗 HUGGING FACE\n${bits.join('\n')}`);
+    }
+    if (brief.community.available && brief.community.data) {
+        const bits = [];
+        const { github_issues, reddit } = brief.community.data;
+        if (github_issues.length > 0) {
+            const lines = github_issues.map((it, i) => `    ${i + 1}. ${it.repo}: ${it.title} (${it.comments} comments)\n       ${it.url}`).join('\n');
+            bits.push(`  GitHub hot issues:\n${lines}`);
+        }
+        if (reddit.length > 0) {
+            const lines = reddit.map((p, i) => `    ${i + 1}. r/${p.subreddit}: ${p.title} (${p.score} pts, ${p.num_comments} comments)\n       ${p.permalink}`).join('\n');
+            bits.push(`  Reddit hot threads:\n${lines}`);
+        }
+        if (bits.length > 0)
+            sectionTexts.push(`💬 COMMUNITY\n${bits.join('\n')}`);
+    }
+    if (brief.inference.available && brief.inference.data) {
+        const d = brief.inference.data;
+        const lines = [];
+        lines.push(`  ${d.total_models} models across providers (OpenRouter)`);
+        if (d.cheapest_input)
+            lines.push(`  Cheapest input: ${d.cheapest_input.id} at $${d.cheapest_input.usd_per_million.toFixed(2)}/Mtok`);
+        if (d.largest_context)
+            lines.push(`  Largest context: ${d.largest_context.id} at ${fmtCount(d.largest_context.tokens)} tokens`);
+        lines.push(`  Free-tier models available: ${d.free_tier_count}`);
+        if (d.top_namespaces.length > 0) {
+            lines.push(`  Top namespaces: ${d.top_namespaces.map(n => `${n.namespace} (${n.count})`).join(', ')}`);
+        }
+        sectionTexts.push(`⚙️  INFERENCE CATALOG\n${lines.join('\n')}`);
+    }
+    if (brief.status.available && brief.status.data) {
+        const d = brief.status.data;
+        if (d.all_operational) {
+            sectionTexts.push(`✓  STATUS: all tracked AI providers operational (${d.service_count} services)`);
+        }
+        else {
+            const lines = d.issues.map(s => `  ${s.name} (${s.provider}): ${s.status.toUpperCase()}`).join('\n');
+            sectionTexts.push(`⚠️  STATUS\n${lines}`);
+        }
+    }
+    if (sectionTexts.length === 0) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'No data available yet. The daily snapshots have not run, or all upstream feeds errored. Try again in a few minutes.',
+                },
+            ],
+        };
+    }
+    const header = `TensorFeed AI ecosystem brief, generated ${brief.generated_at}`;
+    const body = sectionTexts.join('\n\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${header}\n\n${body}\n\nFor any subsection, call the underlying tool directly: get_ai_news, get_ai_papers_trending, get_arxiv_recent, get_hf_daily_papers, get_hf_trending, get_hot_issues, get_reddit_trending, get_openrouter_models, get_ai_status.`,
+            },
+        ],
+    };
+});
 // ── Start ───────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensorfeed/mcp-server",
-  "version": "1.13.0",
+  "version": "1.21.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.13.0",
+  "version": "1.20.0",
   "websiteUrl": "https://tensorfeed.ai/developers/agent-payments",
   "repository": {
     "url": "https://github.com/RipperMercs/tensorfeed-mcp",
@@ -14,7 +14,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "@tensorfeed/mcp-server",
-      "version": "1.13.0",
+      "version": "1.21.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"
@@ -47,7 +47,15 @@
         "probe_latest",
         "get_ai_papers_trending",
         "get_arxiv_recent",
-        "get_hf_trending"
+        "get_hf_trending",
+        "get_hot_issues",
+        "get_reddit_trending",
+        "get_openrouter_models",
+        "get_hf_daily_papers",
+        "get_ai_ecosystem_today",
+        "pricing_series_free",
+        "benchmark_series_free",
+        "status_uptime_free"
       ],
       "premiumTools": [
         "premium_routing",