cito-mcp 0.3.16 → 0.3.17

package/dist/instructions.js

@@ -60,7 +60,7 @@ Live board: api_health (optional) → live_matches → match_summary for selecte
 UFC empty live (count=0): read section.note / emptyReason / health (workerAlive, lag) / supervisor / nextCard — do not claim "API offline" without workerAlive/lag; never invent matchups from supervisor shells.
 Team page: resolve_entity {type:team} → team_profile.
 Player card: resolve_entity {type:player|fighter} → player_profile.
-Fight night / event card: resolve_entity {type:event} → event_card {includeBouts:true} → match_preview for a featured bout.
+Fight night / event card: resolve_entity {type:event} → event_card {includeMatches:true} → match_preview for a featured bout.
 Match preview (named sides): resolve_entity each side (optional) → match_preview {teamA, teamB}.
 App scaffold: list_capabilities ∥ api_health ∥ live_matches, then one composite per screen.
 

package/dist/tools/insight.js

@@ -3,7 +3,7 @@
  */
 import { clampInt, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, unwrapPayload, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
-import { normalizeMatch, sortByCardOrder } from './normalize.js';
+import { normalizeMatch, presentSides, sortByCardOrder } from './normalize.js';
 import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
 async function loadSide(ctx, game, side, recentLimit, includeRosters) {
     const partial = [];
@@ -270,7 +270,9 @@ export function composeH2H(game, sideA, sideB, rows, limit) {
         .slice(0, limit);
     return {
         meetings: meetings.length,
-        lastMeetings: meetings.slice(0, 5),
+        // Tennis has players, not teams: rename team1/team2 -> player1/player2 on
+        // the way out. Every other game keeps team1/team2 unchanged.
+        lastMeetings: meetings.slice(0, 5).map((m) => presentSides(m, game)),
         recordNote: meetings.length ? `${meetings.length} past meetings found in window` : 'No past H2H meetings in window',
     };
 }
@@ -620,14 +622,17 @@ Example: { "game": "lol", "teamA": "t1", "teamB": "gen-g", "includeH2H": true, "
                 context,
                 sideA: {
                     entity: sideARes.entity,
-                    roster: sideARes.roster,
-                    recentForm: sideARes.recentForm,
+                    // A tennis player has no roster; the key never applied here, not
+                    // merely came back empty. UFC fighters get the same treatment
+                    // elsewhere in this surface — omit rather than ship a foreign key.
+                    ...(game === 'tennis' ? {} : { roster: sideARes.roster }),
+                    recentForm: sideARes.recentForm.map((m) => presentSides(m, game)),
                     keyPlayers: sideARes.keyPlayers,
                 },
                 sideB: {
                     entity: sideBRes.entity,
-                    roster: sideBRes.roster,
-                    recentForm: sideBRes.recentForm,
+                    ...(game === 'tennis' ? {} : { roster: sideBRes.roster }),
+                    recentForm: sideBRes.recentForm.map((m) => presentSides(m, game)),
                     keyPlayers: sideBRes.keyPlayers,
                 },
                 h2h,
@@ -744,8 +749,12 @@ Prefer match_preview for one bout/match briefing; match_summary for completed re
 
 Do not use when: you only need live scores (live_matches); single finished match recap (match_summary); no event name/id yet and game unknown.
 
+Tennis: pass a tournament id/slug to get the draw bracket — rounds carry a round
+code (Q1..R128, QF, SF, F) with each match's players and score. Set is the
+primary tennis path here; there is no separate draw tool.
+
 Parallel-safe: yes. Upstream cost: 1–4.
-Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "includeStandings": false }`,
+Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "includeStandings": false }`,
     inputSchema: {
         type: 'object',
         additionalProperties: false,
@@ -757,7 +766,10 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
             game: gameSchema({ allowAll: false, required: true }),
             eventIdOrSlug: stringSchema('Event or tournament id/slug. Prefer over q when known. Required unless q is given. Example: "ufc-300".', 'ufc-300'),
             q: stringSchema('Free-text event name when id/slug unknown. Example: "UFC 300". Resolves within this tool — still prefer resolve_entity when disambiguating many hits.', 'UFC 300'),
-            includeBouts: boolSchema('Include bout/match list (default true).', true),
+            // Named for the general case (a card, a bracket, a match list), not
+            // combat-sport vocabulary — "bout" has no meaning for a tennis draw or a
+            // CS2 event hub, and this same parameter gates both.
+            includeMatches: boolSchema('Include the bout/match list, or the tennis draw bracket (default true).', true),
             includeStandings: boolSchema('Include standings/rankings snippet when API supports event/tournament/division scope (default false). ' +
                 'For UFC this also joins divisional rank and movement onto each bout corner as team.rank / team.rankMovement — ' +
                 'bout rows themselves carry no rank. Costs one extra upstream call.', false),
@@ -785,7 +797,7 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
         const game = gameParse.game;
         let eventKey = typeof args.eventIdOrSlug === 'string' ? args.eventIdOrSlug.trim() : '';
         const q = typeof args.q === 'string' ? args.q.trim() : '';
-        const includeBouts = args.includeBouts !== false;
+        const includeBouts = args.includeMatches !== false;
         const includeStandings = args.includeStandings === true;
         const limit = clampInt(args.limit, 20, 1, 50);
         if (!eventKey && !q) {
@@ -834,6 +846,10 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
         };
         let bouts = [];
         let standingsSnippet = null;
+        // Tennis only: the draw bracket grouped by round, each round carrying the
+        // upstream's own round code (Q1..R128, QF, SF, F) so an agent can render
+        // the tournament tree rather than one flat, order-dependent match list.
+        let drawRounds = null;
         if (game === 'ufc') {
             const detail = await fetchJson(ctx, `/ufc/events/${encodeURIComponent(eventKey)}`);
             upstreamCalls += 1;
@@ -1246,16 +1262,29 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
                 rateLimit = { ...rateLimit, ...draw.headers };
                 if (draw.ok) {
                     const dd = asRecord(unwrapPayload(draw.data)) ?? {};
-                    const rounds = Array.isArray(dd.rounds) ? dd.rounds : [];
+                    const rawRounds = Array.isArray(dd.rounds) ? dd.rounds : [];
                     const flat = [];
-                    for (const rr of rounds) {
+                    drawRounds = rawRounds.map((rr) => {
                         const rec = asRecord(rr) ?? {};
-                        const roundName = pickString(rec.round_name, rec.name, rec.round) ?? null;
-                        for (const mm of (Array.isArray(rec.matches) ? rec.matches : [])) {
+                        const roundCode = pickString(rec.round_code, rec.roundCode) ?? null;
+                        const roundName = pickString(rec.round_name, rec.name, rec.round) ?? roundCode;
+                        const matches = (Array.isArray(rec.matches) ? rec.matches : []).map((mm) => {
                             const mr = asRecord(mm) ?? {};
-                            flat.push({ ...mr, id: mr.match_id, round: roundName, tournament_name: event.name, status: 'completed' });
-                        }
-                    }
+                            const row = { ...mr, id: mr.match_id, round: roundName, tournament_name: event.name, status: 'completed' };
+                            flat.push(row);
+                            // normalizeMatch gives named, id'd sides (player1/player2 once
+                            // presented); the raw score string and bracket-progression
+                            // fields are the only place the actual set score and next slot
+                            // live, so carry them alongside rather than dropping them.
+                            return presentSides({
+                                ...normalizeMatch('tennis', row),
+                                score: pickString(mr.score) ?? null,
+                                matchNum: typeof mr.match_num === 'number' ? mr.match_num : null,
+                                nextMatchId: pickString(mr.next_match_id) ?? null,
+                            }, 'tennis');
+                        });
+                        return { roundCode, roundName, matches };
+                    });
                     bouts = flat.slice(0, limit).map((row) => normalizeMatch('tennis', row));
                     if (!bouts.length)
                         warnings.push('No draw yet: the tournament has no archived results');
@@ -1344,8 +1373,13 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeBouts": true, "inc
             },
             data: {
                 event,
-                bouts: includeBouts ? bouts : [],
+                bouts: includeBouts ? bouts.map((b) => presentSides(b, game)) : [],
                 boutCount: includeBouts ? bouts.length : 0,
+                // Tennis only: the same matches grouped by round, with round codes
+                // (Q1..R128, QF, SF, F) and each match's score/bracket progression —
+                // this is what makes a bracket renderable; `bouts` above is the flat
+                // list every other game already gets.
+                ...(game === 'tennis' ? { draw: drawRounds ? { rounds: drawRounds } : null } : {}),
                 standings: includeStandings ? standingsSnippet : null,
                 nextSteps: [
                     'For a featured bout/match: match_preview { game, matchId } or teamA+teamB',

package/dist/tools/live.js

@@ -3,7 +3,7 @@
  */
 import { clampInt, decodeCursor, encodeCursor, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, } from '../client.js';
 import { DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT, errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
-import { normalizeMatch } from './normalize.js';
+import { normalizeMatch, presentSides } from './normalize.js';
 import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, PRIMARY_GAMES, stringSchema, } from './types.js';
 const LIVE_PATHS = {
     lol: '/lol/live',
@@ -292,7 +292,9 @@ Example: { "game": "all", "limitPerGame": 10 }`,
                     label: m.label,
                     startTime: m.startTime,
                 }))
-                : normalized;
+                // Tennis has players, not teams: rename team1/team2 -> player1/player2
+                // at this boundary only. Every other game is untouched.
+                : normalized.map((m) => presentSides(m, m.game));
             if (game === 'ufc') {
                 const health = asRecord(meta?.health) ?? asRecord(payload?.health);
                 const events = Array.isArray(payload?.events) ? payload.events : [];
@@ -759,7 +761,9 @@ Example: { "game": "lol", "hours": 72, "team": "t1", "limit": 20 }`,
                 nextCursor: hasMore ? encodeCursor({ offset: offset + limit }) : null,
                 prevCursor: offset > 0 ? encodeCursor({ offset: Math.max(0, offset - limit) }) : null,
             },
-            data: { items },
+            // Tennis has players, not teams: rename team1/team2 -> player1/player2
+            // at this boundary only. Every other game is untouched.
+            data: { items: items.map((m) => presentSides(m, game)) },
         });
     },
 };

package/dist/tools/match.js

@@ -3,7 +3,7 @@
  */
 import { extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, unwrapPayload, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
-import { normalizeMatch, normalizeUfcMethod } from './normalize.js';
+import { normalizeMatch, normalizeUfcMethod, presentSides } from './normalize.js';
 import { boolSchema, gameSchema, isPrimaryGame, parseGame, stringSchema, } from './types.js';
 async function getSection(ctx, path, query) {
     return fetchJson(ctx, path, { query });
@@ -61,7 +61,7 @@ function matchCore(game, matchId, raw) {
     const scoreline = m.team1 || m.team2
         ? `${m.team1?.name ?? '?'} ${s1 ?? '-'} : ${s2 ?? '-'} ${m.team2?.name ?? '?'}`
         : null;
-    return {
+    const core = {
         matchId: m.matchId !== 'unknown' ? m.matchId : matchId,
         game,
         status: m.status,
@@ -78,10 +78,17 @@ function matchCore(game, matchId, raw) {
         team2: m.team2,
         event: m.event,
         league: m.league,
-        // One enum on every surface. match_summary carried the source spelling
-        // here while the profile carried the enum, so consumers normalised anyway.
-        method: (game === 'ufc' ? normalizeUfcMethod(pickString(r.method, r.resultMethod)) : pickString(r.method, r.resultMethod)) ?? null,
-        methodRaw: pickString(r.method, r.resultMethod) ?? null,
+        // 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,
+                methodRaw: pickString(r.method, r.resultMethod) ?? null,
+            }
+            : {}),
         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.
@@ -109,33 +116,37 @@ function matchCore(game, matchId, raw) {
                 return sideLabel(s1 > s2 ? m.team1 : m.team2);
             return null;
         })(),
-        weightClass: pickString(r.weightClass, r.division) ?? null,
-        referee: (() => {
-            const nested = asRecord(r.referee);
-            if (nested) {
-                const joined = [nested.firstName, nested.lastName].filter(Boolean).join(' ').trim();
-                const name = pickString(nested.name, joined || undefined) ?? null;
-                const id = pickString(nested.id, nested.refereeId) ?? null;
-                if (name || id) {
+        ...(game === 'ufc'
+            ? {
+                weightClass: pickString(r.weightClass, r.division) ?? null,
+                referee: (() => {
+                    const nested = asRecord(r.referee);
+                    if (nested) {
+                        const joined = [nested.firstName, nested.lastName].filter(Boolean).join(' ').trim();
+                        const name = pickString(nested.name, joined || undefined) ?? null;
+                        const id = pickString(nested.id, nested.refereeId) ?? null;
+                        if (name || id) {
+                            return {
+                                id,
+                                name,
+                                firstName: pickString(nested.firstName) ?? null,
+                                lastName: pickString(nested.lastName) ?? null,
+                            };
+                        }
+                    }
+                    const name = pickString(r.refereeName) ?? null;
+                    const id = pickString(r.refereeId) ?? null;
+                    if (!name && !id)
+                        return null;
                     return {
                         id,
                         name,
-                        firstName: pickString(nested.firstName) ?? null,
-                        lastName: pickString(nested.lastName) ?? null,
+                        firstName: pickString(r.refereeFirstName) ?? null,
+                        lastName: pickString(r.refereeLastName) ?? null,
                     };
-                }
+                })(),
             }
-            const name = pickString(r.refereeName) ?? null;
-            const id = pickString(r.refereeId) ?? null;
-            if (!name && !id)
-                return null;
-            return {
-                id,
-                name,
-                firstName: pickString(r.refereeFirstName) ?? null,
-                lastName: pickString(r.refereeLastName) ?? null,
-            };
-        })(),
+            : {}),
         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.
@@ -150,6 +161,17 @@ 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);
 }
 function primaryPath(game, matchId) {
     switch (game) {
@@ -338,6 +360,36 @@ 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 {
+                        setNumber: typeof sr.set_num === 'number' ? sr.set_num : typeof sr.set_number === 'number' ? sr.set_number : null,
+                        score: pickString(sr.score) ?? (p1g != null && p2g != null ? `${p1g}-${p2g}` : null),
+                        player1Games: p1g,
+                        player2Games: p2g,
+                        tiebreak: sr.tiebreak ?? null,
+                        completed: sr.is_completed === true,
+                    };
+                });
+                return;
+            }
             let path = null;
             if (game === 'lol')
                 path = `/lol/matches/${encodeURIComponent(matchId)}/games`;
@@ -364,11 +416,11 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
             }
         })());
         await Promise.all(enrich);
