cito-mcp 0.2.6 → 0.3.0

package/dist/tools/resolve.js

@@ -230,6 +230,33 @@ async function searchGame(ctx, game, q, type, limit) {
             }
             pushCandidates(candidates, game, type === 'any' ? 'unknown' : type, extractRows(res.data), q, limit);
         }
+        else if (game === 'tennis') {
+            // Tennis has no combined /search; players and competitions are separate lookups.
+            const tasks = [];
+            if (type === 'any' || type === 'player') {
+                tasks.push((async () => {
+                    const res = await fetchJson(ctx, '/tennis/players/search', { query: { q, limit } });
+                    calls += 1;
+                    if (res.ok) {
+                        const envelope = asRecord(res.data) ?? {};
+                        const data = asRecord(envelope.data) ?? envelope;
+                        pushCandidates(candidates, game, 'player', extractRows(data.items ?? data), q, limit);
+                    }
+                })());
+            }
+            if (type === 'any' || type === 'tournament' || type === 'event') {
+                tasks.push((async () => {
+                    const res = await fetchJson(ctx, '/tennis/competitions', { query: { q, page_size: limit } });
+                    calls += 1;
+                    if (res.ok) {
+                        const envelope = asRecord(res.data) ?? {};
+                        const data = asRecord(envelope.data) ?? envelope;
+                        pushCandidates(candidates, game, 'tournament', extractRows(data.items ?? data), q, limit);
+                    }
+                })());
+            }
+            await Promise.all(tasks);
+        }
         else if (game === 'lol') {
             const tasks = [];
             if (type === 'any' || type === 'team') {
@@ -593,6 +620,26 @@ Example: { "game": "ufc", "q": "Jon Jones", "type": "fighter", "limit": 10 }`,
                         await listPath('/dota2/tournaments', 'tournament');
                 }
             }
+            else if (game === 'tennis') {
+                if (type === 'player' || type === 'any') {
+                    const res = await fetchJson(ctx, '/tennis/players/search', { query: { q, limit } });
+                    upstreamCalls += 1;
+                    if (res.ok) {
+                        const envelope = asRecord(res.data) ?? {};
+                        const data = asRecord(envelope.data) ?? envelope;
+                        items.push(...extractRows(data.items ?? data).map((r) => entityRef(r, 'player', game)));
+                    }
+                }
+                if (type === 'tournament' || type === 'event' || type === 'any') {
+                    const res = await fetchJson(ctx, '/tennis/competitions', { query: { q, page_size: limit } });
+                    upstreamCalls += 1;
+                    if (res.ok) {
+                        const envelope = asRecord(res.data) ?? {};
+                        const data = asRecord(envelope.data) ?? envelope;
+                        items.push(...extractRows(data.items ?? data).map((r) => entityRef(r, 'tournament', game)));
+                    }
+                }
+            }
             else if (game === 'cod') {
                 if (q) {
                     const res = await fetchJson(ctx, '/cod/search', {

package/dist/tools/standings.js

@@ -8,7 +8,7 @@ import { gameSchema, isPrimaryGame, limitSchema, parseGame, stringSchema, } from
 export function normalizeStandingRow(row, index) {
     const r = asRecord(row) ?? {};
     const entity = asRecord(r.team) ?? asRecord(r.fighter) ?? asRecord(r.org) ?? r;
-    const name = pickString(asRecord(entity)?.name, r.teamName, r.name, r.orgName, r.fighterName, asRecord(entity)?.slug) ?? `row-${index + 1}`;
+    const name = pickString(asRecord(entity)?.name, r.teamName, r.name, r.orgName, r.fighterName, r.player_name, asRecord(entity)?.slug) ?? `row-${index + 1}`;
     // UFC official lists: champion has rank=null + rankText="C" (interim "IC"); contenders 1..15.
     // Never fall back to index+1 for explicit null ranks — that produced two "#1" rows (champ + #1).
     const championStatus = pickString(r.championStatus, asRecord(entity)?.championStatus);
@@ -234,6 +234,14 @@ Example: { "game": "cod", "season": "2026", "limit": 50 }`,
                 title = 'UFC rankings';
             }
         }
