cito-mcp 0.3.10 → 0.3.12

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

@@ -389,6 +389,102 @@ Example: { "game": "cs2", "matchId": "cs2-match-123", "view": "summary", "includ
         });
     },
 };
+/**
+ * Fold a UFC bout's raw odds payload into something an agent can read.
+ *
+ * The REST response is deliberately complete: every bookmaker, every market, up
+ * to roughly 950 outcomes for a single bout. Handing that back whole would bury
+ * the two numbers a caller almost always wants, and the server's own
+ * instructions say not to flood odds. So the moneyline is summarised per fighter
+ * and every other market is reduced to a count, with the raw endpoint named so
+ * anyone who genuinely needs the full book can go and get it.
+ *
+ * isAvailable is carried through as currentlyOffered rather than filtered on. It
+ * means "a book is offering this right now", so a finished fight's closing line
+ * comes back with it false, and that is information rather than absence.
+ * Filtering here would recreate the bug where whole settled cards looked like
+ * they had no odds at all.
+ */
+export function summarizeUfcOdds(data) {
+    // fetchJson hands back the whole REST envelope ({ success, data, meta }), not
+    // the inner payload, so unwrap one level when it is there. Accepting both
+    // shapes because the unit tests feed the inner object directly; reading only
+    // the outer one returned a perfectly shaped, perfectly empty summary, which
+    // looked like "this bout has no odds" rather than like a bug.
+    const root = (data ?? {});
+    const payload = (root.data && typeof root.data === 'object' && !Array.isArray(root.data)
+        ? root.data
+        : root);
+    const markets = Array.isArray(payload.markets) ? payload.markets : [];
+    const byFighter = new Map();
+    const otherMarkets = new Map();
+    let observedAt = null;
+    for (const market of markets) {
+        const outcomes = Array.isArray(market.outcomes) ? market.outcomes : [];
+        for (const outcome of outcomes) {
+            const observed = typeof outcome.observedAt === 'string' ? outcome.observedAt : null;
+            if (observed && (!observedAt || observed > observedAt))
+                observedAt = observed;
+            const fighter = (outcome.fighter ?? {});
+            const bookmaker = (outcome.bookmaker ?? {});
+            const slug = typeof fighter.slug === 'string' ? fighter.slug : null;
+            const type = typeof outcome.marketType === 'string' ? outcome.marketType : 'unknown';
+            const book = typeof bookmaker.slug === 'string' ? bookmaker.slug : 'unknown';
+            if (type === 'moneyline' && slug) {
+                const entry = byFighter.get(slug) ?? {
+                    slug,
+                    name: typeof fighter.name === 'string' ? fighter.name : null,
+                    side: typeof outcome.side === 'string' ? outcome.side : null,
+                    prices: [],
+                    books: new Set(),
+                    live: false,
+                };
+                if (typeof outcome.moneyline === 'number')
+                    entry.prices.push(outcome.moneyline);
+                entry.books.add(book);
+                if (outcome.isAvailable === true)
+                    entry.live = true;
+                byFighter.set(slug, entry);
+                continue;
+            }
+            const other = otherMarkets.get(type) ?? { outcomes: 0, books: new Set() };
+            other.outcomes += 1;
+            other.books.add(book);
+            otherMarkets.set(type, other);
+        }
+    }
+    // American odds: the best price is the highest number both for an underdog
+    // (+250 beats +180) and for a favourite (-110 beats -200), so it is simply the
+    // maximum in both cases.
+    const moneyline = [...byFighter.values()].map((entry) => {
+        const sorted = [...entry.prices].sort((a, b) => a - b);
+        const mid = sorted.length
+            ? sorted.length % 2
+                ? sorted[(sorted.length - 1) / 2]
+                : Math.round((sorted[sorted.length / 2 - 1] + sorted[sorted.length / 2]) / 2)
+            : null;
+        return {
+            fighter: { slug: entry.slug, name: entry.name },
+            side: entry.side,
+            bookmakers: entry.books.size,
+            bestAmerican: sorted.length ? sorted[sorted.length - 1] : null,
+            medianAmerican: mid,
+            impliedProbability: mid === null ? null : Number((mid > 0 ? 100 / (mid + 100) : -mid / (-mid + 100)).toFixed(4)),
+            currentlyOffered: entry.live,
+        };
+    });
+    return {
+        moneyline,
+        otherMarkets: [...otherMarkets.entries()]
+            .map(([type, value]) => ({ type, outcomes: value.outcomes, bookmakers: value.books.size }))
+            .sort((a, b) => b.outcomes - a.outcomes),
+        observedAt,
+        notes: moneyline.some((row) => !row.currentlyOffered)
+            ? 'currentlyOffered=false means the market has closed; these are closing lines, not live prices.'
+            : undefined,
+        fullBookPath: '/ufc/bouts/{boutId}/odds',
+    };
+}
 export const matchDetails = {
     name: 'match_details',
     description: `Deep match package: optional timelines, advanced stats, live state/snapshots, full map/game tree, media inventory.
@@ -404,6 +500,7 @@ Prefer match_summary for short answers and default cards.
 Do not use when: first-pass live board (use live_matches + match_summary).
 
 Section selection: pass includeTimeline / includeLiveState / includeAdvanced booleans, OR an explicit sections[] list.
+UFC betting lines: sections:["odds"] (opt-in, never in the default set).
 If sections[] is non-empty it wins (booleans are ignored). LoL liveState/advanced require gameId.
 
 Parallel-safe: yes. Upstream cost: 1–8 (section-gated).
@@ -420,9 +517,9 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 type: 'array',
                 items: {
                     type: 'string',
-                    enum: ['base', 'playerStats', 'gamesOrMaps', 'timeline', 'liveState', 'media', 'advanced'],
+                    enum: ['base', 'playerStats', 'gamesOrMaps', 'timeline', 'liveState', 'media', 'advanced', 'odds'],
                 },
-                description: 'Explicit section list; defaults to base+playerStats+gamesOrMaps+media.',
+                description: 'Explicit section list; defaults to base+playerStats+gamesOrMaps+media. "odds" (UFC) is opt-in: moneyline summarised per fighter with bookmaker count, best and median American price and implied probability, plus a count of every other market. Closing lines for a finished fight come back with currentlyOffered=false rather than being omitted.',
             },
             includeTimeline: boolSchema('Include timeline section (heavy).', false),
             includeLiveState: boolSchema('Include live state/snapshots.', false),
@@ -476,12 +573,17 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             base: null,
             playerStats: null,
             gamesOrMaps: null,
+            odds: null,
             timeline: null,
             liveState: null,
             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;
@@ -520,6 +622,28 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 }
             })());
         };
+        // Same as load(), but folds the payload through a shaper first. Raw odds are
+        // far too big to hand back whole: one bout carries up to ~950 outcomes across
+        // every bookmaker and prop market, which would bury the answer it was fetched
+        // to give.
+        const loadWith = (section, path, shape, query) => {
+            tasks.push((async () => {
+                const res = await getSection(ctx, path, query);
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (!res.ok) {
+                    partial.push(partialFromRejection(section, {
+                        code: mapHttpToCode(res.status),
+                        message: `${section} HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                    sections[section] = null;
+                }
+                else {
+                    sections[section] = shape(res.data);
+                }
+            })());
+        };
         if (wanted.has('playerStats')) {
             if (game === 'lol')
                 load('playerStats', `/lol/matches/${encodeURIComponent(matchId)}/player-stats`);
@@ -573,6 +697,17 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
                 }));
             }
         }
+        if (wanted.has('odds')) {
+            if (game === 'ufc') {
+                loadWith('odds', `/ufc/bouts/${encodeURIComponent(matchId)}/odds`, summarizeUfcOdds);
+            }
+            else {
+                partial.push(partialFromRejection('odds', {
+                    code: 'NOT_IMPLEMENTED',
+                    message: `Odds not curated for ${game}; UFC only today`,
+                }));
+            }
+        }
         if (wanted.has('media')) {
             if (game === 'cs2')
                 load('media', `/cs2/matches/${encodeURIComponent(matchId)}/demos`);

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.10",
+  "version": "0.3.12",
   "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": {