-        const scoreline = {
+        const scoreline = presentSides({
             display: `${match.team1?.name ?? '?'} ${match.score.team1 ?? '-'} : ${match.score.team2 ?? '-'} ${match.team2?.name ?? '?'}`,
             team1: match.score.team1,
             team2: match.score.team2,
-        };
+        }, game);
         if (view === 'summary' && playerPerformances.length > 10) {
             playerPerformances = playerPerformances.slice(0, 10);
         }
@@ -382,7 +434,7 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
             partial: partial.length ? partial : undefined,
             entities: { games: [game], ids: { matchId: match.matchId } },
             data: {
-                match,
+                match: toClientMatch(match, game),
                 scoreline,
                 keyEvents,
                 playerPerformances,
@@ -588,9 +640,25 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
         // The header is the identity of the response, not an optional section.
         wanted.add('base');
         if (wanted.has('base')) {
-            const res = await getSection(ctx, primaryPath(game, matchId));
+            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;
+                rateLimit = { ...rateLimit, ...res.headers };
+                const gid = matchId.match(/^s365_(\d+)$/)?.[1];
+                if (!res.ok && gid) {
+                    const year = new Date().getUTCFullYear();
+                    res = await getSection(ctx, `/tennis/matches/${encodeURIComponent(`s365_${year}_${gid}`)}`);
+                    upstreamCalls += 1;
+                    rateLimit = { ...rateLimit, ...res.headers };
+                }
+            }
             if (!res.ok) {
                 return errorEnvelope({
                     code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
@@ -604,7 +672,7 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                     httpStatus: res.status,
                 });
             }
-            sections.base = matchCore(game, matchId, res.data);
+            sections.base = toClientMatch(matchCore(game, matchId, res.data), game);
         }
         const tasks = [];
         const load = (section, path, query) => {

package/dist/tools/meta.js

@@ -139,11 +139,12 @@ const TOOL_CATALOG = [
     {
         name: 'event_card',
         outcome: 'Event / fight-night card: identity + bout list, card-ordered (main event first), ' +
-            'each corner carrying photos, record, nickname, country and weight class (+ optional standings)',
+            'each corner carrying photos, record, nickname, country and weight class (+ optional standings). ' +
+            'For tennis, pass a tournament id/slug to get the draw bracket, grouped by round (Q1..R128, QF, SF, F).',
         parallelSafe: true,
         games: [...PRIMARY_GAMES],
         jobs: ['event_card', 'schedule', 'media', 'app_scaffold'],
-        exampleArgs: { game: 'ufc', eventIdOrSlug: 'ufc-300', includeBouts: true },
+        exampleArgs: { game: 'ufc', eventIdOrSlug: 'ufc-300', includeMatches: true },
         preferOver: [
             'call_api /ufc/events + bout expansion',
             'N+1 match_summary for card list',
@@ -208,7 +209,7 @@ const RECIPES = [
         id: 'ufc_fight_night_card',
         steps: [
             'resolve_entity { game: "ufc", type: "event", q } OR pass known eventIdOrSlug',
-            'event_card { game: "ufc", eventIdOrSlug, includeBouts: true }',
+            'event_card { game: "ufc", eventIdOrSlug, includeMatches: true }',
             'optional match_preview for featured bout; standings { game: "ufc", scope: "division" }',
         ],
     },

package/dist/tools/normalize.js

@@ -28,6 +28,22 @@ function deriveProxiedImageUrl(rawUrl, game) {
         return null;
     return `${IMAGE_PROXY_BASE}/public/images/ufc/${Buffer.from(rawUrl, 'utf8').toString('base64url')}`;
 }
+/**
+ * Tennis has players, not teams. The cross-game NormalizedMatch type keeps
+ * team1/team2 internally for every game so the rest of this module stays
+ * uniform (nestedSide, sidesMatch, sortByCardOrder, …); this renames those two
+ * keys — and, when present, a nested score sub-object shaped the same way —
+ * at the JSON boundary for tennis only. Every other game passes through
+ * unchanged.
+ */
+export function presentSides(obj, game) {
+    if (game !== 'tennis' || !obj || typeof obj !== 'object')
+        return obj;
+    if (!('team1' in obj) && !('team2' in obj))
+        return obj;
+    const { team1, team2, ...rest } = obj;
+    return { ...rest, player1: team1, player2: team2 };
+}
 function sideFrom(name, id, slug, score, extra) {
     if (!name && !id && !slug)
         return null;
@@ -456,6 +472,29 @@ export function normalizeMatch(game, row, forcedStatus) {
     const resultRound = numOrNull(r.resultRound);
     const hasResultDetail = method != null || resultRound != null || winnerSlug != null || resultTime != null;
     const isCancelled = r.isCancelled === true;
+    // Tennis live/detail rows carry a top-level sets[] (set_num/player*_games/
+    // tiebreak/is_completed) plus game_score/server/current_set. A live board
+    // that only reports "score: 1" cannot tell 6-0 6-0 from a 7-6 in progress;
+    // carry the real breakdown through instead of collapsing it to an integer.
+    let tennisSets;
+    let tennisGameScore = null;
+    let tennisServer = null;
+    let tennisCurrentSet = null;
+    if (game === 'tennis' && Array.isArray(r.sets) && r.sets.length) {
+        tennisSets = r.sets.map((s) => {
+            const sr = asRecord(s) ?? {};
+            return {
+                setNumber: numOrNull(sr.set_num),
+                player1Games: numOrNull(sr.player1_games),
+                player2Games: numOrNull(sr.player2_games),
+                tiebreak: sr.tiebreak == null ? null : (pickString(sr.tiebreak) ?? String(sr.tiebreak)),
+                completed: sr.is_completed === true,
+            };
+        });
+        tennisGameScore = pickString(r.game_score) ?? null;
+        tennisServer = typeof r.server === 'number' ? r.server : null;
+        tennisCurrentSet = typeof r.current_set === 'number' ? r.current_set : null;
+    }
     return {
         game,
         matchId,
@@ -466,7 +505,9 @@ export function normalizeMatch(game, row, forcedStatus) {
         team2,
         event: eventName || eventId || eventSlug ? { id: eventId, slug: eventSlug, name: eventName } : null,
         league: leagueName || leagueId || leagueSlug ? { id: leagueId, slug: leagueSlug, name: leagueName } : null,
-        ...(weightOrClass ? { weightClass: weightOrClass } : {}),
+        // weightClass is UFC vocabulary; other games never set it, but never lie
+        // it into existence from a tennis/LoL row that merely shares a field name.
+        ...(weightOrClass && game === 'ufc' ? { weightClass: weightOrClass } : {}),
         ...(r.titleBout != null ? { titleBout: Boolean(r.titleBout) } : {}),
         ...(hasCard
             ? {
@@ -481,16 +522,22 @@ export function normalizeMatch(game, row, forcedStatus) {
         ...(hasResultDetail
             ? {
                 result: {
-                    method: method ?? null,
+                    // method/referee are combat-sport vocabulary with no tennis
+                    // meaning; a tennis history row otherwise picks up a
+                    // result.method:null / result.referee:null pair from this same
+                    // object shape, which reads as "render a fight" to an agent.
+                    ...(game === 'ufc' ? { method: method ?? null, referee: referee ?? null } : {}),
                     methodRaw: methodRaw ?? null,
                     methodDetails: methodDetails ?? null,
                     round: resultRound,
                     time: resultTime ?? null,
-                    referee: referee ?? null,
                     winnerSlug: winnerSlug ?? null,
                 },
             }
             : {}),
+        ...(tennisSets
+            ? { sets: tennisSets, gameScore: tennisGameScore, server: tennisServer, currentSet: tennisCurrentSet }
+            : {}),
         ...(isCancelled
             ? { cancelled: { isCancelled: true, reason: pickString(r.cancellationReason) ?? null } }
             : {}),

package/dist/tools/resolve.js

@@ -584,6 +584,15 @@ Example: { "game": "ufc", "q": "Jon Jones", "type": "fighter", "limit": 10 }`,
         // while reporting total=1429 and hasMore=true. The UFC paths below fetch
         // page 1 deliberately and re-rank in memory, so they page here instead.
         let upstreamPaged = true;
+        // Set for a game whose dedicated search endpoint already returns results
+        // in the right order (e.g. tennis: /tennis/players/search ranks Carlos
+        // Alcaraz first). The generic re-rank below fuzzy-scores every candidate
+        // against the query string with no notion of who is actually ranked, so
+        // "alcaraz" tied four players at nearly the same score and resorted the
+        // world #3 to fourth — behind three players the upstream had already
+        // correctly placed below him. Preserving push order keeps the upstream's
+        // answer instead of a worse one computed from less information.
+        let preserveUpstreamOrder = false;
         const pageQuery = (extra = {}) => ({
             limit,
             offset,
@@ -686,6 +695,11 @@ Example: { "game": "ufc", "q": "Jon Jones", "type": "fighter", "limit": 10 }`,
                         const envelope = asRecord(res.data) ?? {};
                         const data = asRecord(envelope.data) ?? envelope;
                         items.push(...extractRows(data.items ?? data).map((r) => entityRef(r, 'player', game)));
+                        // /tennis/players/search already ranks the best-known match first
+                        // (it has current_rank to break ties this tool's fuzzy scorer
+                        // cannot see); do not let the generic re-sort below undo that.
+                        if (q)
+                            preserveUpstreamOrder = true;
                     }
                 }
                 if (type === 'tournament' || type === 'event' || type === 'any') {
@@ -809,7 +823,7 @@ Example: { "game": "ufc", "q": "Jon Jones", "type": "fighter", "limit": 10 }`,
             seen.add(key);
             return true;
         });
-        if (q) {
+        if (q && !preserveUpstreamOrder) {
             items.sort((a, b) => {
                 const sa = typeof a.meta?.score === 'number' ? a.meta.score : rankScore(q, a.name, a.id, a.slug, a.meta?.nickname);
                 const sb = typeof b.meta?.score === 'number' ? b.meta.score : rankScore(q, b.name, b.id, b.slug, b.meta?.nickname);

package/dist/tools/team.js

@@ -4,7 +4,7 @@
 import { clampInt, extractRows, fetchJson, gameNotIncludedHint, asRecord, pickString, } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
 import { normalizeMatch } from './normalize.js';
-import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from './types.js';
+import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, PRIMARY_GAMES, stringSchema, } from './types.js';
 function teamIdentity(game, raw, idHint, slugHint) {
     const r = asRecord(raw) ?? {};
     const nested = asRecord(r.data) ?? r;
@@ -46,7 +46,15 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
         additionalProperties: false,
         required: ['game'],
         properties: {
-            game: gameSchema({ allowAll: false, required: true }),
+            // Tennis is deliberately absent: singles has players, not team rosters,
+            // and advertising it here only to throw NOT_IMPLEMENTED on every call is
+            // a trap — the schema told the caller the request was valid. player_profile
+            // and standings{game:"tennis"} cover the same ground honestly.
+            game: {
+                type: 'string',
+                enum: PRIMARY_GAMES.filter((g) => g !== 'tennis'),
+                description: 'Game title: lol | cs2 | dota2 | cod | ufc. Tennis has players, not team rosters — use player_profile.',
+            },
             teamId: stringSchema('Team id. Prefer for cs2. Pass teamId and/or slug (at least one required). Either works for dota2.'),
             slug: stringSchema('Team/org slug. Prefer for lol and cod orgs. Pass teamId and/or slug (at least one required). Example: "t1".', 't1'),
             recentLimit: limitSchema({ default: 10, max: 25 }),
@@ -903,6 +911,18 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             }
             const envelope = asRecord(res.data) ?? {};
             const h2h = asRecord(envelope.data) ?? envelope;
+            // The id-shaped shortcut above never resolves a name — sideA:"atp_207989"
+            // came in already looking like an id, so resolveTennisSide handed back
+            // {id: side, name: side} without ever asking who that id belongs to. The
+            // /tennis/h2h payload already states both names one level down (its own
+            // player1/player2, keyed by the same player1_id/player2_id this request
+            // just sent), so read from there rather than trusting the resolver's
+            // name at all: it is authoritative and always available once the H2H
+            // call itself succeeded.
+            const h2hP1 = asRecord(h2h.player1);
+            const h2hP2 = asRecord(h2h.player2);
+            const sideAName = pickString(h2hP1?.name) ?? tA.name;
+            const sideBName = pickString(h2hP2?.name) ?? tB.name;
             return successEnvelope({
                 source: 'head_to_head',
                 game,
@@ -911,8 +931,8 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 upstreamCalls,
                 rateLimit,
                 data: {
-                    sideA: { idOrSlug: tA.id, name: tA.name },
-                    sideB: { idOrSlug: tB.id, name: tB.name },
+                    sideA: { idOrSlug: tA.id, name: sideAName },
+                    sideB: { idOrSlug: tB.id, name: sideBName },
                     h2h,
                     notes: ['Record and meetings come from the first-class /tennis/h2h endpoint'],
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cito-mcp",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "description": "Standalone MCP server for the Cito esports API — 15 curated outcome tools for agents (live, schedule, profiles, standings, previews, event cards).",
   "type": "module",
   "bin": {