+        else if (game === 'tennis') {
+            // Tennis "standings" = the latest ATP/WTA singles rankings. Pass tour via division.
+            const tour = String(division ?? 'ATP').toUpperCase() === 'WTA' ? 'WTA' : 'ATP';
+            path = '/tennis/rankings/top';
+            query = { tour, top_n: Math.min(limit, 100) };
+            effectiveScope = 'world';
+            title = `${tour} singles rankings`;
+        }
         else if (game === 'dota2') {
             // No first-class standings — try team list worldRanking
             const res = await fetchJson(ctx, '/dota2/teams', { query: { limit } });

package/dist/tools/team.js

@@ -21,18 +21,18 @@ function teamIdentity(game, raw, idHint, slugHint) {
 }
 export const teamProfile = {
     name: 'team_profile',
-    description: `Team/org card: identity, roster, recent matches, and form/trends/radar when available.
-
-When to use:
-- Team page / "who is on this roster?"
-- Builder team screen sample
-
-Prefer over: separate roster + matches + detail via call_api.
-
-Do not use when: UFC fighters → player_profile; unknown name → resolve_entity first.
-Dota may return partial roster (API gap). Prefer slug for lol/cod; teamId for cs2.
-
-Parallel-safe: yes. Upstream cost: 2–4.
+    description: `Team/org card: identity, roster, recent matches, and form/trends/radar when available.
+
+When to use:
+- Team page / "who is on this roster?"
+- Builder team screen sample
+
+Prefer over: separate roster + matches + detail via call_api.
+
+Do not use when: UFC fighters → player_profile; unknown name → resolve_entity first.
+Dota may return partial roster (API gap). Prefer slug for lol/cod; teamId for cs2.
+
+Parallel-safe: yes. Upstream cost: 2–4.
 Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
     inputSchema: {
         type: 'object',
@@ -81,6 +81,20 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                 ],
             });
         }
