cito-mcp 0.5.6 → 0.5.8

package/README.md

@@ -550,6 +550,14 @@ claude mcp add cito -e CITO_API_KEY=cito_… "--" npx -y cito-mcp
 
 ## Changelog (summary)
 
+### 0.5.8
+
+- Tennis `player_rankings_history` asks `/tennis/rankings/history/{id}` for one page (`limit`, new `page`, `since` sent as `from`) instead of downloading the whole career and slicing it; page 1 is the newest `limit` rows, returned oldest-first as before. `omittedOlder` counts rows at the old end, new `omittedNewer` the rows on earlier (newer) pages, `hasMore` is the route's own `has_next`.
+
+### 0.5.7
+
+- Tennis `event_card`: `event.drawSize` and `draw.drawSize` are the API's stored draw size, the same value `/tennis/tournaments/{id}` serves (it is now corrected to the proven size: Paris 56, Shanghai 96). `drawSizeVerified` says a proof stands behind it; `draw.drawSizeDerived` is what the edition's own bracket shows.
+
 ### 0.5.6
 
 - **Tennis `event_card` draw is a real bracket** (customer audit 2026-11-03). `draw.complete` is true only when every main round to the Final is played (it said true beside `missingRounds` F/SF/QF); every main round is listed with `status` (`completed` / `in_progress` / `not_started` / `incomplete_archive`), `expected` (byes excluded: a 56 draw's R64 holds 24), `byes`, `walkovers`, and `pending` (scheduled / live matches, never presented as results). `drawSize` is the real field (Paris 56, `drawSizeSource`, `bracketSize`, `byes`); `matchesExpected` counts the main draw and is compared with `mainDrawMatchesReturned` (qualifying is reported apart). Each bout carries `winnerId` / `loserId` / `outcome` (a "6-3 6-7 RET" retirement says who won), `startTime`, `nextMatchId` (the bracket edge) and `bracketPosition`; rounds report `included` / `omitted` when `drawMaxMatches` trims them.

package/dist/tools/insight.js

@@ -1230,6 +1230,7 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "i
                     tier: pickString(d.tier) ?? null,
                     surface: pickString(d.surface) ?? null,
                     drawSize: typeof d.draw_size === 'number' ? d.draw_size : null,
+                    drawSizeVerified: typeof d.draw_size_verified === 'boolean' ? d.draw_size_verified : null,
                     city: pickString(d.city) ?? null,
                     country: pickString(d.country_code) ?? null,
                     editions: { first: d.first_edition_year ?? null, mostRecent: d.most_recent_edition_year ?? null },
@@ -1397,6 +1398,8 @@ Example: { "game": "ufc", "eventIdOrSlug": "ufc-300", "includeMatches": true, "i
                     drawSummary = {
                         drawSize,
                         drawSizeSource: pickString(dd.draw_size_source) ?? null,
+                        drawSizeVerified: typeof dd.draw_size_verified === 'boolean' ? dd.draw_size_verified : null,
+                        drawSizeDerived: num(dd.draw_size_derived),
                         bracketSize: num(dd.bracket_size),
                         byes: num(dd.byes),
                         roundCount: drawRounds.length,

package/dist/tools/rankings.js

@@ -256,10 +256,11 @@ Prefer over: standings (latest snapshot only); rankings_movers (week-over-week d
 Do not use when: the current top-N table → standings with game tennis.
 
 Tennis-only. Rows arrive oldest-first (chronological), which is the order a chart
-wants; the newest entries are the tail. limit keeps the most RECENT N rows (the
-route itself ignores ?limit=, so the bound is applied here) — hasMore and
-oldestReturned/newestReturned say exactly which window came back, and
-omittedOlder counts the rows left behind at the old end.
+wants; the newest entries are the tail. limit + page walk the series from the most
+RECENT end (page 1 = the newest limit rows, page 2 the ones before them); the route
+pages itself. hasMore and oldestReturned/newestReturned say exactly which window came
+back, omittedOlder counts the rows left at the old end and omittedNewer the rows on
+earlier (newer) pages.
 
 Parallel-safe: yes. Upstream cost: 1.`,
     inputSchema: {
@@ -271,6 +272,7 @@ Parallel-safe: yes. Upstream cost: 1.`,
             playerId: stringSchema('Tennis player id, e.g. "atp_207989" or "wta_214544".', 'atp_207989'),
             since: stringSchema('Only rows on or after this date (YYYY-MM-DD).', '2026-01-01'),
             limit: limitSchema({ default: 20, max: 500, description: 'Max history rows (default 20, max 500).' }),
+            page: { type: 'integer', minimum: 1, default: 1, description: 'Page from the newest end (1 = the most recent limit rows).' },
         },
     },
     handler: async (args, ctx) => {
@@ -323,8 +325,9 @@ Parallel-safe: yes. Upstream cost: 1.`,
             });
         }
         const limit = clampInt(args.limit, 20, 1, 500);
+        const page = clampInt(args.page, 1, 1, 100000);
         const res = await fetchJson(ctx, `/tennis/rankings/history/${encodeURIComponent(playerId)}`, {
-            query: { limit },
+            query: { limit, page, ...(sinceRaw ? { from: sinceRaw } : {}) },
         });
         if (!res.ok) {
             return errorEnvelope({
@@ -354,8 +357,21 @@ Parallel-safe: yes. Upstream cost: 1.`,
         const inWindow = sinceRaw
             ? allHistory.filter((h) => h.date !== null && h.date >= sinceRaw)
             : allHistory;
-        const total = inWindow.length;
-        const history = total > limit ? inWindow.slice(total - limit) : inWindow;
+        const pagedUpstream = typeof body.total === 'number' && typeof body.order === 'string';
+        let total;
+        let history;
+        if (pagedUpstream) {
+            total = body.total;
+            history = body.order === 'desc' ? [...inWindow].reverse() : inWindow;
+        }
+        else {
+            total = inWindow.length;
+            const end = Math.max(0, total - (page - 1) * limit);
+            history = inWindow.slice(Math.max(0, end - limit), end);
+        }
+        const omittedNewer = Math.min(total, (page - 1) * limit);
+        const omittedOlder = Math.max(0, total - omittedNewer - history.length);
+        const hasMore = pagedUpstream && typeof body.has_next === 'boolean' ? body.has_next : omittedOlder > 0;
         const best = history.reduce((acc, h) => {
             if (h.rank === null)
                 return acc;
@@ -366,9 +382,9 @@ Parallel-safe: yes. Upstream cost: 1.`,
         return successEnvelope({
             pagination: {
                 limit,
-                offset: total - history.length,
+                offset: omittedNewer,
                 total,
-                hasMore: total > history.length,
+                hasMore,
                 nextCursor: null,
                 prevCursor: null,
             },
@@ -391,7 +407,9 @@ Parallel-safe: yes. Upstream cost: 1.`,
                 history,
                 totalInWindow: total,
                 returned: history.length,
-                omittedOlder: total - history.length,
+                omittedOlder,
+                omittedNewer,
+                page,
                 oldestReturned: history.length ? history[0].date : null,
                 newestReturned: history.length ? history[history.length - 1].date : null,
             },

package/package.json

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