cito-mcp 0.3.19 → 0.3.21

package/dist/tools/player.js

@@ -575,4 +575,198 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
         });
     },
 };
-export const playerTools = [playerProfile];
+/**
+ * player_form (TENNIS-12).
+ *
+ * Tennis-only: recent-match form for one player (GET /tennis/players/{id}/form).
+ * The upstream answers wins/losses/win_pct over the last N completed matches
+ * plus the per-match rows (result, opponent, score, surface) and the player's
+ * current rank + movement. This tool normalizes those rows and derives the
+ * current W/L streak from the leading run, newest first.
+ */
+const SURFACES = ['Hard', 'Clay', 'Grass'];
+function parseFormSurface(args) {
+    const raw = typeof args.surface === 'string' ? args.surface.trim() : '';
+    if (!raw)
+        return {};
+    const canon = raw.charAt(0).toUpperCase() + raw.slice(1).toLowerCase();
+    if (!SURFACES.includes(canon)) {
+        return { error: `surface must be one of Hard, Clay, Grass (got '${args.surface}')` };
+    }
+    return { surface: canon };
+}
+function normalizeFormMatch(row) {
+    const r = asRecord(row) ?? {};
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    return {
+        matchId: pickString(r.match_id) ?? null,
+        date: pickString(r.date) ?? null,
+        result: pickString(r.result) ?? null,
+        opponentId: pickString(r.opponent_id) ?? null,
+        opponentRank: num(r.opponent_rank),
+        score: pickString(r.score) ?? null,
+        surface: pickString(r.surface) ?? null,
+        tournamentId: pickString(r.tournament_id) ?? null,
+    };
+}
+export const playerForm = {
+    name: 'player_form',
+    description: `Tennis player form: W/L record over the last N completed matches, current win/loss streak, and per-match rows (opponent, score, surface). Optional surface filter (Hard/Clay/Grass).
+
+When to use:
+- "How is X playing lately?"; current streak; surface-specific record (e.g. clay last 5).
+
+Prefer over: player_profile (identity + career aggregates, no streak); raw form via call_api for agent-normalized rows.
+
+Do not use when: career totals/titles → player_profile with game tennis (wires /stats); ranking deltas → rankings_movers.
+
+Tennis-only. Limit defaults to 10 (max 50, matching the API). Upstream rows arrive newest-first; the streak is the leading run of that order.
+
+Parallel-safe: yes. Upstream cost: 1.`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['game', 'playerId'],
+        properties: {
+            game: gameSchema({ allowAll: false, required: true }),
+            playerId: stringSchema('Tennis player id, e.g. "atp_207989".', 'atp_207989'),
+            surface: stringSchema('Filter to one surface: Hard, Clay, or Grass.', 'Clay'),
+            limit: limitSchema({ default: 10, max: 50, description: 'Recent-match window (default 10, max 50).' }),
+        },
+    },
+    handler: async (args, ctx) => {
+        const started = Date.now();
+        const requestId = newRequestId();
+        const gameParse = parseGame(args.game, { allowAll: false, required: true });
+        if (gameParse.error || !gameParse.game || !isPrimaryGame(gameParse.game)) {
+            return errorEnvelope({
+                code: gameParse.error?.includes('unsupported') ? 'UNSUPPORTED_GAME' : 'VALIDATION',
+                message: gameParse.error ?? 'game is required',
+                game: null,
+                source: 'player_form',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const game = gameParse.game;
+        if (game !== 'tennis') {
+            return errorEnvelope({
+                code: 'NOT_IMPLEMENTED',
+                message: `player_form is tennis-only (game '${game}' has no recent-form endpoint)`,
+                game,
+                source: 'player_form',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Use player_profile for this game (form/trends where available)',
+                    'Retry player_form with game tennis and a tennis playerId',
+                ],
+            });
+        }
+        const playerId = typeof args.playerId === 'string' ? args.playerId.trim() : '';
+        if (!playerId) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: 'playerId is required (e.g. "atp_207989")',
+                game,
+                source: 'player_form',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Call resolve_entity with the player name',
+                    'Retry player_form with the returned id',
+                ],
+            });
+        }
+        const surfaceParse = parseFormSurface(args);
+        if (surfaceParse.error) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: surfaceParse.error,
+                game,
+                source: 'player_form',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const limit = clampInt(args.limit, 10, 1, 50);
+        const res = await fetchJson(ctx, `/tennis/players/${encodeURIComponent(playerId)}/form`, {
+            query: {
+                limit,
+                ...(surfaceParse.surface ? { surface: surfaceParse.surface } : {}),
+            },
+        });
+        if (!res.ok) {
+            return errorEnvelope({
+                code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                message: `Player form failed (HTTP ${res.status})`,
+                game,
+                source: 'player_form',
+                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 matches = (Array.isArray(body.matches) ? body.matches : []).map(normalizeFormMatch);
+        // Upstream rows arrive newest-first: the streak is the leading run.
+        let streakCount = 0;
+        let streakResult = null;
+        for (const m of matches) {
+            if (streakResult === null) {
+                if (m.result !== 'W' && m.result !== 'L')
+                    break;
+                streakResult = m.result;
+                streakCount = 1;
+            }
+            else if (m.result === streakResult) {
+                streakCount += 1;
+            }
+            else {
+                break;
+            }
+        }
+        const rank = asRecord(body.ranking) ?? {};
+        const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+        return successEnvelope({
+            pagination: {
+                limit,
+                offset: 0,
+                total: matches.length,
+                hasMore: false,
+                nextCursor: null,
+                prevCursor: null,
+            },
+            source: 'player_form',
+            game,
+            requestId,
+            tookMs: Date.now() - started,
+            upstreamCalls: 1,
+            rateLimit: res.headers,
+            entities: {
+                games: [game],
+                ids: { playerId },
+            },
+            data: {
+                title: `${playerId} recent form (last ${matches.length})`,
+                playerId,
+                sampleSize: num(body.sample_size) ?? matches.length,
+                wins: num(body.wins) ?? null,
+                losses: num(body.losses) ?? null,
+                winPct: num(body.win_pct) ?? null,
+                surfaceFilter: pickString(body.surface_filter) ?? null,
+                streak: streakResult ? { result: streakResult, count: streakCount } : null,
+                ranking: {
+                    current: num(rank.current),
+                    movement: num(rank.movement),
+                    asOf: pickString(rank.as_of) ?? null,
+                },
+                matches,
+            },
+        });
+    },
+};
+export const playerTools = [playerProfile, playerForm];

package/dist/tools/rankings.js

@@ -0,0 +1,228 @@
+/**
+ * rankings_movers (TENNIS-07).
+ *
+ * Tennis-only: biggest ranking movers between the latest ranking list and its
+ * predecessor (GET /tennis/rankings/movers). The upstream payload already
+ * carries new_entries[] and dropped[] alongside items[], so one tool covers
+ * both halves of the deferred TENNIS-07 ask — there is no standalone
+ * /rankings/new_entries route (it 404s; verified 2026-09-08).
+ */
+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';
+const DIRECTIONS = ['up', 'down', 'both'];
+function parseTour(args) {
+    const rawTour = typeof args.tour === 'string' ? args.tour.trim() : '';
+    const rawDivision = typeof args.division === 'string' ? args.division.trim() : '';
+    if (rawTour && rawDivision && rawTour.toUpperCase() !== rawDivision.toUpperCase()) {
+        return { error: `tour ('${rawTour}') and division ('${rawDivision}') disagree; pass one of ATP|WTA` };
+    }
+    const raw = rawTour || rawDivision;
+    if (!raw)
+        return { tour: 'ATP' };
+    const upper = raw.toUpperCase();
+    if (upper !== 'ATP' && upper !== 'WTA') {
+        return { error: `tour must be ATP or WTA (got '${raw}')` };
+    }
+    return { tour: upper };
+}
+function parseDirection(args) {
+    const raw = typeof args.direction === 'string' ? args.direction.trim().toLowerCase() : '';
+    if (!raw)
+        return { direction: 'up' };
+    if (!DIRECTIONS.includes(raw)) {
+        return { error: `direction must be one of up, down, both (got '${args.direction}')` };
+    }
+    return { direction: raw };
+}
+function parseDate(args) {
+    const raw = typeof args.date === 'string' ? args.date.trim() : '';
+    if (!raw)
+        return {};
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        return { error: `date must be YYYY-MM-DD (got '${args.date}')` };
+    }
+    return { date: raw };
+}
+function normalizeMover(row) {
+    const r = asRecord(row) ?? {};
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    return {
+        playerId: pickString(r.player_id) ?? null,
+        playerName: pickString(r.player_name) ?? null,
+        country: pickString(r.ioc, r.country_name) ?? null,
+        rank: num(r.rank),
+        previousRank: num(r.previous_rank),
+        movement: num(r.movement),
+        points: num(r.points),
+    };
+}
+function normalizeEdge(row) {
+    const r = asRecord(row) ?? {};
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+    return {
+        playerId: pickString(r.player_id) ?? null,
+        playerName: pickString(r.player_name) ?? null,
+        country: pickString(r.ioc, r.country_name) ?? null,
+        rank: num(r.rank),
+        previousRank: num(r.previous_rank),
+        points: num(r.points),
+    };
+}
+export const rankingsMovers = {
+    name: 'rankings_movers',
+    description: `Tennis ranking movers: biggest climbers/fallers between the latest ATP/WTA list and its predecessor, plus new entries and drop-outs.
+
+When to use:
+- Who climbed or fell this week; new top-100 entrants; who dropped out.
+
+Prefer over: standings (latest snapshot only, no week-over-week delta); raw movers via call_api for agent-normalized rows.
+
+Do not use when: current top-N snapshot → standings with game tennis; player history → player_profile.
+
+Tennis-only. Direction up (climbers, default), down (fallers), or both (largest absolute change). Date pins an older ranking list (YYYY-MM-DD); default is the latest, which the API resolves past zero-diff cloned lists.
+
+Parallel-safe: yes. Upstream cost: 1.`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['game'],
+        properties: {
+            game: gameSchema({ allowAll: false, required: true }),
+            tour: stringSchema('ATP or WTA tour; default ATP. Synonym: division.', 'WTA'),
+            division: stringSchema('Synonym for tour (ATP or WTA), matching the standings tool spelling.'),
+            direction: stringSchema('up (climbers), down (fallers), or both (largest absolute change).', 'up'),
+            within: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 2000,
+                default: 100,
+                description: 'Only players inside the top N on either list.',
+            },
+            date: stringSchema('Ranking date to compare against its predecessor (YYYY-MM-DD). Default: latest.'),
+            limit: limitSchema({ default: 20, max: 500 }),
+        },
+    },
+    handler: async (args, ctx) => {
+        const started = Date.now();
+        const requestId = newRequestId();
+        const gameParse = parseGame(args.game, { allowAll: false, required: true });
+        if (gameParse.error || !gameParse.game || !isPrimaryGame(gameParse.game)) {
+            return errorEnvelope({
+                code: gameParse.error?.includes('unsupported') ? 'UNSUPPORTED_GAME' : 'VALIDATION',
+                message: gameParse.error ?? 'game is required',
+                game: null,
+                source: 'rankings_movers',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const game = gameParse.game;
+        if (game !== 'tennis') {
+            return errorEnvelope({
+                code: 'NOT_IMPLEMENTED',
+                message: `rankings_movers is tennis-only (game '${game}' has no ranking-movers endpoint)`,
+                game,
+                source: 'rankings_movers',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Use standings for the latest snapshot of this game',
+                    'Retry rankings_movers with game tennis and tour ATP|WTA',
+                ],
+            });
+        }
+        const tourParse = parseTour(args);
+        if (tourParse.error || !tourParse.tour) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: tourParse.error ?? 'tour is required',
+                game,
+                source: 'rankings_movers',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const dirParse = parseDirection(args);
+        if (dirParse.error || !dirParse.direction) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: dirParse.error ?? 'direction is invalid',
+                game,
+                source: 'rankings_movers',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const dateParse = parseDate(args);
+        if (dateParse.error) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: dateParse.error,
+                game,
+                source: 'rankings_movers',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const within = clampInt(args.within, 100, 1, 2000);
+        const limit = clampInt(args.limit, 20, 1, 500);
+        const res = await fetchJson(ctx, '/tennis/rankings/movers', {
+            query: {
+                tour: tourParse.tour,
+                direction: dirParse.direction,
+                within,
+                limit,
+                ...(dateParse.date ? { date: dateParse.date } : {}),
+            },
+        });
+        if (!res.ok) {
+            return errorEnvelope({
+                code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                message: `Rankings movers failed (HTTP ${res.status})`,
+                game,
+                source: 'rankings_movers',
+                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(normalizeMover);
+        const newEntries = (Array.isArray(body.new_entries) ? body.new_entries : []).map(normalizeEdge);
+        const dropped = (Array.isArray(body.dropped) ? body.dropped : []).map(normalizeEdge);
+        const total = typeof body.total === 'number' ? body.total : items.length;
+        return successEnvelope({
+            pagination: {
+                limit,
+                offset: 0,
+                total,
+                hasMore: false,
+                nextCursor: null,
+                prevCursor: null,
+            },
+            source: 'rankings_movers',
+            game,
+            requestId,
+            tookMs: Date.now() - started,
+            upstreamCalls: 1,
+            rateLimit: res.headers,
+            data: {
+                title: `${tourParse.tour} ranking movers (${dirParse.direction})`,
+                tour: tourParse.tour,
+                direction: dirParse.direction,
+                within,
+                rankingDate: pickString(body.ranking_date) ?? null,
+                previousDate: pickString(body.previous_date) ?? null,
+                items,
+                newEntries,
+                dropped,
+                total,
+            },
+        });
+    },
+};
+export const rankingsTools = [rankingsMovers];

package/dist/tools/standings.js

@@ -103,6 +103,7 @@ Required scope keys by game:
 - cs2: omit for world rankings; eventId for event standings
 - cod: optional season/stage
 - ufc: optional division (scope=division)
+- tennis: optional division (ATP or WTA tour; default ATP)
 - dota2: best-effort worldRanking only
 
 Parallel-safe: yes. Upstream cost: 1–2.
@@ -242,9 +243,10 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
             }
         }
         else if (game === 'tennis') {
-            // Tennis "standings" = the latest ATP/WTA singles rankings. Pass tour via division.
+            // Tennis "standings" = the latest ATP/WTA singles rankings, with
+            // rank_movement/previous_rank on every row. Pass tour via division.
             const tour = String(division ?? 'ATP').toUpperCase() === 'WTA' ? 'WTA' : 'ATP';
-            path = '/tennis/rankings/top';
+            path = '/tennis/standings';
             query = { tour, top_n: Math.min(limit, 100) };
             effectiveScope = 'world';
             title = `${tour} singles rankings`;

package/dist/tools/team.js

@@ -1022,4 +1022,186 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
         });
     },
 };
