@tensorfeed/mcp-server 1.12.0 → 1.20.0

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 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.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
+- `get_ai_papers_trending` tool. Daily curated AI/ML research papers ranked by citation count, sourced from Semantic Scholar. Five fan-out queries (LLM, transformer, RLHF, AI agents, diffusion), deduped, top 30. Free.
+- `get_arxiv_recent` tool. Most recent arXiv submissions in cs.AI / cs.LG / cs.CL / cs.CV, top 50 by submission date. Optional `limit` arg for the rendered list. Free.
+- `get_hf_trending` tool. Top 30 most-downloaded models and datasets on Hugging Face. Optional `section` (models / datasets / both) and `limit` args. Free.
+
+All three are backed by the worker endpoints shipped in the same monorepo commit and pass through the 1.12.0 output sanitizer automatically.
+
 ## 1.12.0 - 2026-05-04
 
 ### Added

package/README.md

@@ -17,13 +17,31 @@ cd mcp-server
 npm run build
 npm publish --access public
 
-# 3. Republish to the official MCP registry
+# 3. Republish to the official MCP registry. The script lives at
+#    repo-root/scripts/, not mcp-server/scripts/, so step back up first.
+cd ..
 .\scripts\mcp-publish.ps1
 
-# 4. Mirror the new version to the standalone repo
-#    (manual until we wire it as a release-time GitHub Action)
+# 4. Mirror to the standalone repo - automated. The
+#    .github/workflows/mirror-mcp-server.yml workflow runs on every
+#    push to main that touches mcp-server/. To trigger a manual sync,
+#    go to the Actions tab and run "Mirror MCP server to standalone
+#    repo" via workflow_dispatch.
 ```
 
+### Automated mirror setup (one-time)
+
+The mirror workflow needs a personal access token with `contents: write`
+permission on `RipperMercs/tensorfeed-mcp`. Set it once:
+
+1. Generate a fine-grained PAT at github.com/settings/personal-access-tokens
+   scoped to the standalone repo only, with Repository permissions
+   `Contents: Read and write` and `Metadata: Read-only`.
+2. Add it to this monorepo as a repository secret named
+   `STANDALONE_REPO_TOKEN` (Settings -> Secrets and variables -> Actions).
+3. The workflow will pick it up on the next push to main that changes
+   `mcp-server/**`, or via the manual "Run workflow" button.
+
 ## Quick links
 
 - **User-facing repo (please star):** https://github.com/RipperMercs/tensorfeed-mcp

package/dist/index.js

@@ -724,6 +724,363 @@ registerTool('mcp_registry_series', 'Multi-day series of MCP server registry gro
         ],
     };
 });
+// ── Tool: get_ai_papers_trending (free) ─────────────────────────────
+registerTool('get_ai_papers_trending', 'Daily curated AI/ML research papers ranked by citation count. Sourced from Semantic Scholar across five fan-out queries (large language model, transformer, RLHF, AI agents, diffusion model), deduped by paperId, top 30 returned. Each paper carries title, abstract, authors, year, venue, citation count, arxivId, doi, and fields of study. Refreshed daily at 11:00 UTC. Use this when an agent wants the citation-ranked top of the AI research literature. Free, no auth.', {}, async () => {
+    const data = (await fetchJSON('/papers/ai-trending'));
+    const s = data.snapshot;
+    const lines = s.papers.map((p, i) => {
+        const authors = p.authors.slice(0, 3).join(', ') + (p.authors.length > 3 ? ' et al.' : '');
+        const year = p.year ? ` (${p.year})` : '';
+        const venue = p.venue ? ` ${p.venue}.` : '';
+        const arxiv = p.arxivId ? ` arXiv:${p.arxivId}` : '';
+        const link = p.url ? `\n     ${p.url}` : '';
+        return `${i + 1}. ${p.title}${year}\n     ${authors}.${venue} Citations: ${p.citationCount}.${arxiv}${link}`;
+    }).join('\n\n');
+    const venues = s.summary.top_venues.slice(0, 5).map(v => `${v.venue} (${v.count})`).join(', ');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `AI Papers, citation-ranked. ${s.date}, ${s.total_papers} papers.\n` +
+                    (venues ? `Top venues: ${venues}\n\n` : '\n') +
+                    lines +
+                    `\n\nSource: Semantic Scholar Graph API. Captured ${s.capturedAt}.`,
+            },
+        ],
+    };
+});
+// ── Tool: get_arxiv_recent (free) ───────────────────────────────────
+registerTool('get_arxiv_recent', 'Most recent arXiv submissions in cs.AI / cs.LG / cs.CL / cs.CV. Single Atom API call, deduped by arxivId, top 50 by submission date. The firehose pair to get_ai_papers_trending: this shows what just dropped, ai_papers_trending ranks by citation count. Each paper carries arxivId, title, abstract, authors, primary category, publication date, html and pdf URLs. Refreshed daily at 11:30 UTC. Free, no auth.', {
+    limit: z.number().min(1).max(50).optional().describe('Max papers to include in the rendered list (default 25, max 50)'),
+}, async ({ limit }) => {
+    const data = (await fetchJSON('/papers/arxiv-recent'));
+    const s = data.snapshot;
+    const cap = Math.min(limit ?? 25, 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 cat = p.primaryCategory ? ` [${p.primaryCategory}]` : '';
+        const date = p.publishedAt ? ` ${p.publishedAt.slice(0, 10)}` : '';
+        return `${i + 1}. ${p.title}${cat}${date}\n     ${authors}\n     ${p.htmlUrl}`;
+    }).join('\n\n');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `arXiv recent submissions. ${s.date}, showing ${cap} of ${s.total_papers}.\n` +
+                    `Categories: ${s.categories_queried.join(', ')}\n\n` +
+                    lines +
+                    `\n\nSource: arxiv.org. Captured ${s.capturedAt}.`,
+            },
+        ],
+    };
+});
+// ── Tool: get_hf_trending (free) ────────────────────────────────────
+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 ?? '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) => {
+        const tag = m.pipeline_tag ? ` [${m.pipeline_tag}]` : '';
+        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(', ');
+    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`;
+    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.12.0",
+  "version": "1.20.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.12.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.12.0",
+      "version": "1.20.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"
@@ -44,7 +44,15 @@
         "get_ai_today",
         "get_agent_activity",
         "mcp_registry_snapshot",
-        "probe_latest"
+        "probe_latest",
+        "get_ai_papers_trending",
+        "get_arxiv_recent",
+        "get_hf_trending",
+        "get_hot_issues",
+        "get_reddit_trending",
+        "get_openrouter_models",
+        "get_hf_daily_papers",
+        "get_ai_ecosystem_today"
       ],
       "premiumTools": [
         "premium_routing",