cito-mcp 0.4.9 → 0.5.2

package/README.md

@@ -4,7 +4,7 @@ Standalone [MCP](https://modelcontextprotocol.io) server for the [Cito esports A
 
 **Version:** `0.4.9` · **Node:** `>=20` · **Install:** `npx cito-mcp`
 
-Primary games & sports: **lol · cs2 · dota2 · cod · ufc · tennis**, plus **RAF wrestling**, **BKFC bare knuckle** and the **Bellator MMA archive** (2014-2017) through the `combat_*` tools. Long-tail REST stays available via `call_api`.
+Primary games & sports: **lol · cs2 · dota2 · cod · ufc · tennis**, plus **RAF wrestling**, **BKFC bare knuckle** and the **non-UFC MMA archives** (Bellator, PRIDE, Strikeforce, WEC, DREAM, EliteXC, Affliction, and `mma` across all of them) through the `combat_*` tools. Long-tail REST stays available via `call_api`.
 
 ---
 
@@ -244,13 +244,13 @@ upstream, so a non-null `headshotUrl` always has a `license` beside it.
 
 ### Combat leagues (`combat_*`, `league` argument)
 
-RAF, BKFC and Bellator are not on the `game` enum. `combat_events`, `combat_card`, `combat_bout`, `combat_athlete`, `combat_h2h` and `combat_rankings` take `league: "raf" | "bkfc" | "bellator"`, and `call_api` reaches `/raf`, `/bkfc` and `/bellator`. None of them is ever mixed into UFC answers.
+RAF, BKFC and the MMA archives are not on the `game` enum. `combat_events`, `combat_card`, `combat_bout`, `combat_athlete`, `combat_h2h` and `combat_rankings` take `league: "raf" | "bkfc" | "bellator" | "pride" | "strikeforce" | "wec" | "dream" | "elitexc" | "affliction" | "mma"`, and `call_api` reaches each of those prefixes. None of them is ever mixed into UFC answers.
 
 | League | Scoring | Notes |
 | --- | --- | --- |
 | `raf` | per PERIOD (wrestling points, takedowns) | Athletes; champions per division |
 | `bkfc` | per ROUND (punches landed/thrown, knockdowns) | Fighters; official rankings + champions |
-| `bellator` | per ROUND, official stats in UFC's shape (`"13 of 18"`, `controlTime "1:42"`, round 0 = whole fight; knockdowns, submission attempts, reversals) | Closed archive: Bellator 131-172 (Nov 2014 - Feb 2017), ~20 cards / ~230 bouts. Bout ids like `bellator-5600`, event slugs like `bellator-142` (or `142`). A fighter we also hold a UFC record for keeps the **same slug** as `/ufc/fighters/{slug}` (`ufcFighterSlug`). No live data, rankings or upcoming cards: `combat_events` `when:"upcoming"` returns `[]` with a note (default is `recent`), `combat_card` `event:"last"` is the most recent card (the default) and `"next"` is a non-retryable `NOT_IMPLEMENTED`, `combat_rankings` is a non-retryable `NOT_IMPLEMENTED`. All of it is older than the Free (30-day) / Starter (90-day) history window, so its stats are Pro: on those plans round stats come back as a `HISTORY_WINDOW_EXCEEDED` partial note while results still return. |
+| MMA archives: `bellator`, `pride`, `strikeforce`, `wec`, `dream`, `elitexc`, `affliction`, `mma` | per ROUND, official stats in UFC's shape (`"13 of 18"`, `controlTime "1:42"`, round 0 = whole fight; knockdowns, submission attempts, reversals) | Closed archives on one API router with identical routes: Bellator 131-172 (2014-2017), PRIDE 1997-2007 (PRIDE rules: 10-minute first round, then 5-minute rounds), Strikeforce 2006-2013, WEC 2001-2010, DREAM 2008-2012, EliteXC 2007-2008, Affliction 2008-2009. `mma` is every promotion at once: a fighter's whole non-UFC career, with `recordByPromotion` on `combat_athlete`, and `recent` / `last` across promotions; every bout and event carries its real `promotion`. Event slugs like `bellator-142`, `pride-34`, `wec-48`, `strikeforce-barnett-vs-cormier`; bout ids `<promotion>-<fightId>` (a bare fight id resolves in any archive). A fighter we also hold a UFC record for keeps the **same slug** as `/ufc/fighters/{slug}` (`ufcFighterSlug`). No live data, rankings or upcoming cards: `combat_events` `when:"upcoming"` returns `[]` with a note (default is `recent`), `combat_card` `event:"last"` is the most recent card (the default) and `"next"` is a non-retryable `NOT_IMPLEMENTED`, `combat_rankings` is a non-retryable `NOT_IMPLEMENTED`. All of it is older than the Free (30-day) / Starter (90-day) history window, so its stats are Pro: on those plans round stats come back as a `HISTORY_WINDOW_EXCEEDED` partial note while results still return. |
 
 ### UFC projection notes (0.2.4)
 
@@ -269,7 +269,7 @@ Fortnite: **`call_api` only** until promoted into the primary enum.
 
 Path must start with `/` and match one of:
 
-`/health` · `/lol` · `/cs2` · `/dota2` · `/cod` · `/ufc` · `/fortnite` · `/tennis` · `/raf` · `/bkfc` · `/bellator` · `/openapi.json`
+`/health` · `/lol` · `/cs2` · `/dota2` · `/cod` · `/ufc` · `/fortnite` · `/tennis` · `/raf` · `/bkfc` · `/bellator` · `/pride` · `/strikeforce` · `/wec` · `/dream` · `/elitexc` · `/affliction` · `/mma` · `/openapi.json`
 
 Absolute URLs and `..` traversal → `PATH_NOT_ALLOWED`. Prefer curated tools for all standard jobs.
 
@@ -552,8 +552,8 @@ claude mcp add cito -e CITO_API_KEY=cito_… "--" npx -y cito-mcp
 
 ### 0.4.9
 
-- **Bellator MMA archive** (`/api/v1/bellator`): `league: "bellator"` on every `combat_*` tool, and `/bellator` on the `call_api` / `list_routes` allowlist. Bellator 131-172 (Nov 2014 - Feb 2017) with official per-round stats in `/ufc`'s shape; fighters with a UFC record share the UFC slug (`combat_athlete` returns `ufcFighterSlug`). Archive gaps are answered honestly: upcoming events are an empty list with a note, `combat_card` defaults to the most recent card and refuses `"next"`, and `combat_rankings` returns a non-retryable `NOT_IMPLEMENTED`. `HISTORY_WINDOW_EXCEEDED` sections are reported as a plan gap (Pro), not as a key problem.
-- Agent guidance (server instructions, `list_capabilities`): Bellator is never mixed into UFC answers; UFC already includes Dana White's Contender Series and **Road to UFC** (2022-2026, all 19 cards with official round stats, slugs like `road-to-ufc-2-7`).
+- **Non-UFC MMA archives**: `league` `bellator` (2014-2017), `pride` (1997-2007), `strikeforce` (2006-2013), `wec` (2001-2010), `dream` (2008-2012), `elitexc` (2007-2008), `affliction` (2008-2009) and `mma` (all of them at once) on every `combat_*` tool, and `/bellator` `/pride` `/strikeforce` `/wec` `/dream` `/elitexc` `/affliction` `/mma` on the `call_api` / `list_routes` allowlist. Official per-round stats in `/ufc`'s shape; fighters with a UFC record share the UFC slug (`combat_athlete` returns `ufcFighterSlug`, and under `mma` the whole non-UFC career split by `recordByPromotion`); `mma` events `recent` and `combat_card` `last` work across promotions. Archive gaps are answered honestly: upcoming events are an empty list with a note, `combat_card` defaults to the most recent card and refuses `"next"`, and `combat_rankings` returns a non-retryable `NOT_IMPLEMENTED`. `HISTORY_WINDOW_EXCEEDED` sections are reported as a plan gap (Pro), not as a key problem.
+- Agent guidance (server instructions, `list_capabilities`): the MMA archives are never mixed into UFC answers; UFC already includes Dana White's Contender Series and **Road to UFC** (2022-2026, all 19 cards with official round stats, slugs like `road-to-ufc-2-7`).
 
 ### 0.4.8
 

package/dist/envelope.js

@@ -38,7 +38,7 @@ export const DEFAULT_RECOVER = {
         'Call api_health to see which games your plan includes',
     ],
     PATH_NOT_ALLOWED: [
-        'Use only allowlisted path prefixes: /health /lol /cs2 /dota2 /cod /ufc /fortnite /tennis /raf /bkfc /bellator',
+        'Use only allowlisted path prefixes: /health /lol /cs2 /dota2 /cod /ufc /fortnite /tennis /raf /bkfc, MMA archives /bellator /pride /strikeforce /wec /dream /elitexc /affliction /pfl /oktagon /mma',
         'Prefer a curated tool from list_capabilities when one covers the outcome',
     ],
     NOT_IMPLEMENTED: [

package/dist/instructions.js

@@ -18,7 +18,9 @@ game enum (unless a tool documents otherwise): lol | cs2 | dota2 | ufc | cod | t
 - On UNSUPPORTED_GAME / 403 for a title: stop retrying that game; call api_health; report plan gaps.
 - Fortnite and other titles may appear via call_api/resources; do not assume they are in the curated enum until list_capabilities says so.
 - RAF (Real American Freestyle wrestling) and BKFC (Bare Knuckle Fighting Championship) are NOT on the game enum: use the combat_* tools with league raf|bkfc (combat_events, combat_card, combat_bout, combat_athlete, combat_h2h, combat_rankings), or call_api /raf/... and /bkfc/.... RAF scores per PERIOD (wrestling points, takedowns); BKFC per ROUND (punches landed/thrown, knockdowns). Never mix either into UFC answers.
-- Bellator MMA is not on the enum either: combat_* tools with league bellator, or call_api /bellator/.... A closed 2014-2017 archive (Bellator 131-172) with official per-ROUND stats in UFC's shape ("13 of 18", round 0 = whole fight); no live, rankings or upcoming cards (combat_card "last" = most recent card). A fighter with a UFC record keeps the SAME slug as /ufc/fighters/{slug} (ufcFighterSlug). Never mix Bellator fights into UFC answers. Its stats predate the Free/Starter window: HISTORY_WINDOW_EXCEEDED means Pro, not a bad key.
+- MMA archives: Bellator, PRIDE, Strikeforce, WEC, DREAM, EliteXC, Affliction, plus /mma for a fighter's whole non-UFC career (recordByPromotion). combat_* tools with league bellator|pride|strikeforce|wec|dream|elitexc|affliction|mma, or call_api /{league}/.... Closed archives (1997-2017) with official per-ROUND stats in UFC's shape ("13 of 18", round 0 = whole fight); no live, rankings or upcoming cards (combat_card "last" = most recent card). Fighters share their UFC slug (ufcFighterSlug). Never mix these into UFC answers. Their stats predate the Free/Starter window: HISTORY_WINDOW_EXCEEDED means Pro, not a bad key.
+- PFL (Professional Fighters League): combat_* with league pfl, or call_api /pfl/.... Every card since 2018, upcoming cards (combat_events when upcoming, combat_card "next") and live fight status (/pfl/live: bout status "live" with live.round / live.clock). Results only (winner, method, round, time): no strike or round stats exist for PFL. league mma includes PFL. Never mix into UFC answers.
+- OKTAGON MMA: combat_* with league oktagon, or call_api /oktagon/.... Every card since Oktagon 1 (2016), upcoming cards and live fight status. Per-ROUND stats on most bouts, LANDED ONLY: significant/total strikes, head/body/leg and takedowns as plain counts (landed.*), plus submission attempts; attempts, accuracy, knockdowns and control time are null because the source does not log them (each bout's statsCoverage says which fields exist). Fighters share their UFC slug when proven. league mma includes OKTAGON. Never mix into UFC answers.
 - UFC includes DWCS and Road to UFC (2022-2026, all 19 cards with official round stats; slugs like road-to-ufc-2-7, "Road to UFC 2.7").
 
 ## Preferred tool order

package/dist/tools/combat.js

@@ -1,22 +1,46 @@
 import { asRecord, clampInt, extractRows, fetchJson, gameNotIncludedHint } from '../client.js';
 import { errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
 import { boolSchema, limitSchema, stringSchema } from './types.js';
-export const COMBAT_LEAGUES = ['raf', 'bkfc', 'bellator'];
+export const MMA_ARCHIVE_LEAGUES = ['bellator', 'pride', 'strikeforce', 'wec', 'dream', 'elitexc', 'affliction'];
+export const MMA_LEAGUES = [...MMA_ARCHIVE_LEAGUES, 'pfl', 'oktagon', 'mma'];
+export const COMBAT_LEAGUES = ['raf', 'bkfc', ...MMA_LEAGUES];
+const isMma = (league) => MMA_LEAGUES.includes(league);
 const LEAGUE_NAMES = {
     raf: 'Real American Freestyle (pro freestyle wrestling)',
     bkfc: 'Bare Knuckle Fighting Championship',
     bellator: 'Bellator MMA',
+    pride: 'PRIDE Fighting Championships',
+    strikeforce: 'Strikeforce',
+    wec: 'World Extreme Cagefighting',
+    dream: 'DREAM',
+    elitexc: 'EliteXC',
+    affliction: 'Affliction Entertainment',
+    pfl: 'Professional Fighters League',
+    oktagon: 'OKTAGON MMA',
+    mma: 'MMA beyond the UFC (every non-UFC promotion we hold, PFL and OKTAGON included)',
 };
 const ARCHIVES = {
-    bellator: 'Bellator is a closed archive (Bellator 131-172, November 2014 to February 2017)',
+    bellator: { short: 'Bellator', note: 'Bellator is a closed archive (2014-2024; official round stats for Bellator 131-172, results only after that)' },
+    pride: { short: 'PRIDE', note: 'PRIDE is a closed archive (1997-2007; PRIDE rules: a 10-minute first round, then 5-minute rounds)' },
+    strikeforce: { short: 'Strikeforce', note: 'Strikeforce is a closed archive (2006-2013)' },
+    wec: { short: 'WEC', note: 'WEC is a closed archive (2001-2010, until it merged into the UFC)' },
+    dream: { short: 'DREAM', note: 'DREAM is a closed archive (2008-2012)' },
+    elitexc: { short: 'EliteXC', note: 'EliteXC is a closed archive (2007-2008)' },
+    affliction: { short: 'Affliction', note: 'Affliction is a closed archive (2008-2009)' },
 };
-const PEOPLE = { raf: 'athletes', bkfc: 'fighters', bellator: 'fighters' };
-const HISTORY = { raf: 'bouts', bkfc: 'fights', bellator: 'fights' };
+function archiveOf(league) {
+    return ARCHIVES[league];
+}
+const PEOPLE = (league) => (league === 'raf' ? 'athletes' : 'fighters');
+const HISTORY = (league) => (league === 'raf' ? 'bouts' : 'fights');
 const leagueSchema = {
     type: 'string',
     enum: [...COMBAT_LEAGUES],
-    description: 'League: "raf" (Real American Freestyle wrestling), "bkfc" (Bare Knuckle Fighting Championship) or "bellator" ' +
-        '(Bellator MMA archive, 2014-2017). Example: "bkfc".',
+    description: 'League: "raf" (Real American Freestyle wrestling), "bkfc" (Bare Knuckle Fighting Championship), or an MMA archive: ' +
+        '"bellator" (2014-2017), "pride" (1997-2007), "strikeforce" (2006-2013), "wec" (2001-2010), "dream" (2008-2012), ' +
+        '"elitexc" (2007-2008), "affliction" (2008-2009), "pfl" (PFL, 2018 to now: upcoming cards, live fight status, results only), ' +
+        '"oktagon" (OKTAGON MMA, 2016 to now: upcoming cards, live fight status, per-round LANDED strikes by target and takedowns), ' +
+        'or "mma" (all of them at once). Example: "bkfc".',
 };
 function parseLeague(value) {
     const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
@@ -25,7 +49,7 @@ function parseLeague(value) {
 function leagueError(d, value) {
     return errorEnvelope({
         code: 'VALIDATION',
-        message: `league must be raf, bkfc or bellator (got ${JSON.stringify(value ?? null)})`,
+        message: `league must be one of ${COMBAT_LEAGUES.join(', ')} (got ${JSON.stringify(value ?? null)})`,
         game: null,
         source: d.source,
         requestId: d.requestId,
@@ -75,7 +99,7 @@ function sectionFailure(section, res, league) {
     if (isHistoryWindow(res)) {
         message =
             `${section} is older than this key's history window (HISTORY_WINDOW_EXCEEDED: Free 30 days, Starter 90 days; ` +
-                `Pro reads the full archive)` + (league && ARCHIVES[league] ? `. ${ARCHIVES[league]}, so all of its stats need Pro` : '');
+                `Pro reads the full archive)` + (league && archiveOf(league) ? `. ${archiveOf(league).note}, so all of its stats need Pro` : '');
     }
     else if (res.status === 403) {
         message = `${section} needs the Starter plan or above for this league (${err?.message || 'plan restriction'})`;
@@ -98,7 +122,7 @@ function archiveGap(d, league, message, recover, calls = 0) {
 async function resolvePerson(ctx, league, input) {
     const raw = input.trim();
     if (/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(raw)) {
-        const probe = await fetchJson(ctx, `/${league}/${PEOPLE[league]}/${encodeURIComponent(raw)}`);
+        const probe = await fetchJson(ctx, `/${league}/${PEOPLE(league)}/${encodeURIComponent(raw)}`);
         if (probe.ok)
             return { slug: raw };
         if (probe.status !== 404)
@@ -129,7 +153,7 @@ async function resolveOrFail(d, ctx, league, input, argName) {
         return {
             fail: errorEnvelope({
                 code: 'AMBIGUOUS_ENTITY',
-                message: `"${input}" matches several ${PEOPLE[league]}; pass one slug from details.candidates`,
+                message: `"${input}" matches several ${PEOPLE(league)}; pass one slug from details.candidates`,
                 game: league,
                 source: d.source,
                 requestId: d.requestId,
@@ -141,7 +165,7 @@ async function resolveOrFail(d, ctx, league, input, argName) {
     return {
         fail: errorEnvelope({
             code: 'NOT_FOUND',
-            message: `No ${league.toUpperCase()} ${PEOPLE[league].slice(0, -1)} matches "${input}"`,
+            message: `No ${league.toUpperCase()} ${PEOPLE(league).slice(0, -1)} matches "${input}"`,
             game: league,
             source: d.source,
             requestId: d.requestId,
@@ -154,17 +178,18 @@ function begin(source) {
 }
 export const combatEvents = {
     name: 'combat_events',
-    description: `RAF wrestling, BKFC bare-knuckle or Bellator MMA events: upcoming cards or recent results.
+    description: `RAF wrestling, BKFC bare-knuckle or MMA archive (Bellator, PRIDE, Strikeforce, WEC, DREAM, EliteXC, Affliction) events.
 
 When to use:
-- "When is the next RAF / BKFC card?", "recent BKFC results", "Bellator cards from 2015", schedule pages
+- "When is the next RAF / BKFC card?", "recent BKFC results", "PRIDE results", "Bellator cards from 2015", schedule pages
 - Getting an event slug for combat_card
 
 Each event carries slug, name, date, local start time + timezone, venue/location, status and bout counts.
-Bellator is a closed archive (Bellator 131-172, Nov 2014 - Feb 2017): "when" defaults to "recent" (newest card
-first), and "upcoming" returns an empty list with data.note instead of failing.
+The MMA archives (bellator, pride, strikeforce, wec, dream, elitexc, affliction, and mma = all of them, each
+event tagged with its real promotion) are closed: "when" defaults to "recent" (newest card first), and "upcoming"
+returns an empty list with data.note instead of failing.
 
-Prefer over: call_api /raf/events, /bkfc/events or /bellator/events.
+Prefer over: call_api /{league}/events.
 Do not use when: you already have the event slug and want its bouts (combat_card).
 
 Parallel-safe: yes. Upstream cost: 1.
@@ -180,7 +205,7 @@ Example: { "league": "bkfc", "when": "upcoming", "limit": 5 }`,
                 enum: ['upcoming', 'recent'],
                 default: 'upcoming',
                 description: 'upcoming = scheduled cards, soonest first; recent = completed cards, newest first. Default "upcoming" ' +
-                    '("recent" for bellator, an archive). Example: "recent".',
+                    '("recent" for the MMA archives). Example: "recent".',
             },
             limit: limitSchema({ default: 10, max: 50, description: 'Max events (default 10, max 50).' }),
         },
@@ -190,14 +215,14 @@ Example: { "league": "bkfc", "when": "upcoming", "limit": 5 }`,
         const league = parseLeague(args.league);
         if (!league)
             return leagueError(d, args.league);
-        const archive = ARCHIVES[league];
+        const archive = archiveOf(league);
         const when = args.when === 'recent' || args.when === 'upcoming' ? args.when : archive ? 'recent' : 'upcoming';
         const limit = clampInt(args.limit, 10, 1, 50);
         if (archive && when === 'upcoming') {
             return successEnvelope({
                 data: {
                     league, leagueName: LEAGUE_NAMES[league], when, count: 0, events: [],
-                    note: `${archive}: there are no upcoming cards. Use when "recent" for its cards, newest first.`,
+                    note: `${archive.note}: there are no upcoming cards. Use when "recent" for its cards, newest first.`,
                 },
                 game: league,
                 source: d.source,
@@ -223,18 +248,18 @@ Example: { "league": "bkfc", "when": "upcoming", "limit": 5 }`,
 };
 export const combatCard = {
     name: 'combat_card',
-    description: `COMPOSITE fight card for one RAF, BKFC or Bellator event: event identity + bouts in running order with results.
+    description: `COMPOSITE fight card for one RAF, BKFC or MMA archive event: event identity + bouts in running order with results.
 
 When to use:
-- "RAF 14 card", "BKFC 95 results", "Bellator 142 card", "who won the main event at the last BKFC?"
+- "RAF 14 card", "BKFC 95 results", "Bellator 142 card", "PRIDE 34", "who won the main event at the last BKFC?"
 - Event pages and results pages
 
-event accepts a slug (e.g. "raf13", "bkfc-95-newark", "bellator-142" or "142") or "next" / "last". Bouts come main
-event first; each carries weight class, title stakes, both sides (athletes for RAF, red/blue fighters for BKFC with
-punch totals, red/blue fighters for Bellator with UFC-format totals and ufcFighterSlug), and once finished the winner
-and result (RAF: score, takedowns, method; BKFC/Bellator: method, round, time).
-Bellator is an archive: event defaults to "last" (its most recent card, Bellator 172), and "next" is a
-non-retryable NOT_IMPLEMENTED (there are no upcoming cards).
+event accepts a slug (e.g. "raf13", "bkfc-95-newark", "bellator-142", "pride-34", "wec-48") or "next" / "last".
+Bouts come main event first; each carries weight class, title stakes, both sides (athletes for RAF, red/blue fighters for BKFC with
+punch totals, red/blue fighters for the MMA archives with UFC-format totals and ufcFighterSlug), and once finished
+the winner and result (RAF: score, takedowns, method; BKFC/MMA archives: method, round, time).
+MMA archives are closed: event defaults to "last" (the most recent card; for mma, across every promotion), and
+"next" is a non-retryable NOT_IMPLEMENTED (there are no upcoming cards).
 
 Prefer over: combat_events + call_api per bout.
 Do not use when: you need one bout's period/round breakdown (combat_bout).
@@ -247,7 +272,7 @@ Example: { "league": "raf", "event": "last" }`,
         required: ['league'],
         properties: {
             league: leagueSchema,
-            event: stringSchema('Event slug, or "next" / "last" (default "next"; "last" for bellator). Example: "raf13".', 'next'),
+            event: stringSchema('Event slug, or "next" / "last" (default "next"; "last" for the MMA archives). Example: "raf13".', 'next'),
             limit: limitSchema({ default: 30, max: 40, description: 'Max bouts on the card (default 30, max 40).' }),
         },
     },
@@ -257,11 +282,11 @@ Example: { "league": "raf", "event": "last" }`,
         if (!league)
             return leagueError(d, args.league);
         const limit = clampInt(args.limit, 30, 1, 40);
-        const archive = ARCHIVES[league];
+        const archive = archiveOf(league);
         let slug = typeof args.event === 'string' && args.event.trim() ? args.event.trim().toLowerCase() : archive ? 'last' : 'next';
         let calls = 0;
         if (archive && slug === 'next') {
-            return archiveGap(d, league, `${archive}: there is no next card.`, [
+            return archiveGap(d, league, `${archive.note}: there is no next card.`, [
                 `Use event "last" for the most recent ${league} card, or a slug from combat_events { league: "${league}", when: "recent" }`,
             ]);
         }
@@ -290,7 +315,7 @@ Example: { "league": "raf", "event": "last" }`,
             slug = String(first.slug);
         }
         const [ev, bouts] = await Promise.all([
-            fetchJson(ctx, `/${league}/events/${encodeURIComponent(slug)}`, league === 'bellator' ? { query: { includeBouts: 'false' } } : undefined),
+            fetchJson(ctx, `/${league}/events/${encodeURIComponent(slug)}`, archive ? { query: { includeBouts: 'false' } } : undefined),
             fetchJson(ctx, `/${league}/events/${encodeURIComponent(slug)}/bouts`),
         ]);
         calls += 2;
@@ -324,18 +349,20 @@ Example: { "league": "raf", "event": "last" }`,
 };
 export const combatBout = {
     name: 'combat_bout',
-    description: `One RAF, BKFC or Bellator bout in full, with its scoring breakdown.
+    description: `One RAF, BKFC or MMA archive bout in full, with its scoring breakdown.
 
 RAF: winner, method (decision / tech fall / pin / injury), final score, takedowns, and per-PERIOD scores.
 BKFC: winner, method, round, time, and per-ROUND punch stats for red and blue (landed/thrown, head/body,
 distance/clinch, knockdowns). BKFC round stats need the Starter plan; on Free they come back as a partial note.
-Bellator: winner, method, round, time, finish (position / submission), referee, judges' scores, each corner's
-whole-fight totals, and per-ROUND official stats in UFC's format (significantStrikes "13 of 18", totalStrikes,
-takedowns, head/body/leg, distance/clinch/ground, knockdowns, submissionAttempts, reversals, controlTime "1:42").
-The archive is 2014-2017, older than the Free/Starter history window: on those plans rounds come back as a
-HISTORY_WINDOW_EXCEEDED partial note while the result still returns.
+MMA archives (Bellator, PRIDE, Strikeforce, WEC, DREAM, EliteXC, Affliction, mma): winner, method, round, time,
+finish (position / submission), referee, judges' scores, each corner's whole-fight totals, and per-ROUND official
+stats in UFC's format (significantStrikes "13 of 18", totalStrikes, takedowns, head/body/leg, distance/clinch/ground,
+knockdowns, submissionAttempts, reversals, controlTime "1:42"). PRIDE's first round is 10 minutes. The archives are
+older than the Free/Starter history window: on those plans rounds come back as a HISTORY_WINDOW_EXCEEDED partial
+note while the result still returns.
 
 Get boutId from combat_card or combat_athlete (e.g. "raf13--belal-muhammad--colby-covington", "bellator-5600").
+MMA archive bout ids are "<promotion>-<fightId>"; a bare fight id resolves in any MMA archive league.
 
 Parallel-safe: yes. Upstream cost: 1–2.
 Example: { "league": "bkfc", "boutId": "bkfc-fight-night-bethlehem--gregoris-cisneros--ryan-petersen" }`,
@@ -345,8 +372,8 @@ Example: { "league": "bkfc", "boutId": "bkfc-fight-night-bethlehem--gregoris-cis
         required: ['league', 'boutId'],
         properties: {
             league: leagueSchema,
-            boutId: stringSchema('Bout id from combat_card / combat_athlete (Bellator: "bellator-5600"). Example: "raf13--belal-muhammad--colby-covington".'),
-            includeBreakdown: boolSchema('Include per-period (RAF) / per-round (BKFC, Bellator) breakdown (default true).', true),
+            boutId: stringSchema('Bout id from combat_card / combat_athlete (MMA archives: "<promotion>-<fightId>"). Example: "raf13--belal-muhammad--colby-covington".'),
+            includeBreakdown: boolSchema('Include per-period (RAF) / per-round (BKFC, MMA archives) breakdown (default true).', true),
         },
     },
     handler: async (args, ctx) => {
@@ -379,7 +406,7 @@ Example: { "league": "bkfc", "boutId": "bkfc-fight-night-bethlehem--gregoris-cis
         const b = asRecord(data.bout);
         if (league === 'bkfc' && b && 'rounds' in b && data.rounds)
             delete b.rounds;
-        if (league === 'bellator' && b && 'roundStats' in b && (data.rounds || !breakdown))
+        if (archiveOf(league) && b && 'roundStats' in b && (data.rounds || !breakdown))
             delete b.roundStats;
         return successEnvelope({
             data,
@@ -395,19 +422,20 @@ Example: { "league": "bkfc", "boutId": "bkfc-fight-night-bethlehem--gregoris-cis
 };
 export const combatAthlete = {
     name: 'combat_athlete',
-    description: `COMPOSITE RAF athlete / BKFC or Bellator fighter page: profile + recent bouts + career stats.
+    description: `COMPOSITE RAF athlete / BKFC or MMA archive fighter page: profile + recent bouts + career stats.
 
 When to use:
-- "Kyle Snyder's RAF record", "Arlovski BKFC stats", "Tito Ortiz in Bellator", athlete/fighter profile pages
+- "Kyle Snyder's RAF record", "Arlovski BKFC stats", "Tito Ortiz in Bellator", "Fedor's PRIDE record", athlete/fighter profile pages
 
 athlete accepts a slug ("kyle-snyder") or a name ("Andrei Arlovski"); names are resolved through the league's
 search, and several matches return AMBIGUOUS_ENTITY with candidates. Profile carries record, division, nickname,
 country, official headshot (+ its credit — show it with the image). Career stats need the Starter plan; on Free
 they come back as a partial note while profile and history still return.
-Bellator: profile is bio (DOB, height, reach, stance, hometown) + Bellator-only record (2014-2017 archive, not the
-whole career); stats are career totals in UFC's format. A fighter we also hold a UFC record for keeps the SAME slug
-as /ufc/fighters/{slug}: data.ufcFighterSlug is set then (a UFC slug is accepted here too). Keep the two records
-apart: Bellator fights never belong in a UFC answer.
+MMA archives: profile is bio (DOB, height, reach, stance, hometown) + the record in that promotion's archive (not the
+whole career); stats are career totals in UFC's format. league "mma" covers every archived promotion at once, and
+data.recordByPromotion splits the record ({ pride: {...}, strikeforce: {...} }). A fighter we also hold a UFC record
+for keeps the SAME slug as /ufc/fighters/{slug}: data.ufcFighterSlug is set then (a UFC slug is accepted here too).
+Keep the records apart: archive fights never belong in a UFC answer.
 
 Prefer over: call_api profile + history + stats separately.
 
@@ -438,20 +466,23 @@ Example: { "league": "raf", "athlete": "Kyle Snyder", "historyLimit": 5 }`,
         const r = await resolveOrFail(d, ctx, league, input, 'athlete');
         if ('fail' in r)
             return r.fail;
-        const base = `/${league}/${PEOPLE[league]}/${encodeURIComponent(r.slug)}`;
+        const base = `/${league}/${PEOPLE(league)}/${encodeURIComponent(r.slug)}`;
         const historyLimit = clampInt(args.historyLimit, 10, 1, 50);
         const [profile, history, stats] = await Promise.all([
             fetchJson(ctx, base),
-            args.includeHistory === false ? Promise.resolve(null) : fetchJson(ctx, `${base}/${HISTORY[league]}`, { query: { limit: historyLimit } }),
+            args.includeHistory === false ? Promise.resolve(null) : fetchJson(ctx, `${base}/${HISTORY(league)}`, { query: { limit: historyLimit } }),
             args.includeStats === false ? Promise.resolve(null) : fetchJson(ctx, `${base}/stats`),
         ]);
         if (!profile.ok)
-            return httpError(d, league, profile, `${league} ${PEOPLE[league]} ${r.slug}`);
+            return httpError(d, league, profile, `${league} ${PEOPLE(league)} ${r.slug}`);
         const partial = [];
         const data = { league, slug: r.slug, profile: payload(profile) };
-        if (league === 'bellator') {
+        if (isMma(league)) {
             const ufc = asRecord(asRecord(data.profile)?.ufc);
             data.ufcFighterSlug = typeof ufc?.ufcFighterSlug === 'string' ? ufc.ufcFighterSlug : null;
+            const byPromotion = asRecord(data.profile)?.recordByPromotion;
+            if (league === 'mma' || byPromotion)
+                data.recordByPromotion = asRecord(byPromotion) ?? null;
         }
         if (history) {
             if (history.ok)
@@ -479,10 +510,11 @@ Example: { "league": "raf", "athlete": "Kyle Snyder", "historyLimit": 5 }`,
 };
 export const combatH2h = {
     name: 'combat_h2h',
-    description: `Head-to-head between two RAF athletes, two BKFC fighters or two Bellator fighters: record and every meeting.
+    description: `Head-to-head between two RAF athletes, two BKFC fighters or two MMA archive fighters: record and every meeting.
 
-Accepts slugs or names for both sides (names resolve through the league's search). Bellator meetings are only
-the ones on Bellator cards (2014-2017); UFC meetings between the same two are a UFC question (head_to_head).
+Accepts slugs or names for both sides (names resolve through the league's search). MMA archive meetings are only
+the ones on that promotion's cards (league "mma": every archived promotion); UFC meetings are a UFC question
+(head_to_head).
 
 Parallel-safe: yes. Upstream cost: 1–3.
 Example: { "league": "bkfc", "athleteA": "ryan-petersen", "athleteB": "gregoris-cisneros" }`,
@@ -537,7 +569,8 @@ export const combatRankings = {
 BKFC: omit division for every division's ranked list (champion, interim champion, ranked fighters), or pass one
 (e.g. "heavyweight", "womens-flyweight"). RAF has no ranked lists; it returns every title and its holder, or one
 division's detail when division is given (e.g. "men-heavyweight").
-Bellator has no rankings (a 2014-2017 archive): league "bellator" returns a non-retryable NOT_IMPLEMENTED.
+The MMA archives (bellator, pride, strikeforce, wec, dream, elitexc, affliction, mma) have no rankings: they return a
+non-retryable NOT_IMPLEMENTED.
 Never answer with UFC rankings instead.
 
 Parallel-safe: yes. Upstream cost: 1.
@@ -556,11 +589,12 @@ Example: { "league": "bkfc", "division": "heavyweight" }`,
         const league = parseLeague(args.league);
         if (!league)
             return leagueError(d, args.league);
-        if (league === 'bellator') {
-            return archiveGap(d, league, `Bellator has no rankings or champions lists: ${ARCHIVES.bellator}, and the API serves its results only.`, [
-                'Do not retry: no Bellator rankings exist on the API',
-                'Title fights: call_api /bellator/bouts with query { "title": "true" }; results: combat_events { league: "bellator", when: "recent" }',
-                'Never substitute UFC rankings for Bellator',
+        const archive = archiveOf(league) ?? (isMma(league) ? { short: league === 'pfl' ? 'PFL' : league === 'oktagon' ? 'OKTAGON' : 'The MMA namespace', note: 'the API carries its cards and results' } : undefined);
+        if (archive) {
+            return archiveGap(d, league, `${archive.short} has no rankings or champions lists: ${archive.note}, and the API serves its results only.`, [
+                `Do not retry: no ${league} rankings exist on the API`,
+                `Title fights: call_api /${league}/bouts with query { "title": "true" }; results: combat_events { league: "${league}", when: "recent" }`,
+                `Never substitute UFC rankings for ${archive.short}`,
             ]);
         }
         const division = typeof args.division === 'string' ? args.division.trim().toLowerCase() : '';

package/dist/tools/cs2.js

@@ -362,6 +362,79 @@ export const cs2RosterTransfers = {
         });
     },
 };
+const POSITION_VIEWS = ['grenades', 'positions', 'heatmap'];
+const POSITION_FILTERS = ['type', 'side', 'round', 'player', 'team', 'kind', 'grid', 'map', 'days', 'limit'];
+export const cs2Positions = {
+    name: 'cs2_positions',
+    description: 'CS2 positional data from parsed demos. With mapId: view=grenades (every grenade with landing spot, thrower, round, duration), '
+        + 'view=positions (grenades, bomb plants/defuses and kills with attacker/victim spots in one timeline) or view=heatmap (counts per radar cell; '
+        + 'kind=utility|smoke|flash|he|molotov|decoy|bomb_plant|bomb_defuse|kill|death). With playerId instead: that player\'s grenades across recent maps '
+        + '(pass map for a heatmap). Every point has game coordinates and a 0..1 radar point. Read the response notes and null fields for what is not recorded.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            mapId: stringSchema('Map/game id from match maps, e.g. "cs2-match-2399437-map-1".', 'cs2-match-2399437-map-1'),
+            playerId: stringSchema('Player id or slug (e.g. "ropz"). Use instead of mapId for one player across maps.', 'ropz'),
+            view: { type: 'string', enum: [...POSITION_VIEWS], description: 'For mapId: grenades (default), positions or heatmap.' },
+            type: stringSchema('Grenade type: smoke, flash, he, molotov or decoy.'),
+            side: stringSchema('T or CT.'),
+            round: { type: 'integer', minimum: 1, description: 'Only this round.' },
+            player: stringSchema('With mapId: only this player (id or nickname).'),
+            team: stringSchema('With mapId + view=grenades: only this team (id or name).'),
+            kind: stringSchema('view=heatmap: utility, smoke, flash, he, molotov, decoy, bomb_plant, bomb_defuse, kill or death. view=positions: grenade,bomb,kill.'),
+            grid: { type: 'integer', minimum: 4, maximum: 128, description: 'Heatmap cells per side (default 32).' },
+            map: stringSchema('With playerId: map name (Mirage, Inferno...) to get a heatmap.'),
+            days: { type: 'integer', minimum: 1, maximum: 3650, description: 'With playerId: look-back window in days (default 180).' },
+            limit: limitSchema({ default: 200, max: 5000 }),
+        },
+        additionalProperties: false,
+    },
+    annotations: READ_TOOL_ANNOTATIONS,
+    handler: async (args, ctx) => {
+        const reqId = newRequestId();
+        const mapId = typeof args.mapId === 'string' ? args.mapId.trim() : '';
+        const playerId = typeof args.playerId === 'string' ? args.playerId.trim() : '';
+        if (!mapId && !playerId) {
+            return errorEnvelope({
+                code: 'VALIDATION',
+                message: 'mapId or playerId is required',
+                game: 'cs2',
+                source: 'cs2_positions',
+                requestId: reqId,
+            });
+        }
+        const view = POSITION_VIEWS.includes(args.view) ? String(args.view) : 'grenades';
+        const path = playerId
+            ? `/cs2/players/${encodeURIComponent(playerId)}/utility`
+            : `/cs2/maps/${encodeURIComponent(mapId)}/${view === 'grenades' ? 'utility' : view}`;
+        const query = {};
+        for (const key of POSITION_FILTERS) {
+            const value = args[key];
+            if (typeof value === 'string' && value.trim())
+                query[key] = value.trim();
+            else if (typeof value === 'number' && Number.isFinite(value))
+                query[key] = value;
+        }
+        const res = await fetchJson(ctx, path, { query });
+        if (!res.ok) {
+            return errorEnvelope({
+                code: mapHttpToCode(res.status),
+                message: `CS2 positions fetch failed: ${res.status} on ${path}`,
+                game: 'cs2',
+                source: 'cs2_positions',
+                requestId: reqId,
+                httpStatus: res.status,
+            });
+        }
+        return successEnvelope({
+            data: unwrapPayload(res.data),
+            game: 'cs2',
+            source: 'cs2_positions',
+            requestId: reqId,
+            rateLimit: res.headers,
+        });
+    },
+};
 export const cs2Tools = [
     cs2LiveScoreboard,
     cs2RoundEconomy,
@@ -371,4 +444,5 @@ export const cs2Tools = [
     cs2UtilityLeaderboard,
     cs2VetoSequence,
     cs2RosterTransfers,
+    cs2Positions,
 ];

package/dist/tools/meta.js

@@ -2,23 +2,24 @@ import { extractRows, fetchJson, gameNotIncludedHint, present } from '../client.
 import { errorEnvelope, mapHttpToCode, newRequestId, successEnvelope, } from '../envelope.js';
 import { boolSchema, gameSchema, parseGame, PRIMARY_GAMES, stringSchema, } from './types.js';
 import { PACKAGE_VERSION as CATALOG_VERSION } from '../version.js';
+import { COMBAT_LEAGUES } from './combat.js';
 const COMBAT_CATALOG = [
     {
         name: 'combat_events',
         doNotUse: 'You already have the event slug → combat_card',
-        outcome: 'RAF wrestling / BKFC bare-knuckle / Bellator MMA events: upcoming cards or recent results, with date, local time and venue (Bellator: archive, upcoming is empty with a note)',
+        outcome: 'RAF wrestling / BKFC bare-knuckle / MMA archive (Bellator, PRIDE, Strikeforce, WEC, DREAM, EliteXC, Affliction, mma = all) events: upcoming cards or recent results, with date, local time and venue (archives: upcoming is empty with a note)',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['schedule'],
         exampleArgs: { league: 'bkfc', when: 'upcoming', limit: 5 },
-        preferOver: ['call_api /raf/events, /bkfc/events or /bellator/events'],
+        preferOver: ['call_api /{league}/events'],
     },
     {
         name: 'combat_card',
         doNotUse: "One bout's period/round breakdown → combat_bout",
-        outcome: 'One RAF/BKFC/Bellator event card in running order with results; event = slug, "next" or "last" (Bellator: "last" = most recent archived card, no "next")',
+        outcome: 'One RAF/BKFC/MMA archive event card in running order with results; event = slug, "next" or "last" (archives: "last" = most recent card, across promotions for mma; no "next")',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['event_card', 'schedule', 'media'],
         exampleArgs: { league: 'raf', event: 'last' },
         preferOver: ['combat_events + call_api per bout'],
@@ -27,9 +28,9 @@ const COMBAT_CATALOG = [
         name: 'combat_bout',
         doNotUse: 'Whole card → combat_card',
         preferOver: [],
-        outcome: 'One bout in full: RAF per-period scores / BKFC per-round punch stats (Starter) / Bellator per-round official stats in UFC format (Pro: the archive is older than the Free/Starter window)',
+        outcome: 'One bout in full: RAF per-period scores / BKFC per-round punch stats (Starter) / MMA archive per-round official stats in UFC format (Pro: the archives are older than the Free/Starter window)',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['match_page'],
         exampleArgs: { league: 'raf', boutId: 'raf13--belal-muhammad--colby-covington' },
     },
@@ -37,9 +38,9 @@ const COMBAT_CATALOG = [
         name: 'combat_athlete',
         doNotUse: "Two athletes' meetings → combat_h2h",
         preferOver: [],
-        outcome: 'RAF athlete / BKFC or Bellator fighter page: profile + headshot, recent bouts, career stats (Starter); slug or name; Bellator fighters share the UFC slug (ufcFighterSlug)',
+        outcome: 'RAF athlete / BKFC or MMA archive fighter page: profile + headshot, recent bouts, career stats (Starter); slug or name; archive fighters share the UFC slug (ufcFighterSlug); league mma = whole non-UFC career with recordByPromotion',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['player_form', 'media'],
         exampleArgs: { league: 'raf', athlete: 'Kyle Snyder', historyLimit: 5 },
     },
@@ -47,19 +48,19 @@ const COMBAT_CATALOG = [
         name: 'combat_h2h',
         doNotUse: "One athlete's whole history → combat_athlete",
         preferOver: [],
-        outcome: 'Head-to-head between two RAF athletes, two BKFC fighters or two Bellator fighters',
+        outcome: 'Head-to-head between two RAF athletes, two BKFC fighters or two MMA archive fighters',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['h2h', 'preview'],
         exampleArgs: { league: 'bkfc', athleteA: 'ryan-petersen', athleteB: 'gregoris-cisneros' },
     },
     {
         name: 'combat_rankings',
-        doNotUse: 'UFC rankings → standings / rankings tools (RAF/BKFC/Bellator never appear in UFC answers); Bellator has no rankings (NOT_IMPLEMENTED)',
+        doNotUse: 'UFC rankings → standings / rankings tools (RAF/BKFC/MMA archives never appear in UFC answers); the MMA archives have no rankings (NOT_IMPLEMENTED)',
         preferOver: [],
         outcome: 'RAF champions per division / BKFC official rankings and champions',
         parallelSafe: true,
-        games: ['raf', 'bkfc', 'bellator'],
+        games: [...COMBAT_LEAGUES],
         jobs: ['standings'],
         exampleArgs: { league: 'bkfc', division: 'heavyweight' },
     },
@@ -441,6 +442,16 @@ const TOOL_CATALOG = [
         preferOver: ['unindexed round event aggregation'],
         doNotUse: 'For standard weapon ratings',
     },
+    {
+        name: 'cs2_positions',
+        outcome: 'CS2 grenade landing spots, bomb plants, kill/death spots and radar heatmaps for a map or a player',
+        parallelSafe: true,
+        games: ['cs2'],
+        jobs: ['match_page', 'player_form'],
+        exampleArgs: { mapId: 'cs2-match-2399437-map-1', view: 'heatmap', kind: 'smoke' },
+        preferOver: ['call_api /cs2/maps/{mapId}/utility|positions|heatmap', 'parsing /cs2/games/{id}/rounds events for coordinates'],
+        doNotUse: 'For live matches (positions come from the demo, after the map ends)',
+    },
     {
         name: 'cs2_veto_sequence',
         outcome: 'Map pick/ban sequence and veto history for a CS2 match',
@@ -552,8 +563,8 @@ const GAMES_META = [
         label: 'UFC / MMA',
         depth: 'medium',
         notes: 'Fighter slugs; boutId; live + rankings. Includes Dana White\'s Contender Series and Road to UFC (2022-2026, all 19 cards ' +
-            'with official round stats; event slugs like road-to-ufc-2-7, titles "Road to UFC 2.7"). Bellator is NOT UFC: use the ' +
-            'combat_* tools with league bellator, and never mix its fights into UFC answers.',
+            'with official round stats; event slugs like road-to-ufc-2-7, titles "Road to UFC 2.7"). Bellator, PRIDE, Strikeforce, WEC, ' +
+            'DREAM, EliteXC and Affliction are NOT UFC: combat_* tools with that league (or mma), never mixed into UFC answers.',
     },
 ];
 export const listCapabilities = {
@@ -797,6 +808,15 @@ const ALLOWLIST_PREFIXES = [
     '/raf',
     '/bkfc',
     '/bellator',
+    '/pride',
+    '/strikeforce',
+    '/wec',
+    '/dream',
+    '/elitexc',
+    '/affliction',
+    '/pfl',
+    '/oktagon',
+    '/mma',
     '/openapi.json',
 ];
 function pathAllowed(path) {
@@ -820,7 +840,7 @@ Prefer curated tools for all standard jobs (live, schedule, profiles, standings,
 
 Do not use when: a curated tool covers the outcome. Avoid parallel storms; same plan rate limits apply.
 
-Path must start with / and match allowlisted prefixes: /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis, /raf, /bkfc, /bellator.
+Path must start with / and match allowlisted prefixes: /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis, /raf, /bkfc, /bellator, /pride, /strikeforce, /wec, /dream, /elitexc, /affliction, /pfl, /oktagon, /mma.
 Rejects absolute URLs and path traversal → PATH_NOT_ALLOWED.
 
 Parallel-safe: yes but discouraged in bulk. Upstream cost: 1.
@@ -881,7 +901,7 @@ Example: { "method": "GET", "path": "/cs2/rankings/teams", "queryJson": "{\\"pag
                 source: 'call_api',
                 requestId,
                 tookMs: Date.now() - started,
-                hint: 'Use prefixes /health /lol /cs2 /dota2 /cod /ufc /fortnite /tennis /raf /bkfc /bellator',
+                hint: 'Use prefixes /health /lol /cs2 /dota2 /cod /ufc /fortnite /tennis /raf /bkfc /bellator /pride /strikeforce /wec /dream /elitexc /affliction /pfl /oktagon /mma',
             });
         }
         let query = {};
@@ -982,10 +1002,10 @@ Example: { "game": "ufc", "q": "rankings" }`,
         const started = Date.now();
         const requestId = newRequestId();
         const gameRaw = typeof args.game === 'string' ? args.game.toLowerCase().trim() : '';
-        if (gameRaw && !gameRaw.match(/^(lol|cs2|dota2|cod|ufc|fortnite|tennis|raf|bkfc|bellator)$/)) {
+        if (gameRaw && !gameRaw.match(/^(lol|cs2|dota2|cod|ufc|fortnite|tennis|raf|bkfc|bellator|pride|strikeforce|wec|dream|elitexc|affliction|pfl|oktagon|mma)$/)) {
             return errorEnvelope({
                 code: 'UNSUPPORTED_GAME',
-                message: `unsupported game "${gameRaw}"; use lol|cs2|dota2|cod|ufc|fortnite|tennis|raf|bkfc|bellator`,
+                message: `unsupported game "${gameRaw}"; use lol|cs2|dota2|cod|ufc|fortnite|tennis|raf|bkfc|bellator|pride|strikeforce|wec|dream|elitexc|affliction|pfl|oktagon|mma`,
                 game: null,
                 source: 'list_routes',
                 requestId,
@@ -1008,7 +1028,7 @@ Example: { "game": "ufc", "q": "rankings" }`,
                 httpStatus: res.status,
                 recover: [
                     'Call list_capabilities for curated tools that need no route knowledge',
-                    'call_api accepts /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis, /raf, /bkfc, /bellator',
+                    'call_api accepts /health, /lol, /cs2, /dota2, /cod, /ufc, /fortnite, /tennis, /raf, /bkfc, /bellator, /pride, /strikeforce, /wec, /dream, /elitexc, /affliction, /pfl, /oktagon, /mma',
                 ],
             });
         }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "cito-mcp",
-  "version": "0.4.9",
-  "description": "Standalone MCP server for the Cito esports and sports API \u2014 curated outcome tools for agents (live scoreboards, round economy, opening duels, clutches, vetoes, rosters, tennis, mma).",
+  "version": "0.5.2",
+  "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",
-  "//REPOSITORY": "Intentionally NOT set. cito-api-scraper and cito.gg are PRIVATE repos and must stay that way, so a repository URL pointing at them would render as a broken 404 link on the public npm page and would not satisfy MCP Registry npm ownership validation. Set this only if a PUBLIC repo for this package is ever created (e.g. achillesscriptsvip/cito-mcp with this directory as root) \u2014 then use `git+https://github.com/OWNER/REPO.git` and mirror it in the `mcpName`/server.json `name` pair. Do not point it at the private monorepo.",
+  "//REPOSITORY": "Intentionally NOT set. cito-api-scraper and cito.gg are PRIVATE repos and must stay that way, so a repository URL pointing at them would render as a broken 404 link on the public npm page and would not satisfy MCP Registry npm ownership validation. Set this only if a PUBLIC repo for this package is ever created (e.g. achillesscriptsvip/cito-mcp with this directory as root) — then use `git+https://github.com/OWNER/REPO.git` and mirror it in the `mcpName`/server.json `name` pair. Do not point it at the private monorepo.",
   "keywords": [
     "mcp",
     "model-context-protocol",