cito-mcp 0.4.3 → 0.4.5

package/dist/tools/match.js

@@ -1,21 +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';
-import { summarizeTennisOdds } from './odds.js';
 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);
@@ -33,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);
@@ -62,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,
@@ -86,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,
@@ -98,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) {
@@ -156,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: {
@@ -171,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);
 }
@@ -264,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();
@@ -324,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;
@@ -366,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 {
@@ -393,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),
                     };
                 });
@@ -456,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
@@ -520,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
@@ -552,21 +468,90 @@ export function summarizeUfcOdds(data) {
         fullBookPath: '/ufc/bouts/{boutId}/odds',
     };
 }
-/**
- * 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 }` — 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 summarizeTennisSetStats(block) {
+    const b = asRecord(block);
+    if (!b)
+        return null;
+    const arr = (v) => (Array.isArray(v) ? v : []);
+    const strings = (v) => arr(v).map(String);
+    if (!arr(b.periods).length && !arr(b.gaps).length && !arr(b.sources).length
+        && typeof b.note !== 'string') {
+        return null;
+    }
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    const str = (v) => (typeof v === 'string' ? v : null);
+    const line = (side) => {
+        const s = asRecord(side) ?? {};
+        return {
+            aces: num(s.aces),
+            doubleFaults: num(s.double_faults),
+            firstServePct: num(s.first_serve_pct),
+            firstServeWonPct: num(s.first_serve_win_pct),
+            secondServeWonPct: num(s.second_serve_win_pct),
+            breakPointsSaved: num(s.break_points_saved),
+            breakPointsFaced: num(s.break_points_faced),
+            breakPointsConverted: num(s.break_points_converted),
+            breakPointOpportunities: num(s.break_point_opportunities),
+            totalPointsWon: num(s.total_points_won),
+            servicePointsPlayed: num(s.serve_points),
+            servicePointsWon: num(s.service_points_won),
+            gamesWon: num(s.games_won),
+        };
+    };
+    return {
+        periods: arr(b.periods).map((p) => {
+            const pr = asRecord(p) ?? {};
+            const missing = asRecord(pr.missing) ?? {};
+            return {
+                period: str(pr.period) ?? 'ALL',
+                setNumber: num(pr.set_number) ?? 0,
+                status: str(pr.status) ?? 'partial',
+                sources: strings(pr.sources),
+                winner: line(pr.winner),
+                loser: line(pr.loser),
+                missing: { winner: strings(missing.winner), loser: strings(missing.loser) },
+            };
+        }),
+        sources: arr(b.sources).map((s) => {
+            const sr = asRecord(s) ?? {};
+            return {
+                source: str(sr.source) ?? 'unknown',
+                status: str(sr.status) ?? 'unknown',
+                fields: strings(sr.fields),
+                detail: str(sr.detail),
+            };
+        }),
+        gaps: arr(b.gaps).map((g) => {
+            const gr = asRecord(g) ?? {};
+            return {
+                code: str(gr.code) ?? 'UNKNOWN',
+                period: str(gr.period),
+                setNumber: num(gr.set_number),
+                side: str(gr.side),
+                fields: strings(gr.fields),
+                source: str(gr.source),
+                status: str(gr.status),
+                message: str(gr.message) ?? '',
+            };
+        }),
+        note: str(b.note),
+    };
+}
+export function tennisSetStatsWarnings(block) {
+    const shaped = summarizeTennisSetStats(block);
+    if (!shaped)
+        return [];
+    const gaps = shaped.gaps ?? [];
+    const out = [];
+    for (const gap of gaps) {
+        const where = [gap.period, gap.side].filter(Boolean).join(' ');
+        out.push(`set_stats ${gap.code}${where ? ` (${where})` : ''}: ${gap.message}`);
+    }
+    const note = shaped.note;
+    if (gaps.length && typeof note === 'string')
+        out.unshift(`set_stats: ${note}`);
+    return out.slice(0, 6);
+}
 export function summarizeTennisMatchStats(data) {
     const root = asRecord(data) ?? {};
     const payload = asRecord(root.data) ?? root;
@@ -595,6 +580,7 @@ export function summarizeTennisMatchStats(data) {
                 completed: tennisSetCompleted(sr),
             };
         }),
+        setStats: summarizeTennisSetStats(payload.set_stats),
         rawPath: '/tennis/matches/{matchId}/stats',
     };
 }
@@ -632,7 +618,7 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                     type: 'string',
                     enum: ['base', 'playerStats', 'gamesOrMaps', 'timeline', 'liveState', 'media', 'advanced', 'odds'],
                 },
-                description: 'Explicit section list; defaults to base+playerStats+gamesOrMaps+media. "odds" is opt-in: UFC returns moneyline summarised per fighter with bookmaker count, best and median American price and implied probability plus a count of every other market (closing lines for a finished fight come back with currentlyOffered=false rather than being omitted); tennis returns the same bookmaker/market/outcome projection that tennis_odds serves, including oddsAvailable=false when no book is quoting. Odds exist for UFC and tennis only.',
+                description: 'Explicit section list; defaults to base+playerStats+gamesOrMaps+media. "odds" is opt-in: UFC returns moneyline summarised per fighter with bookmaker count, best and median American price and implied probability plus a count of every other market (closing lines for a finished fight come back with currentlyOffered=false rather than being omitted). Tennis odds were withdrawn alongside the /tennis/odds/* routes, so for any other game the section reports NOT_IMPLEMENTED. Odds exist for UFC only.',
             },
             includeTimeline: boolSchema('Include timeline section (heavy).', false),
             includeLiveState: boolSchema('Include live state/snapshots.', false),
@@ -692,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;
@@ -751,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);
@@ -784,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);
             }
@@ -798,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;
             }
         }
@@ -835,17 +806,10 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             if (game === 'ufc') {
                 loadWith('odds', `/ufc/bouts/${encodeURIComponent(matchId)}/odds`, summarizeUfcOdds);
             }
-            else if (game === 'tennis') {
-                // The gate that produced "Odds not curated for tennis; UFC only today"
-                // was written before /tennis/odds/{id} existed. It does: the same match
-                // returned FanDuel 1.105 / Matchbook 1.13 from tennis_odds while this
-                // section denied odds existed. Both surfaces now share one projection.
-                loadWith('odds', `/tennis/odds/${encodeURIComponent(matchId)}`, summarizeTennisOdds);
-            }
             else {
                 partial.push(partialFromRejection('odds', {
                     code: 'NOT_IMPLEMENTED',
-                    message: `Odds are not curated for ${game}. Available: UFC (/ufc/bouts/{id}/odds) and tennis (/tennis/odds/{id}).`,
+                    message: `Odds are not curated for ${game}. Currently available: UFC (/ufc/bouts/{id}/odds). Tennis odds were withdrawn.`,
                 }));
             }
         }
@@ -872,6 +836,12 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             }
         }
         await Promise.all(tasks);
+        const warnings = [];
+        if (game === 'tennis') {
+            const ps = asRecord(sections.playerStats);
+            if (ps)
+                warnings.push(...tennisSetStatsWarnings(ps.setStats));
+        }
         return successEnvelope({
             source: 'match_details',
             game,
@@ -879,6 +849,7 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             tookMs: Date.now() - started,
             upstreamCalls,
             rateLimit,
+            warnings: warnings.length ? warnings : undefined,
             partial: partial.length ? partial : undefined,
             entities: { games: [game], ids: { matchId, ...(gameId ? { gameId } : {}) } },
             data: {

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';
@@ -186,16 +183,6 @@ const TOOL_CATALOG = [
         preferOver: ['raw rankings history via call_api'],
         doNotUse: 'Latest snapshot → standings; week-over-week delta → rankings_movers',
     },
-    {
-        name: 'tennis_odds',
-        outcome: 'Tennis betting odds: upcoming matches with prices, plus pre-match and in-play for one match; upcoming rows carry a joinKey and playerIds because the feed leaves match_id null',
-        parallelSafe: true,
-        games: ['tennis'],
-        jobs: ['preview', 'match_page', 'odds'],
-        exampleArgs: { game: 'tennis', scope: 'upcoming', limit: 20 },
-        preferOver: ['raw odds via call_api', 'match_preview (no prices)'],
-        doNotUse: 'The result → match_details; rankings → standings',
-    },
     {
         name: 'tournaments',
         outcome: 'Tennis tournament catalog: filter by year, tour, level, surface or country; a level name that names a tour also fixes it',
@@ -378,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',
     },
@@ -443,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.',
@@ -653,7 +638,6 @@ Example: { "includeGameProbes": true }`,
                 });
             }
             else {
-                // try product root
                 const cs2 = await fetchJson(ctx, '/cs2');
                 upstreamCalls += 1;
                 rateLimit = cs2.headers;
@@ -670,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) {
@@ -703,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 };
             }
@@ -743,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) {
@@ -780,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: {
@@ -794,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) => {
@@ -815,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,
@@ -837,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 };
         }
@@ -861,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 });
         if (!res.ok) {
             return errorEnvelope({
                 code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
@@ -909,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.',
@@ -959,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({
@@ -1052,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;