cito-mcp 0.4.0 → 0.4.2

package/dist/tools/tournaments.js

@@ -69,6 +69,9 @@ Do not use when: the draw bracket or a specific edition → event_card with the
 
 Tennis-only. Levels accept names (Grand Slam, WTA 1000, ATP 500, Challenger,
 ITF World Tennis Tour, Davis Cup, ...) or raw tier codes (G, M, A, C, D).
+A level name that starts with ATP or WTA also fixes the tour (and conflicts with
+a contradicting tour= argument are rejected), so "WTA 1000" cannot return ATP
+Masters events even though the upstream filter is not tour-aware.
 Note the source does not separate ATP 500 from ATP 250 — both are ATP Tour.
 
 Parallel-safe: yes. Upstream cost: 1.`,
@@ -171,6 +174,44 @@ Parallel-safe: yes. Upstream cost: 1.`,
                 });
             }
         }
+        /**
+         * A level name that starts with a tour token constrains the tour, and the
+         * upstream filter does not know that.
+         *
+         * The API's reverse level map is not tour-aware: `_TIER_WTA` carries BOTH
+         * "PM" and "M" as "WTA 1000" (M is the fallback label for a WTA row stored
+         * with the ATP code), so `?level=WTA 1000` resolves to `tier_code IN
+         * ('PM','M')` and returns every ATP Masters 1000 event alongside the WTA
+         * ones. Verified live: asking for "WTA 1000" returned Rome Masters, Madrid
+         * Masters, Monte Carlo, Miami Masters and Indian Wells Masters (all ATP).
+         * The same widening hits "WTA 125" (code C, shared with ATP Challengers) and
+         * "ATP 500"/"ATP 250" (code A, shared with WTA tour-level rows).
+         *
+         * The tool therefore asserts the invariant the label states: it sends the
+         * tour, and it verifies the rows that come back. Rows that contradict the
+         * requested level are dropped and counted rather than passed through as
+         * "close enough" — a filter that returns other-tour events is worse than a
+         * filter that returns nothing, because the caller has no way to notice.
+         */
+        const levelTourPrefix = (() => {
+            const m = /^(ATP|WTA)\b/i.exec(levelRaw);
+            return m ? m[1].toUpperCase() : null;
+        })();
+        if (levelTourPrefix && tourRaw && tourRaw !== levelTourPrefix) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: `tour ('${tourRaw}') contradicts level ('${levelRaw}'), which names the ${levelTourPrefix} tour`,
+                game,
+                source: 'tournaments',
+                requestId,
+                tookMs: Date.now() - started,
+                recover: [
+                    `Drop tour, or set tour=${levelTourPrefix}`,
+                    'A level name that starts with ATP/WTA already determines the tour',
+                ],
+            });
+        }
+        const effectiveTour = tourRaw || levelTourPrefix || '';
         const limit = clampInt(args.limit, 20, 1, 50);
         const page = clampInt(args.page, 1, 1, 10000);
         const countryCode = typeof args.countryCode === 'string' && args.countryCode.trim()
@@ -182,7 +223,7 @@ Parallel-safe: yes. Upstream cost: 1.`,
                 limit,
                 page,
                 ...(year !== null ? { year } : {}),
-                ...(tourRaw ? { tour: tourRaw } : {}),
+                ...(effectiveTour ? { tour: effectiveTour } : {}),
                 ...(levelRaw ? { level: levelRaw } : {}),
                 ...(surface ? { surface } : {}),
                 ...(countryCode ? { country_code: countryCode } : {}),
@@ -204,17 +245,35 @@ Parallel-safe: yes. Upstream cost: 1.`,
         }
         const root = asRecord(res.data) ?? {};
         const body = asRecord(root.data) ?? root;
-        const items = (Array.isArray(body.items) ? body.items : []).map(normalizeTournament);
+        const rawItems = (Array.isArray(body.items) ? body.items : []).map(normalizeTournament);
+        // Verify the invariant the level label states. See levelTourPrefix above.
+        const contradictions = levelTourPrefix
+            ? rawItems.filter((t) => t.tour && t.tour.toUpperCase() !== levelTourPrefix)
+            : [];
+        const items = contradictions.length
+            ? rawItems.filter((t) => !t.tour || t.tour.toUpperCase() === levelTourPrefix)
+            : rawItems;
         const total = typeof body.total === 'number' ? body.total : items.length;
         const pageSize = typeof body.page_size === 'number' ? body.page_size : limit;
         const filters = [
             year !== null ? String(year) : null,
-            tourRaw || null,
+            effectiveTour || null,
             levelRaw || null,
             surface || null,
             countryCode || null,
             q ? `"${q}"` : null,
         ].filter(Boolean);
+        const warnings = [];
+        if (contradictions.length) {
+            const sample = contradictions
+                .slice(0, 5)
+                .map((t) => `${t.id} (${t.tour})`)
+                .join(', ');
+            warnings.push(`The upstream level filter returned ${contradictions.length} tournament(s) that contradict level="${levelRaw}": ` +
+                `${sample}. They were dropped. The API's level reverse-map is not tour-aware (WTA 1000 resolves to tier codes ` +
+                `PM and M), which is a server-side defect; this tool sends tour=${levelTourPrefix} as well, so a repeat of this ` +
+                `warning means the upstream filter is widening again.`);
+        }
         return successEnvelope({
             pagination: {
                 limit: pageSize,
@@ -230,18 +289,25 @@ Parallel-safe: yes. Upstream cost: 1.`,
             tookMs: Date.now() - started,
             upstreamCalls: 1,
             rateLimit: res.headers,
+            warnings: warnings.length ? warnings : undefined,
             data: {
                 title: filters.length > 0
                     ? `Tennis tournaments — ${filters.join(' ')}`
                     : 'Tennis tournaments',
                 filters: {
                     year,
-                    tour: tourRaw || null,
+                    tour: effectiveTour || null,
                     level: levelRaw || null,
                     surface: surface ?? null,
                     countryCode: countryCode || null,
                     q: q || null,
                 },
+                levelFilterIntegrity: {
+                    levelNamesTour: levelTourPrefix,
+                    rowsChecked: rawItems.length,
+                    contradictionsDropped: contradictions.length,
+                    ok: contradictions.length === 0,
+                },
                 items,
                 total,
                 page,

package/package.json

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