+        if (game === 'tennis') {
+            return errorEnvelope({
+                code: 'NOT_IMPLEMENTED',
+                message: 'Tennis has players, not team profiles',
+                game,
+                source: 'team_profile',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    'Use player_profile with a tennis player id (e.g. atp_104745)',
+                    'Use standings with game "tennis" for ATP/WTA rankings',
+                ],
+            });
+        }
         const teamId = typeof args.teamId === 'string' ? args.teamId.trim() : '';
         const slug = typeof args.slug === 'string' ? args.slug.trim() : '';
         if (!teamId && !slug) {
@@ -486,19 +500,19 @@ function winnerSide(match, a) {
 }
 export const headToHead = {
     name: 'head_to_head',
-    description: `Composed head-to-head record between two teams (or two UFC fighters). No first-class REST H2H exists — this tool filters match history server-side.
-
-When to use:
-- Rivalry / series record questions
-- Supporting context for previews
-
-Prefer over: agent-side double match-list filtering.
-
-Do not use when: single-side form only → team_profile or player_profile.
-
-Caveat: Dota filters are weaker; expect meta.warnings when data is sparse.
-
-Parallel-safe: yes. Upstream cost: 2–4.
+    description: `Composed head-to-head record between two teams, two UFC fighters, or two tennis players. No first-class REST H2H exists — this tool filters match history server-side.
+
+When to use:
+- Rivalry / series record questions
+- Supporting context for previews
+
+Prefer over: agent-side double match-list filtering.
+
+Do not use when: single-side form only → team_profile or player_profile.
+
+Caveat: Dota filters are weaker; expect meta.warnings when data is sparse.
+
+Parallel-safe: yes. Upstream cost: 2–4.
 Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
     inputSchema: {
         type: 'object',
@@ -508,9 +522,9 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
             game: gameSchema({ allowAll: false, required: true }),
             entityType: {
                 type: 'string',
-                enum: ['team', 'fighter'],
+                enum: ['team', 'fighter', 'player'],
                 default: 'team',
-                description: 'team (default) or fighter (UFC).',
+                description: 'team (default), fighter (UFC), or player (tennis).',
             },
             sideA: stringSchema('Id or slug for side A.', 'faze'),
             sideB: stringSchema('Id or slug for side B.', 'navi'),
@@ -734,6 +748,74 @@ Example: { "game": "cs2", "sideA": "faze", "sideB": "navi", "limit": 20 }`,
                 warnings.push('No fight history rows returned for either fighter; H2H may be empty');
             }
         }
+        if (game === 'tennis') {
+            // Tennis has a first-class H2H endpoint; resolve names to player ids first when needed.
+            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 [tA, tB] = await Promise.all([resolveTennisSide(sideA), resolveTennisSide(sideB)]);
+            if (!tA || !tB) {
+                return errorEnvelope({
+                    code: 'NOT_FOUND',
+                    message: 'One or both tennis players not found — pass names or ids like atp_104745',
+                    game,
+                    source: 'head_to_head',
+                    requestId,
+                    tookMs: Date.now() - started,
+                    upstreamCalls,
+                    rateLimit,
+                    recover: [
+                        'resolve_entity { game: "tennis", type: "player", q } for each name',
+                        'Retry head_to_head with returned ids as sideA/sideB',
+                    ],
+                });
+            }
+            const res = await fetchJson(ctx, '/tennis/h2h', {
+                query: { player1_id: tA.id, player2_id: tB.id },
+            });
+            upstreamCalls += 1;
+            rateLimit = { ...rateLimit, ...res.headers };
+            if (!res.ok) {
+                return errorEnvelope({
+                    code: mapHttpToCode(res.status, { gameNotIncluded: gameNotIncludedHint(res.data) }),
+                    message: `Tennis H2H fetch failed (HTTP ${res.status})`,
+                    game,
+                    source: 'head_to_head',
+                    requestId,
+                    tookMs: Date.now() - started,
+                    upstreamCalls,
+                    httpStatus: res.status,
+                    rateLimit,
+                });
+            }
+            const envelope = asRecord(res.data) ?? {};
+            const h2h = asRecord(envelope.data) ?? envelope;
+            return successEnvelope({
+                source: 'head_to_head',
+                game,
+                requestId,
+                tookMs: Date.now() - started,
+                upstreamCalls,
+                rateLimit,
+                data: {
+                    sideA: { idOrSlug: tA.id, name: tA.name },
+                    sideB: { idOrSlug: tB.id, name: tB.name },
+                    h2h,
+                    notes: ['Record and meetings come from the first-class /tennis/h2h endpoint'],
+                },
+            });
+        }
         const meetings = rows
             .map((row) => normalizeMatch(game, row))
             .filter((m) => sidesMatch(m, matchA, matchB))

package/dist/tools/types.js

@@ -1,5 +1,20 @@
-import { toMcpResult } from '../envelope.js';
-export const PRIMARY_GAMES = ['lol', 'cs2', 'dota2', 'cod', 'ufc'];
+import { ENVELOPE_OUTPUT_SCHEMA, toMcpResult } from '../envelope.js';
+/** All curated tools fetch Cito data. None delete, post, or mutate user state. */
+export const READ_TOOL_ANNOTATIONS = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    openWorldHint: true,
+};
+export function toolListing(def) {
+    return {
+        name: def.name,
+        description: def.description,
+        inputSchema: def.inputSchema,
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        annotations: def.annotations ?? READ_TOOL_ANNOTATIONS,
+    };
+}
+export const PRIMARY_GAMES = ['lol', 'cs2', 'dota2', 'cod', 'ufc', 'tennis'];
 export const GAME_ENUM = [...PRIMARY_GAMES, 'all'];
 export function isPrimaryGame(value) {
     return typeof value === 'string' && PRIMARY_GAMES.includes(value);
@@ -15,7 +30,7 @@ export function parseGame(value, opts) {
     const g = value.toLowerCase();
     if (g === 'all') {
         if (opts?.allowAll === false) {
-            return { error: 'game=all is not valid for this tool; pick lol|cs2|dota2|cod|ufc' };
+            return { error: 'game=all is not valid for this tool; pick lol|cs2|dota2|cod|ufc|tennis' };
         }
         return { game: 'all' };
     }
@@ -23,7 +38,7 @@ export function parseGame(value, opts) {
         return { game: g };
     }
     return {
-        error: `unsupported game "${value}"; use lol|cs2|dota2|cod|ufc${opts?.allowAll !== false ? '|all' : ''}`,
+        error: `unsupported game "${value}"; use lol|cs2|dota2|cod|ufc|tennis${opts?.allowAll !== false ? '|all' : ''}`,
     };
 }
 export function gameSchema(opts) {
@@ -33,8 +48,8 @@ export function gameSchema(opts) {
         enum: values,
         description: opts?.description ??
             (opts?.allowAll === false
-                ? 'Game title: lol | cs2 | dota2 | cod | ufc. Example: "cs2".'
-                : 'Game title: lol | cs2 | dota2 | cod | ufc | all. Omit or all for multi-game tools. Example: "lol".'),
+                ? 'Game title: lol | cs2 | dota2 | cod | ufc | tennis. Example: "cs2".'
+                : 'Game title: lol | cs2 | dota2 | cod | ufc | tennis | all. Omit or all for multi-game tools. Example: "lol".'),
     };
 }
 export function limitSchema(opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cito-mcp",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "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": {