cito-mcp 0.3.9 → 0.3.11

package/dist/tools/live.js

@@ -426,8 +426,31 @@ Example: { "game": "lol", "hours": 72, "team": "t1", "limit": 20 }`,
         // also moves paging client-side, because an upstream offset would be
         // counted against rows we are about to discard.
         let clientTeamFilter = false;
+        // Set when this tool, not the upstream, is responsible for paging.
+        let clientDatePaging = false;
         let query = { limit, offset };
-        if (game === 'lol') {
+        lolBranch: if (game === 'lol') {
+            // from/to means a date WINDOW, which /lol/schedule/upcoming cannot serve:
+            // it only knows `hours` forward from now, so asking for last month
+            // silently returned next week's fixtures with an "ignored filter"
+            // warning. /lol/schedule does accept from/to, so route there instead and
+            // let callers list completed matches.
+            if (from || to) {
+                path = '/lol/schedule';
+                clientDatePaging = true;
+                query = {
+                    limit: String(Math.min(200, (offset + limit) * 4)),
+                    ...(from ? { from } : {}),
+                    ...(to ? { to } : {}),
+                    ...(league ? { leagueSlug: league } : {}),
+                    ...(team ? { teamSlug: team } : {}),
+                };
+                if (team)
+                    clientTeamFilter = true;
+                if (tournamentId)
+                    noteIgnored('tournamentId', 'use league filter or standings for LoL tournaments');
+                break lolBranch;
+            }
             path = '/lol/schedule/upcoming';
             // The upstream accepts teamSlug but does not apply it: asking for t1
             // returned Dplus KIA, Team WE and NightBirds. That is a silently wrong
@@ -437,10 +460,13 @@ Example: { "game": "lol", "hours": 72, "team": "t1", "limit": 20 }`,
             // here instead.
             if (team)
                 clientTeamFilter = true;
+            // The upstream accepts `offset` and ignores it, so page two came back
+            // byte for byte identical to page one while the cursor advanced in the
+            // metadata. Over-fetch and slice here instead of trusting it.
+            clientDatePaging = true;
             query = {
                 hours: String(hours),
-                limit: String(clientTeamFilter ? Math.min(200, (offset + limit) * 4) : limit),
-                ...(clientTeamFilter ? {} : { offset: String(offset) }),
+                limit: String(Math.min(200, (offset + limit) * 4)),
                 ...(league ? { leagueSlug: league } : {}),
                 ...(team ? { teamSlug: team } : {}),
             };
@@ -664,8 +690,13 @@ Example: { "game": "lol", "hours": 72, "team": "t1", "limit": 20 }`,
         if (team && beforeTeamFilter > 0 && rows.length === 0) {
             warnings.push(`team "${team}" matched 0 of ${beforeTeamFilter} upcoming fixtures in this window — widen hours or check the slug`);
         }
-        const items = (clientTeamFilter ? rows.slice(offset, offset + limit) : rows.slice(0, limit))
-            .map((row) => normalizeMatch(game, row, 'upcoming'));
+        const pageHere = clientTeamFilter || clientDatePaging;
+        const windowed = pageHere
+            ? rows.slice(Number(offset), Number(offset) + Number(limit))
+            : rows.slice(0, limit);
+        // A date window can contain finished matches, so do not force "upcoming"
+        // onto rows that already carry a real state.
+        const items = windowed.map((row) => from || to ? normalizeMatch(game, row) : normalizeMatch(game, row, 'upcoming'));
         const obj = asRecord(res.data);
         const total = typeof obj?.total === 'number' ? obj.total : null;
         const hasMore = (typeof obj?.hasMore === 'boolean' ? obj.hasMore : items.length >= limit) ||

package/dist/tools/match.js

@@ -481,7 +481,11 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             media: null,
             advanced: null,
         };
-        // base is primary
+        // base is ALWAYS fetched, whatever sections were asked for. Requesting
+        // sections:["timeline"] returned match:null, so a caller got a timeline with
+        // nothing to attach it to and no way to tell which match it belonged to.
+        // 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));
             upstreamCalls += 1;

package/dist/tools/team.js

@@ -8,8 +8,15 @@ import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, stringSc
 function teamIdentity(game, raw, idHint, slugHint) {
     const r = asRecord(raw) ?? {};
     const nested = asRecord(r.data) ?? r;
-    const id = pickString(nested.id, nested.teamId, idHint, slugHint) ?? 'unknown';
     const slug = pickString(nested.slug, nested.orgSlug, slugHint);
+    // When the caller asks for an alias the API resolves it, and the resolved
+    // slug is the truth. Falling back to the requested value for `id` produced
+    // id:"t1a" beside slug:"t1-challengers", a row that disagreed with itself.
+    const resolved = pickString(nested.slug, nested.orgSlug);
+    const id = pickString(nested.id, nested.teamId) ??
+        resolved ??
+        pickString(idHint, slugHint) ??
+        'unknown';
     const name = pickString(nested.name, nested.tag, nested.code, slug, id) ?? id;
     return {
         id,
@@ -301,8 +308,26 @@ Example: { "game": "lol", "slug": "t1", "recentLimit": 10 }`,
                         const t = Date.parse(String(row?.startTime ?? ''));
                         return Number.isFinite(t) ? t : -Infinity;
                     };
+                    // RECENT means finished AND in the past. The index also carries
+                    // scheduled fixtures, and this path forced every row to
+                    // "completed", so Gen.G and HLE both listed their 2026-09-05
+                    // playoff match as a completed result days before it was played.
+                    const nowMs = Date.now();
+                    const isFinished = (row) => {
+                        const r = asRecord(row) ?? {};
+                        const t = Date.parse(String(r.startTime ?? ''));
+                        if (Number.isFinite(t) && t > nowMs)
+                            return false;
+                        const state = String(r.state ?? r.status ?? '').toLowerCase();
+                        if (/unstarted|scheduled|upcoming|not_?started|in_?progress|live/.test(state))
+                            return false;
+                        // No usable state: fall back to the clock plus a decided result.
+                        if (!state)
+                            return Number.isFinite(t) && t <= nowMs;
+                        return /complete|finish|final|ended/.test(state);
+                    };
                     recentMatches = extractRows(res.data)
-                        .slice()
+                        .filter(isFinished)
                         .sort((a, b) => startMs(b) - startMs(a))
                         .slice(0, recentLimit)
                         .map((row) => normalizeMatch('lol', row, 'completed'));

package/package.json

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