cito-mcp 0.4.4 → 0.4.6

package/dist/tools/match.js

@@ -1,24 +1,10 @@
-/**
- * match_summary + match_details
- */
 import { extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, unwrapPayload, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
 import { normalizeMatch, normalizeUfcMethod, presentSides, tennisSetCompleted } from './normalize.js';
-// summarizeTennisOdds was used here for the tennis odds section. Tennis odds were
-// withdrawn 2026-09-13 (see docs/tennis-risk-register.md), so this module no
-// longer imports it. The shaper still exists and is still exported from
-// ./odds.js for the day the surface is restored.
 import { boolSchema, gameSchema, isPrimaryGame, parseGame, stringSchema, } from './types.js';
 async function getSection(ctx, path, query) {
     return fetchJson(ctx, path, { query });
 }
-/**
- * Series length. The LoL feed states it as `strategy: "Bo5"`, which nothing was
- * reading, so every match reported bestOf: null. Accept the spelled forms and
- * the object shape other titles use, and fall back to the declared game count.
- * Only 1/3/5/7/9 are real series lengths, so anything else is refused rather
- * than guessed.
- */
 export function parseBestOf(r) {
     const fromNumber = (v) => {
         const n = Number(v);
@@ -36,7 +22,6 @@ export function parseBestOf(r) {
                 return n;
         }
     }
-    // { type: "bestOf", count: 5 }
     if (strat && typeof strat === 'object') {
         const o = strat;
         const n = fromNumber(o.count) ?? fromNumber(o.value) ?? fromNumber(o.bestOf);
@@ -65,11 +50,6 @@ function matchCore(game, matchId, raw) {
     const scoreline = m.team1 || m.team2
         ? `${m.team1?.name ?? '?'} ${s1 ?? '-'} : ${s2 ?? '-'} ${m.team2?.name ?? '?'}`
         : null;
-    /**
-     * Tennis: `score` is the set-by-set game score ("4-6 6-3 6-3 7-5"), which is
-     * a DIFFERENT fact from the sets-won scoreline. "3 : 1" is the result; it
-     * cannot distinguish 6-0 6-0 from three tiebreaks. Both are carried.
-     */
     const scoreDetail = game === 'tennis' ? (pickString(r.score, r.score_raw) ?? null) : null;
     const core = {
         matchId: m.matchId !== 'unknown' ? m.matchId : matchId,
@@ -89,11 +69,6 @@ function matchCore(game, matchId, raw) {
         team2: m.team2,
         event: m.event,
         league: m.league,
-        // method/methodRaw/weightClass/referee are combat-sport vocabulary. They
-        // stayed on every match_summary/match_details card regardless of game, so
-        // a tennis card carried referee:null and weightClass:null — foreign
-        // fields, not merely empty ones. UFC keeps them; every other game omits
-        // the keys entirely rather than shipping them as null.
         ...(game === 'ufc'
             ? {
                 method: normalizeUfcMethod(pickString(r.method, r.resultMethod)) ?? null,
@@ -101,18 +76,13 @@ function matchCore(game, matchId, raw) {
             }
             : {}),
         winner: (() => {
-            // Never name a winner while play is in progress: the score fallback
-            // below reads "who is ahead", which mid-match is a lead, not a result.
             if (m.status === 'live' || m.status === 'upcoming')
                 return null;
-            // UFC rows carry an explicit winner slug/fighter ref; tennis archive
-            // rows nest a winner object.
             const explicit = pickString(r.winnerFighterSlug, r.winnerSlug, r.winner, asRecord(r.winner)?.id);
             if (explicit)
                 return explicit;
             if (game === 'ufc')
                 return null;
-            // CS2 rows expose winnerTeamId instead; map it to a side, else fall back to scores.
             const sideLabel = (side) => side ? pickString(side.slug, side.id, side.name) ?? null : null;
             const winnerTeamId = pickString(r.winnerTeamId, r.winner_team_id);
             if (winnerTeamId) {
@@ -159,8 +129,6 @@ function matchCore(game, matchId, raw) {
             }
             : {}),
         rawStatus: pickString(r.status, r.state) ?? null,
-        // Point-level live state (tennis): current game score like "40-AD", which
-        // side is serving, and the set in progress. Absent for other games.
         ...(game === 'tennis' && (r.game_score || r.server)
             ? {
                 liveState: {
@@ -174,13 +142,6 @@ function matchCore(game, matchId, raw) {
     };
     return core;
 }
-/**
- * Rename team1/team2 -> player1/player2 (top level and the nested score
- * sub-object) for tennis only, at the point a matchCore object leaves this
- * module. Kept separate from matchCore itself so every internal reader
- * (scoreline strings, winner lookup, sideLabel) keeps working against the
- * stable team1/team2 shape; only the client-facing copy is renamed.
- */
 function toClientMatch(core, game) {
     return presentSides({ ...core, score: presentSides(core.score, game) }, game);
 }
@@ -202,18 +163,18 @@ function primaryPath(game, matchId) {
 }
 export const matchSummary = {
     name: 'match_summary',
-    description: `COMPOSITE match card: scoreline, key context, player performances, and VOD/demo links when available.
-
-When to use:
-- Match recap / default match UI
-- After user selects a live or completed matchId
-
-Prefer over match_details for chat answers and default UIs.
-Prefer match_details for timelines, full map trees, live state, advanced packages.
-
-Do not use when: no matchId yet (resolve from live/schedule); pure pre-match → match_preview.
-
-Parallel-safe: yes. Upstream cost: 2–5.
+    description: `COMPOSITE match card: scoreline, key context, player performances, and VOD/demo links when available.
+
+When to use:
+- Match recap / default match UI
+- After user selects a live or completed matchId
+
+Prefer over match_details for chat answers and default UIs.
+Prefer match_details for timelines, full map trees, live state, advanced packages.
+
+Do not use when: no matchId yet (resolve from live/schedule); pure pre-match → match_preview.
+
+Parallel-safe: yes. Upstream cost: 2–5.
 Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includePlayerStats": true }`,
     inputSchema: {
         type: 'object',
@@ -267,15 +228,10 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
         let primary = await getSection(ctx, primaryPath(game, matchId));
         upstreamCalls += 1;
         rateLimit = primary.headers;
-        // Tennis live board hands out s365_* ids that live at /matches/live/{id}
-        // until the match finishes and lands in the archive. Without this fallback
-        // the board gives out ids that match_summary immediately 404s on.
         if (!primary.ok && game === 'tennis' && primary.status === 404) {
             primary = await getSection(ctx, `/tennis/matches/live/${encodeURIComponent(matchId)}`);
             upstreamCalls += 1;
             rateLimit = { ...rateLimit, ...primary.headers };
-            // Finished live matches archive under s365_{year}_{gid} while the live
-            // board handed out s365_{gid} — insert the year before giving up.
             const gid = matchId.match(/^s365_(\d+)$/)?.[1];
             if (!primary.ok && gid) {
                 const year = new Date().getUTCFullYear();
@@ -327,9 +283,6 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
                     upstreamCalls += 1;
                     rateLimit = { ...rateLimit, ...res.headers };
                     if (!res.ok) {
-                        // Live tennis matches have no archive stats row yet, but the live
-                        // detail payload (already fetched as `primary`) carries the full
-                        // per-side stat block — serve that instead of a 404 partial.
                         if (game === 'tennis' && res.status === 404) {
                             const livePayload = asRecord(asRecord(primary.data)?.data) ?? asRecord(primary.data);
                             const liveStats = livePayload?.stats;
@@ -369,25 +322,12 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
                 }
             })());
         }
-        // games/maps
         enrich.push((async () => {
-            // Tennis has no per-set endpoint of its own; the set-by-set score is
-            // already sitting in `primary` (the same payload matchCore built the
-            // scoreline from). Pulling it out here means match_summary keeps the
-            // set breakdown instead of shipping gamesOrMaps: [] next to a fully
-            // populated `sets` array one field over.
             if (game === 'tennis') {
                 const payload = asRecord(asRecord(primary.data)?.data) ?? asRecord(primary.data);
                 const sets = Array.isArray(payload?.sets) ? payload.sets : [];
                 gamesOrMaps = sets.map((s) => {
                     const sr = asRecord(s) ?? {};
-                    // The live route (/tennis/matches/live/{id}) spells this set_num +
-                    // score + is_completed; the archive route (/tennis/matches/{id})
-                    // spells the same set set_number, with no per-set score string
-                    // (the match-level `score` already holds "6-4, 6-4, 2-1") and no
-                    // completion flag. Read both spellings rather than nulling out
-                    // real data because match_summary happened to resolve the other
-                    // route this time.
                     const p1g = typeof sr.player1_games === 'number' ? sr.player1_games : null;
                     const p2g = typeof sr.player2_games === 'number' ? sr.player2_games : null;
                     return {
@@ -396,9 +336,6 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
                         player1Games: p1g,
                         player2Games: p2g,
                         tiebreak: sr.tiebreak ?? null,
-                        // is_completed is a LIVE-route field. The archive route omits it,
-                        // so every set of a finished match read completed:false. Fall
-                        // back to the games, which always decide whether a set is over.
                         completed: tennisSetCompleted(sr),
                     };
                 });
@@ -459,28 +396,7 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
         });
     },
 };
-/**
- * Fold a UFC bout's raw odds payload into something an agent can read.
- *
- * The REST response is deliberately complete: every bookmaker, every market, up
- * to roughly 950 outcomes for a single bout. Handing that back whole would bury
- * the two numbers a caller almost always wants, and the server's own
- * instructions say not to flood odds. So the moneyline is summarised per fighter
- * and every other market is reduced to a count, with the raw endpoint named so
- * anyone who genuinely needs the full book can go and get it.
- *
- * isAvailable is carried through as currentlyOffered rather than filtered on. It
- * means "a book is offering this right now", so a finished fight's closing line
- * comes back with it false, and that is information rather than absence.
- * Filtering here would recreate the bug where whole settled cards looked like
- * they had no odds at all.
- */
 export function summarizeUfcOdds(data) {
-    // fetchJson hands back the whole REST envelope ({ success, data, meta }), not
-    // the inner payload, so unwrap one level when it is there. Accepting both
-    // shapes because the unit tests feed the inner object directly; reading only
-    // the outer one returned a perfectly shaped, perfectly empty summary, which
-    // looked like "this bout has no odds" rather than like a bug.
     const root = (data ?? {});
     const payload = (root.data && typeof root.data === 'object' && !Array.isArray(root.data)
         ? root.data
@@ -523,9 +439,6 @@ export function summarizeUfcOdds(data) {
             otherMarkets.set(type, other);
         }
     }
-    // American odds: the best price is the highest number both for an underdog
-    // (+250 beats +180) and for a favourite (-110 beats -200), so it is simply the
-    // maximum in both cases.
     const moneyline = [...byFighter.values()].map((entry) => {
         const sorted = [...entry.prices].sort((a, b) => a - b);
         const mid = sorted.length
@@ -555,33 +468,12 @@ export function summarizeUfcOdds(data) {
         fullBookPath: '/ufc/bouts/{boutId}/odds',
     };
 }
-/**
- * Per-period ("ALL / 1ST / 2ND / 3RD") statistics.
- *
- * The REST route gained `set_stats`: the same serving/returning figures split by
- * set. Every field is nullable and a null is a STATEMENT, not a zero -- 0 aces is
- * a claim, "we do not know" is not. `missing` names the nulls per side and `gaps`
- * says why each one is absent, so a caller can tell these three apart:
- *   PERIOD_NO_STATS          no stats exist for that period at all
- *   INCOMPLETE_PERIOD_STATS  the period exists but a field is unknown
- *   SOURCE_UNAVAILABLE / SOURCE_NOT_MAPPED
- *                            a source was consulted and did not deliver
- * Collapsing any of that into zero, or dropping `gaps`, would delete the very
- * information that makes the block trustworthy.
- */
 export function summarizeTennisSetStats(block) {
     const b = asRecord(block);
     if (!b)
         return null;
     const arr = (v) => (Array.isArray(v) ? v : []);
     const strings = (v) => arr(v).map(String);
-    /**
-     * An object carrying nothing at all is not a block: the API sends
-     * `set_stats: null` when it has no rows, so `{}` can only be a caller's stub,
-     * and `setStats: null` says "no information" more honestly than a block of
-     * empty arrays. A block with ONLY gaps is kept, because the gaps are the
-     * information.
-     */
     if (!arr(b.periods).length && !arr(b.gaps).length && !arr(b.sources).length
         && typeof b.note !== 'string') {
         return null;
@@ -645,11 +537,6 @@ export function summarizeTennisSetStats(block) {
         note: str(b.note),
     };
 }
-/**
- * One line per stated absence, for the envelope's meta.warnings. The gaps also
- * ride inside the section; this is what makes them visible to a client that only
- * reads the envelope.
- */
 export function tennisSetStatsWarnings(block) {
     const shaped = summarizeTennisSetStats(block);
     if (!shaped)
@@ -660,28 +547,11 @@ export function tennisSetStatsWarnings(block) {
         const where = [gap.period, gap.side].filter(Boolean).join(' ');
         out.push(`set_stats ${gap.code}${where ? ` (${where})` : ''}: ${gap.message}`);
     }
-    // One warning per distinct code is enough for a client that only needs to know
-    // the block is not fully populated; the section carries the detail.
     const note = shaped.note;
     if (gaps.length && typeof note === 'string')
         out.unshift(`set_stats: ${note}`);
     return out.slice(0, 6);
 }
-/**
- * Tennis per-match stats projection.
- *
- * `/tennis/matches/{id}/stats` does NOT return a row per player the way every
- * other game's player-stats route does. It returns
- * `{ stats: { winner: {...}, loser: {...} }, sets: [...], score, set_stats }` —
- * two objects keyed by OUTCOME. `match_details sections:["playerStats"]` had no
- * tennis arm at all, so it answered `playerStats: null` while `match_summary`
- * was filling `playerPerformances` from the same route.
- *
- * The sides stay keyed by outcome rather than being mislabelled as player1 /
- * player2, because the payload carries no names and the ordering is not
- * guaranteed to match the base row. `match.player1.is_winner` on the base
- * section is what maps a name onto these numbers, and `sidesKeyedBy` says so.
- */
 export function summarizeTennisMatchStats(data) {
     const root = asRecord(data) ?? {};
     const payload = asRecord(root.data) ?? root;
@@ -710,31 +580,29 @@ export function summarizeTennisMatchStats(data) {
                 completed: tennisSetCompleted(sr),
             };
         }),
-        // ALL / 1ST / 2ND / 3RD ... Null when the API has no per-period rows for
-        // this match, which is a different statement from an ingested empty period.
         setStats: summarizeTennisSetStats(payload.set_stats),
         rawPath: '/tennis/matches/{matchId}/stats',
     };
 }
 export const matchDetails = {
     name: 'match_details',
-    description: `Deep match package: optional timelines, advanced stats, live state/snapshots, full map/game tree, media inventory.
-
-When to use:
-- Analyst deep dive
-- Live in-game window (LoL/CS2/UFC)
-- Full demo list
-
-Prefer over match_summary only when summary is insufficient.
-Prefer match_summary for short answers and default cards.
-
-Do not use when: first-pass live board (use live_matches + match_summary).
-
-Section selection: pass includeTimeline / includeLiveState / includeAdvanced booleans, OR an explicit sections[] list.
-UFC betting lines: sections:["odds"] (opt-in, never in the default set).
-If sections[] is non-empty it wins (booleans are ignored). LoL liveState/advanced require gameId.
-
-Parallel-safe: yes. Upstream cost: 1–8 (section-gated).
+    description: `Deep match package: optional timelines, advanced stats, live state/snapshots, full map/game tree, media inventory.
+
+When to use:
+- Analyst deep dive
+- Live in-game window (LoL/CS2/UFC)
+- Full demo list
+
+Prefer over match_summary only when summary is insufficient.
+Prefer match_summary for short answers and default cards.
+
+Do not use when: first-pass live board (use live_matches + match_summary).
+
+Section selection: pass includeTimeline / includeLiveState / includeAdvanced booleans, OR an explicit sections[] list.
+UFC betting lines: sections:["odds"] (opt-in, never in the default set).
+If sections[] is non-empty it wins (booleans are ignored). LoL liveState/advanced require gameId.
+
+Parallel-safe: yes. Upstream cost: 1–8 (section-gated).
 Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "includeLiveState": false }`,
     inputSchema: {
         type: 'object',
@@ -810,19 +678,11 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             media: null,
             advanced: null,
         };
-        // base is ALWAYS fetched, whatever sections were asked for. Requesting
-        // sections:["timeline"] returned match:null, so a caller got a timeline with
-        // nothing to attach it to and no way to tell which match it belonged to.
-        // The header is the identity of the response, not an optional section.
         wanted.add('base');
         if (wanted.has('base')) {
             let res = await getSection(ctx, primaryPath(game, matchId));
             upstreamCalls += 1;
             rateLimit = res.headers;
-            // Same fallback match_summary already has: the live board hands out
-            // s365_* ids that only resolve at /matches/live/{id} until the match
-            // finishes and archives. Without this, a matchId taken straight off
-            // live_matches 404s here even though match_summary resolves it fine.
             if (!res.ok && game === 'tennis' && res.status === 404) {
                 res = await getSection(ctx, `/tennis/matches/live/${encodeURIComponent(matchId)}`);
                 upstreamCalls += 1;
@@ -869,10 +729,6 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 }
             })());
         };
-        // Same as load(), but folds the payload through a shaper first. Raw odds are
-        // far too big to hand back whole: one bout carries up to ~950 outcomes across
-        // every bookmaker and prop market, which would bury the answer it was fetched
-        // to give.
         const loadWith = (section, path, shape, query) => {
             tasks.push((async () => {
                 const res = await getSection(ctx, path, query);
@@ -902,8 +758,6 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 load('playerStats', `/cod/matches/${encodeURIComponent(matchId)}/player-stats`);
             if (game === 'ufc')
                 load('playerStats', `/ufc/bouts/${encodeURIComponent(matchId)}/stats`);
-            // Tennis has a real per-match stats route; the section simply had no arm
-            // for it and shipped playerStats:null forever.
             if (game === 'tennis') {
                 loadWith('playerStats', `/tennis/matches/${encodeURIComponent(matchId)}/stats`, summarizeTennisMatchStats);
             }
@@ -916,7 +770,6 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             if (game === 'ufc')
                 load('gamesOrMaps', `/ufc/bouts/${encodeURIComponent(matchId)}/rounds`);
             if (game === 'cs2' || game === 'dota2') {
-                // no dedicated maps list — leave null with note via partial only if requested alone
                 sections.gamesOrMaps = sections.base;
             }
         }
@@ -954,11 +807,6 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 loadWith('odds', `/ufc/bouts/${encodeURIComponent(matchId)}/odds`, summarizeUfcOdds);
             }
             else {
-                // Tennis odds were REMOVED 2026-09-13 alongside the /tennis/odds/* routes.
-                // Betting data concentrates the legal risk and is the subject of every
-                // significant dispute researched (see docs/tennis-risk-register.md), so
-                // it is no longer offered. Requesting the section is now an explicit
-                // NOT_IMPLEMENTED rather than a call to a route that returns 404.
                 partial.push(partialFromRejection('odds', {
                     code: 'NOT_IMPLEMENTED',
                     message: `Odds are not curated for ${game}. Currently available: UFC (/ufc/bouts/{id}/odds). Tennis odds were withdrawn.`,
@@ -988,9 +836,6 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             }
         }
         await Promise.all(tasks);
-        // Per-period coverage gaps ride in meta.warnings as well as inside the
-        // playerStats section, so a client that only reads the envelope still learns
-        // that the ALL / 1ST / 2ND / 3RD block is not fully populated and why.
         const warnings = [];
         if (game === 'tennis') {
             const ps = asRecord(sections.playerStats);

package/dist/tools/meta.js

@@ -1,6 +1,3 @@
-/**
- * Meta / power tools: list_capabilities, api_health, call_api.
- */
 import { extractRows, fetchJson, gameNotIncludedHint, present } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, successEnvelope, } from '../envelope.js';
 import { boolSchema, gameSchema, parseGame, PRIMARY_GAMES, stringSchema, } from './types.js';
@@ -368,7 +365,7 @@ const TOOL_CATALOG = [
         parallelSafe: true,
         games: ['cs2'],
         jobs: ['team_page', 'preview'],
-        exampleArgs: { teamId: 'hltv-team-4608', days: 90 },
+        exampleArgs: { teamId: 'cs2-team-4608', days: 90 },
         preferOver: ['manual match history scraping'],
         doNotUse: 'For non-CS2 games',
     },
@@ -433,8 +430,6 @@ const JOBS = [
     { id: 'schedule', description: 'Upcoming fixtures/events', recommendedTools: ['upcoming_schedule', 'event_card'] },
     { id: 'preview', description: 'Pre-match briefing', recommendedTools: ['match_preview'] },
     { id: 'event_card', description: 'Event / fight-night card page', recommendedTools: ['event_card', 'resolve_entity', 'match_preview'] },
-    // Agents asked "does this API have photos?" and, finding no job for it,
-    // assumed no. Photos ship on every UFC corner and profile; make that findable.
     {
         id: 'media',
         description: 'Headshots, full-body shots and team logos for visual UIs. UFC fighters carry headshotUrl / bodyImageUrl / imageUrl plus a CORS-safe proxiedImageUrl; use the proxied URL in a browser. Available on event_card corners and player_profile without any extra call.',
@@ -643,7 +638,6 @@ Example: { "includeGameProbes": true }`,
                 });
             }
             else {
-                // try product root
                 const cs2 = await fetchJson(ctx, '/cs2');
                 upstreamCalls += 1;
                 rateLimit = cs2.headers;
@@ -660,11 +654,10 @@ Example: { "includeGameProbes": true }`,
             }
         }
         else {
-            // health may be unauthenticated — confirm key with light authed probe
             const probe = await fetchJson(ctx, '/lol/leagues');
             upstreamCalls += 1;
             rateLimit = { ...rateLimit, ...probe.headers };
-            keyValid = probe.ok || probe.status === 403; // 403 may still mean key accepted but gated
+            keyValid = probe.ok || probe.status === 403;
             if (probe.ok)
                 answeredBy = '/health+/lol/leagues';
             if (probe.status === 401) {
@@ -693,10 +686,8 @@ Example: { "includeGameProbes": true }`,
                 if (res.ok)
                     includedGames.push(game);
                 else if (res.status === 403 && gameNotIncludedHint(res.data)) {
-                    // not included
                 }
                 else if (res.status !== 401 && res.status !== 404) {
-                    // ambiguous — still list as probed
                 }
                 rateLimit = { ...rateLimit, ...res.headers };
             }
@@ -733,8 +724,6 @@ const ALLOWLIST_PREFIXES = [
     '/ufc',
     '/fortnite',
     '/tennis',
-    // The spec describes the surface call_api is allowed to reach; refusing to
-    // serve it left route discovery impossible except by guessing.
     '/openapi.json',
 ];
 function pathAllowed(path) {
@@ -770,9 +759,9 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
         properties: {
             method: {
                 type: 'string',
-                enum: ['GET', 'POST'],
+                enum: ['GET'],
                 default: 'GET',
-                description: 'HTTP method. Prefer GET. Example: "GET".',
+                description: 'HTTP method. GET only: call_api is read-only. Example: "GET".',
             },
             path: stringSchema('Path starting with /. Allowlisted prefixes only. Example: "/cs2/rankings/teams".', '/cs2/rankings/teams'),
             queryJson: {
@@ -784,10 +773,6 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
                 type: 'object',
                 description: 'Query params as a plain object (alternative to queryJson). Example: {"year":2026}.',
             },
-            bodyJson: {
-                type: 'string',
-                description: 'Stringified JSON body for POST only (rare).',
-            },
         },
     },
     handler: async (args, ctx) => {
@@ -805,10 +790,10 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
                 tookMs: Date.now() - started,
             });
         }
-        if (method !== 'GET' && method !== 'POST') {
+        if (method !== 'GET') {
             return errorEnvelope({
                 code: 'VALIDATION',
-                message: 'method must be GET or POST',
+                message: 'method must be GET; call_api is read-only',
                 game: null,
                 source: 'call_api',
                 requestId,
@@ -827,8 +812,6 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
             });
         }
         let query = {};
-        // Agents pass query as a plain object at least as often as the stringified
-        // queryJson form; silently dropping it produced confusing upstream 422s.
         if (args.query && typeof args.query === 'object' && !Array.isArray(args.query)) {
             query = { ...args.query };
         }
@@ -851,23 +834,7 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
                 });
             }
         }
-        let body;
-        if (method === 'POST' && typeof args.bodyJson === 'string' && args.bodyJson.trim()) {
-            try {
-                body = JSON.parse(args.bodyJson);
-            }
-            catch (e) {
-                return errorEnvelope({
-                    code: 'VALIDATION',
-                    message: `Invalid bodyJson: ${e.message}`,
-                    game: null,
-                    source: 'call_api',
-                    requestId,
-                    tookMs: Date.now() - started,
-                });
-            }
-        }
-        const res = await fetchJson(ctx, path, { method, query, body });
+        const res = await fetchJson(ctx, path, { method, query, raw: true });
         if (!res.ok) {
             return errorEnvelope({
                 code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
@@ -899,14 +866,6 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
         });
     },
 };
-/**
- * Games whose routes the published spec does not describe.
- *
- * The spec has 123 paths and zero under /lol, yet every LoL route works —
- * api_health itself answers partly from /lol/leagues. An agent that treats the
- * spec as the whole surface concludes LoL is unsupported and stops, so say so
- * explicitly rather than returning an empty list that reads as a verdict.
- */
 const SPEC_OMITS = {
     tennis: 'The published OpenAPI spec documents no /tennis paths, but tennis routes exist and work (players, matches, h2h, rankings, tournaments, live). Use the curated tools with game tennis, or call_api with /tennis/* paths.',
     lol: 'The published OpenAPI spec documents no /lol paths, but LoL routes exist and work. Use the curated LoL tools (live_matches, upcoming_schedule, team_profile, standings, player_profile); for raw access, /lol/* is allowlisted for call_api even though it is undocumented.',
@@ -949,9 +908,6 @@ Example: { "game": "ufc", "q": "rankings" }`,
     handler: async (args, ctx) => {
         const started = Date.now();
         const requestId = newRequestId();
-        // Accept fortnite here even though it is not a PRIMARY_GAME: it has 21
-        // documented paths and no curated tools, so it is exactly what call_api
-        // callers come looking for.
         const gameRaw = typeof args.game === 'string' ? args.game.toLowerCase().trim() : '';
         if (gameRaw && !gameRaw.match(/^(lol|cs2|dota2|cod|ufc|fortnite|tennis)$/)) {
             return errorEnvelope({
@@ -1042,5 +998,4 @@ Example: { "game": "ufc", "q": "rankings" }`,
     },
 };
 export const metaTools = [listCapabilities, apiHealth, listRoutes, callApi];
-// silence unused import in case extractRows needed later
 void extractRows;