cito-mcp 0.3.11 → 0.3.12

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,6 +573,7 @@ Example: { "game": "lol", "matchId": "lol-match-1", "includeTimeline": true, "in
             base: null,
             playerStats: null,
             gamesOrMaps: null,
+            odds: null,
             timeline: null,
             liveState: null,
             media: null,
@@ -524,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`);
@@ -577,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/package.json

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