cito-mcp 0.4.6 → 0.4.7

package/README.md

@@ -2,7 +2,7 @@
 
 Standalone [MCP](https://modelcontextprotocol.io) server for the [Cito esports API](https://api.citoapi.com) — **curated outcome tools** for agents building esports apps, dashboards, bots, and research flows.
 
-**Version:** `0.3.20` · **Node:** `>=20` · **Install:** `npx cito-mcp`
+**Version:** `0.4.7` · **Node:** `>=20` · **Install:** `npx cito-mcp`
 
 Primary games & sports: **lol · cs2 · dota2 · cod · ufc · tennis**. Long-tail REST stays available via `call_api`.
 
@@ -50,8 +50,6 @@ Where the source data is partial, the tool says so instead of shipping a plausib
 | The two ranking lists compared by `rankings_movers` are not a week apart | `gapDays` + `comparisonWindow` (`"12-week gap"`), `comparisonsAreWeekly: false`, and a warning naming both dates |
 | A tennis tournament draw is missing matches | `draw.shortRounds` (`["R128 45/64"]`), `draw.missingRounds`, `draw.complete` |
 | A stats section the endpoint does not publish | `player_stats.unavailable` names the section and why, rather than a block of nulls |
-| No bookmaker is quoting a match | `oddsAvailable: false` plus a note that it is a coverage gap, not an error |
-| The odds feed leaves `match_id` null | `joinKey` (`{kind:"oddsEventId", …}`) and `playerIds`, so the row is still joinable |
 | `search_entities` results that do not match at all | dropped, counted under `data.relevance.droppedBelowFloor`, with a warning naming them |
 
 ---
@@ -542,11 +540,14 @@ claude mcp add cito -e CITO_API_KEY=cito_… "--" npx -y cito-mcp
 
 ## Changelog (summary)
 
+### 0.4.7
+
+- Removed the unregistered tennis odds module and its README entries; `match_details` `sections:["odds"]` stays UFC-only and answers `NOT_IMPLEMENTED` for other games.
+
 ### 0.4.2
 
 Second tennis correctness pass, from the 2026-09-12 re-sweep. Five defects, each reproduced from a raw payload and re-verified after the fix. Two were upstream (fixed on the API and verified with the 40/40 invariant gate); three were MCP-side.
 
-- **`tennis_odds` called a nonexistent match "no coverage".** `/tennis/odds/{id}` answers **HTTP 200 with `coverage.odds=false` for every id it does not know** — verified for `s365_2026_0000000` and for the literal `total-garbage-id`. So a typo and a genuine no-book gap were indistinguishable and both came back `ok:true`. `scope=match`/`live` now verify the id against `/tennis/matches/{id}` (which does 404) when no odds are quoted: unknown id → `NOT_FOUND` with recovery steps, real match → an honest coverage gap with `matchExists: true`.
 - **Tennis `standings` published a fake total and could not be paged.** `/tennis/standings?top_n=5` set `rank_max=top_n`, so the count (which carried the rank bounds) equalled the page size: `total:5`, `hasMore:false` for a list of **150** ranked players. The API now counts the population without the rank window and returns `ranked_players`/`total_pages`/`has_next`, `/standings` takes a `page` argument, and the tool reports `total`/`rankedPlayers`/`totalPages`/`hasMore` — page 2 of the ATP list now starts at rank 6. The same `allRows.length` mistake in the `pagination` block was fixed too, so the two counts cannot disagree.
 - **`event_card` published the requested id as the event name.** With a bad id it answered `ok:true` and `event.name = "atp_2026_999999"` over a 404 that `partial[]` reported correctly. Names now come from the payload or are `null`, with `event.resolved` recording whether the detail fetch succeeded.
 - **`leaderboard_*` reported the page size as the population.** Every board returned `"total": len(items)` after applying `.limit(limit)`, so `limit=2` answered `total:2` — for boards whose own docs record thousands of qualifiers. Upstream now carries `count(*) OVER ()` (Postgres evaluates it after `GROUP BY`/`HAVING`, so it is exactly the qualifying population, at no extra round trip): aces **2488**, break-conversion **1089** (matching the figure in its own docstring), 1st-serve-won 1141, bp-saved 1186, return-games 987, tiebreak 364, deciders 334, comebacks 611, finals 66. Each tool also reports `returned` and the board's `minimumAttempts`.
@@ -560,12 +561,10 @@ Second tennis correctness pass, from the 2026-09-12 re-sweep. Five defects, each
 Tennis correctness pass, driven by the 2026-09-12 sweep (`reports/tennis-mcp-sweep-2026-09-12.md`). Every item was reproduced against live ids and re-verified after the fix.
 
 - **`match_summary` tennis scoreline was always `- : -`.** `/tennis/matches/{id}` puts no `sets_won` on its player objects, so the sets-won score was null for every completed match while the same payload held the real score in `score` and `sets[]`. Sets won are now derived (explicit → `winner_sets_won` → `sets[]` → `score` string), `score.detail` carries the game score, and a set's `completed` is inferred when the archive omits `is_completed`. The winner-oriented `winner_games`/`loser_games` pair is deliberately not used as a side score. `bestOf` now reads `best_of`.
-- **`match_details` denied tennis odds existed.** The `odds` section was gated to UFC; the same match returned bookmaker prices from `tennis_odds`. Both surfaces now share one projection (`summarizeTennisOdds`), and `playerStats` (previously always `null` for tennis) is filled from `/tennis/matches/{id}/stats`.
 - **`player_stats.bySurface` was always four nulls.** The endpoint publishes one object per surface and the projector coerced each to a number. Real per-surface blocks, `servingStats`, and an explicit `unavailable` map for sections the endpoint does not publish.
 - **`limit` was ignored** by `player_rankings_history` (asked 4, got 342) and by `/tennis/matches/completed`. Both are bounded locally now, with `*Returned` versus `*Count` so the day total is never confused with the page.
 - **`tournaments level="WTA 1000"` returned ATP Masters events.** The API's level reverse-map is not tour-aware (`_TIER_WTA` maps both `PM` and `M` to "WTA 1000"), so the tool now sends and enforces the tour the level name states, and drops + counts contradicting rows. Fixed at the source too — the same widening also leaked `WTA 125`, `Challenger`, `Davis Cup` and `Billie Jean King Cup`.
 - **`rankings_movers` called an 84-day gap "week-over-week".** `gapDays`/`comparisonWindow`/`comparisonsAreWeekly` now state the real interval, with a warning. `standings` reports the tennis `ranking_date` as `updatedAt` instead of `null`.
-- **`tennis_odds upcoming` rows carried `matchId: null`** with no alternative key. `joinKey` and `playerIds` make the row joinable without inventing an id.
 - **`tennis_schedule`** now counts the day's list/completed overlap, summarises statuses, and flags date-only `startsAt` placeholders.
 - **`live_matches` labelled tennis rows by tournament**, not players, because the live route's `name` is the event.
 - **Tennis players had no images** although `/tennis/players/{id}` carries `portrait_url`. Now surfaced (plus `ioc` as the side country on boards).

package/dist/tools/match.js

@@ -809,7 +809,7 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             else {
                 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.`,
+                    message: `Odds are only available for UFC (/ufc/bouts/{id}/odds).`,
                 }));
             }
         }

package/dist/tools/meta.js

@@ -488,18 +488,18 @@ const GAMES_META = [
 ];
 export const listCapabilities = {
     name: 'list_capabilities',
-    description: `Curated catalog of cito-mcp tools, games, jobs, and builder recipes.
-
-When to use:
-- Session start or "what can you do?"
-- Mapping app screens to tools
-- Filtering by game or job (live_board, match_page, team_page, player_form, standings, h2h, schedule, preview, event_card, app_scaffold)
-
-Prefer over: guessing from memory; exploring raw OpenAPI via call_api.
-
-Do not use when: you already know the tool and have IDs — call that tool directly.
-
-Parallel-safe: yes. Upstream cost: 0.
+    description: `Curated catalog of cito-mcp tools, games, jobs, and builder recipes.
+
+When to use:
+- Session start or "what can you do?"
+- Mapping app screens to tools
+- Filtering by game or job (live_board, match_page, team_page, player_form, standings, h2h, schedule, preview, event_card, app_scaffold)
+
+Prefer over: guessing from memory; exploring raw OpenAPI via call_api.
+
+Do not use when: you already know the tool and have IDs — call that tool directly.
+
+Parallel-safe: yes. Upstream cost: 0.
 Example: { "game": "cs2", "job": "live_board", "includeExamples": true }`,
     inputSchema: {
         type: 'object',
@@ -582,18 +582,18 @@ Example: { "game": "cs2", "job": "live_board", "includeExamples": true }`,
 };
 export const apiHealth = {
     name: 'api_health',
-    description: `API reachability, API key validity, plan tier, rate-limit headers, and best-effort included games.
-
-When to use:
-- Once per session before heavy work
-- After 401/403/UNSUPPORTED_GAME/RATE_LIMIT
-- App scaffolding entitlement checks
-
-Prefer over: probing random game endpoints to test the key.
-
-Do not use when: you only need live scores — use live_matches.
-
-Parallel-safe: yes. Upstream cost: 1–6.
+    description: `API reachability, API key validity, plan tier, rate-limit headers, and best-effort included games.
+
+When to use:
+- Once per session before heavy work
+- After 401/403/UNSUPPORTED_GAME/RATE_LIMIT
+- App scaffolding entitlement checks
+
+Prefer over: probing random game endpoints to test the key.
+
+Do not use when: you only need live scores — use live_matches.
+
+Parallel-safe: yes. Upstream cost: 1–6.
 Example: { "includeGameProbes": true }`,
     inputSchema: {
         type: 'object',
@@ -736,21 +736,21 @@ function pathAllowed(path) {
 }
 export const callApi = {
     name: 'call_api',
-    description: `Power escape hatch: allowlisted Cito REST call with unshaped raw JSON in data.raw.
-
-When to use:
-- Long-tail paths not yet curated (Fortnite, CS2 leaderboards, niche stats)
-- Debugging payloads while building an app
-- User explicitly knows an OpenAPI path
-
-Prefer curated tools for all standard jobs (live, schedule, profiles, standings, H2H, previews).
-
-Do not use when: a curated tool covers the outcome. Avoid parallel storms; same plan rate limits apply.
-
-Path must start with / and match allowlisted prefixes: /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis.
-Rejects absolute URLs and path traversal → PATH_NOT_ALLOWED.
-
-Parallel-safe: yes but discouraged in bulk. Upstream cost: 1.
+    description: `Power escape hatch: allowlisted Cito REST call with unshaped raw JSON in data.raw.
+
+When to use:
+- Long-tail paths not yet curated (Fortnite, CS2 leaderboards, niche stats)
+- Debugging payloads while building an app
+- User explicitly knows an OpenAPI path
+
+Prefer curated tools for all standard jobs (live, schedule, profiles, standings, H2H, previews).
+
+Do not use when: a curated tool covers the outcome. Avoid parallel storms; same plan rate limits apply.
+
+Path must start with / and match allowlisted prefixes: /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis.
+Rejects absolute URLs and path traversal → PATH_NOT_ALLOWED.
+
+Parallel-safe: yes but discouraged in bulk. Upstream cost: 1.
 Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"page\\":1,\\"limit\\":20}" }`,
     inputSchema: {
         type: 'object',
@@ -872,20 +872,20 @@ const SPEC_OMITS = {
 };
 export const listRoutes = {
     name: 'list_routes',
-    description: `Index of raw REST routes from the live OpenAPI spec: method, path, summary, tag.
-
-When to use:
-- You need a long-tail path for call_api and do not want to guess
-- Checking whether an endpoint exists before building around it
-- Mapping what raw data backs a curated tool
-
-Prefer curated tools for standard jobs — this indexes the escape hatch, it is not a replacement for list_capabilities.
-
-Do not use when: a curated tool already covers the outcome (call list_capabilities instead).
-
-Note: the spec omits /lol entirely, though LoL routes work. Filtering by game=lol returns that caveat rather than an empty list.
-
-Parallel-safe: yes. Upstream cost: 1.
+    description: `Index of raw REST routes from the live OpenAPI spec: method, path, summary, tag.
+
+When to use:
+- You need a long-tail path for call_api and do not want to guess
+- Checking whether an endpoint exists before building around it
+- Mapping what raw data backs a curated tool
+
+Prefer curated tools for standard jobs — this indexes the escape hatch, it is not a replacement for list_capabilities.
+
+Do not use when: a curated tool already covers the outcome (call list_capabilities instead).
+
+Note: the spec omits /lol entirely, though LoL routes work. Filtering by game=lol returns that caveat rather than an empty list.
+
+Parallel-safe: yes. Upstream cost: 1.
 Example: { "game": "ufc", "q": "rankings" }`,
     inputSchema: {
         type: 'object',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cito-mcp",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "Standalone MCP server for the Cito esports and sports API — curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
   "type": "module",
   "homepage": "https://cito.gg",

package/dist/tools/odds.js

@@ -1,287 +0,0 @@
-import { asRecord, clampInt, fetchJson, gameNotIncludedHint, pickString, } from '../client.js';
-import { errorEnvelope, mapHttpToCode, newRequestId, successEnvelope, } from '../envelope.js';
-import { gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
-function normalizeBookmaker(row) {
-    const r = asRecord(row) ?? {};
-    const markets = (Array.isArray(r.markets) ? r.markets : []).map((mk) => {
-        const m = asRecord(mk) ?? {};
-        const outcomes = (Array.isArray(m.outcomes) ? m.outcomes : []).map((o) => {
-            const oc = asRecord(o) ?? {};
-            return {
-                name: pickString(oc.name) ?? null,
-                price: typeof oc.price === 'number' && Number.isFinite(oc.price) ? oc.price : null,
-                point: typeof oc.point === 'number' && Number.isFinite(oc.point) ? oc.point : null,
-            };
-        });
-        return {
-            market: pickString(m.key) ?? null,
-            outcomes,
-            impliedProbabilities: (() => {
-                const prices = outcomes.map((o) => o.price).filter((p) => p !== null && p > 1);
-                if (prices.length !== outcomes.length || prices.length === 0)
-                    return null;
-                const inv = prices.map((p) => 1 / p);
-                const sum = inv.reduce((a, b) => a + b, 0);
-                return inv.map((v) => Number((v / sum).toFixed(4)));
-            })(),
-        };
-    });
-    return {
-        key: pickString(r.key) ?? null,
-        title: pickString(r.title) ?? null,
-        lastUpdate: pickString(r.last_update) ?? null,
-        markets,
-    };
-}
-export function summarizeTennisOdds(data) {
-    const root = asRecord(data) ?? {};
-    const payload = asRecord(root.data) ?? root;
-    const coverage = asRecord(payload.coverage) ?? {};
-    const bookmakers = (Array.isArray(payload.bookmakers) ? payload.bookmakers : []).map(normalizeBookmaker);
-    const hasOdds = coverage.odds === true || bookmakers.length > 0;
-    return {
-        matchId: pickString(payload.match_id) ?? null,
-        oddsFormat: pickString(payload.odds_format) ?? 'decimal',
-        commenceTime: pickString(payload.commence_time) ?? null,
-        stale: payload.stale === true,
-        bookmakers,
-        oddsAvailable: hasOdds,
-        note: hasOdds
-            ? null
-            : 'No bookmaker is currently quoting this match. This is an upstream coverage gap, not an error; retry closer to the start time.',
-        fullBookPath: '/tennis/odds/{matchId}',
-    };
-}
-function parseTennis(args, tool) {
-    const gameParse = parseGame(args.game, { allowAll: false, required: true });
-    if (gameParse.error || !gameParse.game || !isPrimaryGame(gameParse.game)) {
-        return { error: gameParse.error ?? 'game is required', game: null };
-    }
-    const game = gameParse.game;
-    if (game !== 'tennis') {
-        return {
-            error: `${tool} is tennis-only (odds for '${game}' is not served by this endpoint)`,
-            game,
-        };
-    }
-    return { game };
-}
-function requireTennisId(args, tool) {
-    const id = typeof args.matchId === 'string' ? args.matchId.trim() : '';
-    if (!id)
-        return { error: `${tool} requires matchId` };
-    return { matchId: id };
-}
-export const tennisOdds = {
-    name: 'tennis_odds',
-    description: `Tennis betting odds: upcoming matches with prices, plus pre-match and in-play odds for one match.
-
-Modes (pick with 'scope'):
-- upcoming (default): matches with odds available, each with the bookmakers quoting it.
-- match: pre-match odds for one match_id.
-- live: in-play odds for one match_id.
-
-When to use:
-- "What are the odds on X vs Y?"; pre-match prices; in-play prices; which matches have odds today.
-
-Prefer over: call_api for /tennis/odds/*; match_preview (no prices).
-
-Do not use when: the match result → match_details; rankings → standings.
-
-Tennis-only. Odds are decimal. Coverage is partial upstream: a match with no
-priced bookmaker returns coverage.odds=false and an empty bookmakers[] rather
-than invented numbers, and this tool surfaces that distinction explicitly.
-A match id that does not exist is a NOT_FOUND error, not a coverage gap: the
-odds route answers 200/odds:false for every unknown id, so scope=match and
-scope=live verify the match against /tennis/matches/{id} before reporting a gap,
-and set matchExists.
-
-Parallel-safe: yes. Upstream cost: 1.`,
-    inputSchema: {
-        type: 'object',
-        additionalProperties: false,
-        required: ['game'],
-        properties: {
-            game: gameSchema({ allowAll: false, required: true }),
-            scope: stringSchema('upcoming (default) | match | live.', 'upcoming'),
-            matchId: stringSchema('Match id for scope=match or scope=live, e.g. "s365_2026_4853596".', 's365_2026_4853596'),
-            limit: limitSchema({ default: 20, max: 50, description: 'Rows for scope=upcoming (default 20, max 50).' }),
-        },
-    },
-    handler: async (args, ctx) => {
-        const started = Date.now();
-        const requestId = newRequestId();
-        const parsed = parseTennis(args, 'tennis_odds');
-        if (parsed.error) {
-            return errorEnvelope({
-                code: parsed.error.includes('unsupported') ? 'UNSUPPORTED_GAME' : 'VALIDATION',
-                message: parsed.error,
-                game: parsed.game,
-                source: 'tennis_odds',
-                requestId,
-                tookMs: Date.now() - started,
-            });
-        }
-        const game = parsed.game;
-        const scopeRaw = typeof args.scope === 'string' ? args.scope.trim().toLowerCase() : 'upcoming';
-        if (!['upcoming', 'match', 'live'].includes(scopeRaw)) {
-            return errorEnvelope({
-                code: 'VALIDATION',
-                message: `scope must be upcoming, match, or live (got '${args.scope}')`,
-                game,
-                source: 'tennis_odds',
-                requestId,
-                tookMs: Date.now() - started,
-                recover: ['Use scope=upcoming for matches with odds', 'Use scope=match or scope=live with a matchId'],
-            });
-        }
-        const matchId = typeof args.matchId === 'string' ? args.matchId.trim() : '';
-        if (scopeRaw !== 'upcoming' && !matchId) {
-            return errorEnvelope({
-                code: 'VALIDATION',
-                message: `matchId is required when scope=${scopeRaw}`,
-                game,
-                source: 'tennis_odds',
-                requestId,
-                tookMs: Date.now() - started,
-                recover: [`Pass matchId, or use scope=upcoming with no id`],
-            });
-        }
-        const limit = clampInt(args.limit, 20, 1, 50);
-        if (scopeRaw === 'upcoming') {
-            const res = await fetchJson(ctx, '/tennis/odds/upcoming', { query: { limit } });
-            if (!res.ok) {
-                return errorEnvelope({
-                    code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
-                    message: `Upcoming tennis odds failed (HTTP ${res.status})`,
-                    game,
-                    source: 'tennis_odds',
-                    requestId,
-                    tookMs: Date.now() - started,
-                    upstreamCalls: 1,
-                    httpStatus: res.status,
-                    rateLimit: res.headers,
-                });
-            }
-            const root = asRecord(res.data) ?? {};
-            const body = asRecord(root.data) ?? root;
-            const items = (Array.isArray(body.items) ? body.items : []).map((row) => {
-                const r = asRecord(row) ?? {};
-                const home = asRecord(r.home) ?? {};
-                const away = asRecord(r.away) ?? {};
-                const homeId = pickString(home.player_id, home.id) ?? null;
-                const awayId = pickString(away.player_id, away.id) ?? null;
-                const matchId = pickString(r.match_id, r.id) ?? null;
-                const oddsEventId = pickString(r.odds_event_id) ?? null;
-                return {
-                    matchId,
-                    oddsEventId,
-                    tournament: pickString(r.tournament) ?? null,
-                    commenceTime: pickString(r.commence_time, r.starts_at) ?? null,
-                    player1: { name: pickString(home.name) ?? null, id: homeId },
-                    player2: { name: pickString(away.name) ?? null, id: awayId },
-                    bookmakers: Array.isArray(r.bookmakers) ? r.bookmakers.map((b) => pickString(b) ?? null) : [],
-                    live: r.live === true,
-                    joinKey: matchId
-                        ? { kind: 'matchId', matchId }
-                        : oddsEventId
-                            ? { kind: 'oddsEventId', oddsEventId }
-                            : null,
-                    playerIds: [homeId, awayId].filter((x) => Boolean(x)),
-                };
-            });
-            const total = typeof body.total === 'number' ? body.total : items.length;
-            return successEnvelope({
-                pagination: {
-                    limit,
-                    offset: 0,
-                    total,
-                    hasMore: body.has_next === true,
-                    nextCursor: null,
-                    prevCursor: null,
-                },
-                source: 'tennis_odds',
-                game,
-                requestId,
-                tookMs: Date.now() - started,
-                upstreamCalls: 1,
-                rateLimit: res.headers,
-                data: {
-                    title: `Tennis odds — upcoming (${items.length} of ${total})`,
-                    scope: scopeRaw,
-                    oddsFormat: 'decimal',
-                    items,
-                    total,
-                },
-            });
-        }
-        const path = scopeRaw === 'match'
-            ? `/tennis/odds/${encodeURIComponent(matchId)}`
-            : `/tennis/odds/${encodeURIComponent(matchId)}/live`;
-        const res = await fetchJson(ctx, path, {});
-        let upstreamCalls = 1;
-        let rateLimit = res.headers;
-        if (!res.ok) {
-            return errorEnvelope({
-                code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
-                message: `Tennis ${scopeRaw} odds failed for '${matchId}' (HTTP ${res.status})`,
-                game,
-                source: 'tennis_odds',
-                requestId,
-                tookMs: Date.now() - started,
-                upstreamCalls: 1,
-                httpStatus: res.status,
-                rateLimit: res.headers,
-                recover: ['Check the match id with live_matches or match_details'],
-            });
-        }
-        const summary = summarizeTennisOdds(res.data);
-        let matchExists = null;
-        if (summary.oddsAvailable !== true) {
-            const probe = await fetchJson(ctx, `/tennis/matches/${encodeURIComponent(matchId)}`);
-            upstreamCalls += 1;
-            rateLimit = { ...rateLimit, ...probe.headers };
-            matchExists = probe.ok;
-            if (!matchExists) {
-                const liveProbe = await fetchJson(ctx, `/tennis/matches/live/${encodeURIComponent(matchId)}`);
-                upstreamCalls += 1;
-                rateLimit = { ...rateLimit, ...liveProbe.headers };
-                matchExists = liveProbe.ok;
-            }
-            if (!matchExists) {
-                return errorEnvelope({
-                    code: 'NOT_FOUND',
-                    message: `No tennis match with id '${matchId}' — the odds feed has no event for it because the id itself does not exist`,
-                    game,
-                    source: 'tennis_odds',
-                    requestId,
-                    tookMs: Date.now() - started,
-                    upstreamCalls,
-                    rateLimit,
-                    httpStatus: 200,
-                    recover: [
-                        'Check the id with live_matches or tennis_schedule / match_summary',
-                        'Ids come from live_matches (s365_*) or the archive (s365_{year}_{gid})',
-                        `For the pre-match odds list instead, call tennis_odds { game: "tennis", scope: "upcoming" }`,
-                    ],
-                });
-            }
-        }
-        return successEnvelope({
-            source: 'tennis_odds',
-            game,
-            requestId,
-            tookMs: Date.now() - started,
-            upstreamCalls,
-            rateLimit,
-            data: {
-                title: `Tennis ${scopeRaw} odds — ${matchId}`,
-                scope: scopeRaw,
-                ...summary,
-                matchId: summary.matchId ?? matchId,
-                matchExists,
-            },
-        });
-    },
-};
-export const oddsTools = [tennisOdds];