-export const teamTools = [teamProfile, headToHead];
+/**
+ * h2h_matrix (TENNIS-24, cycle 60).
+ *
+ * Tennis-only: multi-player head-to-head comparison grid from the first-class
+ * GET /tennis/h2h/matrix route (2-16 player ids, comma-separated). Upstream
+ * shape (verified 2026-09-09): { players: [{ id, name, ioc, wins }], matrix:
+ * { [rowId]: { [colId]: "W-L" | "-" } } }. Cell "7-6" at [A][B] means A won 7
+ * and B won 6 of their meetings; "-" marks the self diagonal. Unknown ids get
+ * honest 0-0 cells and no players entry (no 404); fewer than 2 or more than 16
+ * ids 422, which surfaces as VALIDATION here.
+ *
+ * Names are resolved to atp_/wta_ ids via /tennis/players/search first (same
+ * id-shaped shortcut as the head_to_head tennis branch); duplicates collapse
+ * to one grid row.
+ */
+export const h2hMatrix = {
+    name: 'h2h_matrix',
+    description: `Multi-player tennis head-to-head grid: every pair's series record in one comparison matrix.
+
+When to use:
+- Draw/field analysis: how each contender fares against every other (e.g. Alcaraz vs Zverev vs Sinner round-robin records)
+- Group-stage or semifinal-field comparisons
+
+Prefer over: N head_to_head calls for an N-player field; raw matrix via call_api.
+
+Do not use when: a two-player rivalry deep-dive with tiebreak/decider splits → head_to_head; season stat leaders → leaderboard_*; rankings → standings.
+
+Tennis-only. players takes 2-16 ids or names (names resolve via player search). Each matrix cell is "W-L" from the row player's perspective, "-" on the diagonal.
+
+Parallel-safe: yes. Upstream cost: 1 + one search per unresolved name.`,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['game', 'players'],
+        properties: {
+            game: gameSchema({ allowAll: false, required: true }),
+            players: {
+                type: 'array',
+                items: { type: 'string' },
+                minItems: 2,
+                maxItems: 16,
+                description: '2-16 tennis player ids (atp_207989) or names ("Carlos Alcaraz"); duplicates collapse.',
+            },
+        },
+    },
+    handler: async (args, ctx) => {
+        const started = Date.now();
+        const requestId = newRequestId();
+        const gameParse = parseGame(args.game, { allowAll: false, required: true });
+        if (gameParse.error || !gameParse.game || !isPrimaryGame(gameParse.game)) {
+            return errorEnvelope({
+                code: gameParse.error?.includes('unsupported') ? 'UNSUPPORTED_GAME' : 'VALIDATION',
+                message: gameParse.error ?? 'game is required',
+                game: null,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+            });
+        }
+        const game = gameParse.game;
+        if (game !== 'tennis') {
+            return errorEnvelope({
+                code: 'NOT_IMPLEMENTED',
+                message: `h2h_matrix is tennis-only (game '${game}' has no H2H matrix)`,
+                game,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Use head_to_head for a two-side rivalry record in this game',
+                    'Retry h2h_matrix with game tennis and 2-16 player ids or names',
+                ],
+            });
+        }
+        const rawPlayers = Array.isArray(args.players) ? args.players : [];
+        const cleaned = rawPlayers
+            .filter((p) => typeof p === 'string' && p.trim().length > 0)
+            .map((p) => p.trim());
+        if (cleaned.length < 2 || cleaned.length > 16) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: `players must contain between 2 and 16 names or ids (got ${cleaned.length})`,
+                game,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: ['Pass 2-16 player ids (atp_207989) or names ("Carlos Alcaraz")'],
+            });
+        }
+        let upstreamCalls = 0;
+        let rateLimit = {};
+        const resolveTennisSide = async (side) => {
+            if (/^(atp|wta)_\d+$/i.test(side))
+                return { id: side, name: side };
+            const res = await fetchJson(ctx, '/tennis/players/search', { query: { q: side, limit: 3 } });
+            upstreamCalls += 1;
+            rateLimit = { ...rateLimit, ...res.headers };
+            if (!res.ok)
+                return null;
+            const envelope = asRecord(res.data) ?? {};
+            const data = asRecord(envelope.data) ?? envelope;
+            const first = asRecord(extractRows(data.items ?? data)[0]);
+            const id = pickString(first?.id, first?.player_id);
+            return id ? { id, name: pickString(first?.full_name, first?.name) ?? side } : null;
+        };
+        const resolved = await Promise.all(cleaned.map((side) => resolveTennisSide(side)));
+        const missing = cleaned.filter((_, i) => !resolved[i]);
+        if (missing.length > 0) {
+            return errorEnvelope({
+                code: 'NOT_FOUND',
+                message: `Tennis player(s) not found: ${missing.join(', ')} — pass names or ids like atp_104745`,
+                game,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls,
+                rateLimit,
+                recover: [
+                    'resolve_entity { game: "tennis", type: "player", q } for each missing name',
+                    'Retry h2h_matrix with returned ids',
+                ],
+            });
+        }
+        // Dedupe resolved ids preserving order: REST dict keys would collapse
+        // anyway, but players_info would list the duplicate twice.
+        const ids = [...new Set(resolved.map((r) => r.id))];
+        if (ids.length < 2) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: 'players resolve to fewer than 2 distinct players — pass at least 2 different players',
+                game,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls,
+                rateLimit,
+            });
+        }
+        const res = await fetchJson(ctx, '/tennis/h2h/matrix', {
+            query: { player_ids: ids.join(',') },
+        });
+        upstreamCalls += 1;
+        rateLimit = { ...rateLimit, ...res.headers };
+        if (!res.ok) {
+            return errorEnvelope({
+                code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                message: `Tennis H2H matrix fetch failed (HTTP ${res.status})`,
+                game,
+                source: 'h2h_matrix',
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls,
+                httpStatus: res.status,
+                rateLimit,
+            });
+        }
+        const envelope = asRecord(res.data) ?? {};
+        const payload = asRecord(envelope.data) ?? envelope;
+        const players = extractRows(payload.players ?? []).map((row) => {
+            const r = asRecord(row) ?? {};
+            return {
+                id: pickString(r.id, r.player_id) ?? null,
+                name: pickString(r.full_name, r.name) ?? null,
+                ioc: pickString(r.ioc) ?? null,
+            };
+        });
+        const matrix = asRecord(payload.matrix) ?? {};
+        return successEnvelope({
+            source: 'h2h_matrix',
+            game,
+            requestId,
+            tookMs: Date.now() - started,
+            upstreamCalls,
+            rateLimit,
+            data: {
+                players,
+                matrix,
+                notes: ['Cells are "W-L" from the row player vs the column player; "-" is the self diagonal'],
+            },
+        });
+    },
+};
+export const teamTools = [teamProfile, headToHead, h2hMatrix];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cito-mcp",
-  "version": "0.3.19",
-  "description": "Standalone MCP server for the Cito esports API — 15 curated outcome tools for agents (live, schedule, profiles, standings, previews, event cards).",
+  "version": "0.3.21",
+  "description": "Standalone MCP server for the Cito esports and sports API — 36 curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
   "type": "module",
   "bin": {
     "cito-mcp": "dist/index.js"