cito-mcp 0.3.7 → 0.3.9

package/dist/tools/normalize.js

@@ -280,7 +280,7 @@ export function normalizeMatch(game, row, forcedStatus) {
         else if (/complete|finished|ended|final|closed|done|official|result/.test(statusRaw) || hasResult) {
             status = 'completed';
         }
-        else if (/upcoming|scheduled|not_started|pending|soon|booked|confirmed|announced/.test(statusRaw) ||
+        else if (/upcoming|scheduled|not_?started|unstarted|pending|soon|booked|confirmed|announced|tbd/.test(statusRaw) ||
             (game === 'ufc' && !hasResult && (startTime || statusRaw === '' || statusRaw === 'unknown'))) {
             // UFC bouts often omit status or use sparse values; default upcoming when no result yet.
             if (hasResult)

package/dist/tools/player.js

@@ -9,9 +9,20 @@ function identityFrom(game, raw, idHint, slugHint) {
     const r = asRecord(raw) ?? {};
     const id = pickString(r.id, r.playerId, r.lolPlayerId, r.codPlayerId, idHint, slugHint) ?? 'unknown';
     const slug = pickString(r.slug, slugHint);
-    const name = pickString(r.name, r.full_name, r.nickname, r.displayName, r.tag, slug, id) ?? id;
+    // currentIgn FIRST for LoL. The row carries currentIgn "Faker" and realName
+    // "Sanghyeok Lee" but no `name`, so this fell through every key to the id and
+    // served a raw UUID as the player's display name.
+    const name = pickString(r.name, r.currentIgn, r.ign, r.full_name, r.nickname, r.displayName, r.tag, r.realName, slug, id) ?? id;
+    // currentTeam is a STRING on the LoL row ("T1"), not an object, so asRecord
+    // returned null and the profile reported a team of "?" while the slug sat
+    // right there in currentTeamSlug.
+    const currentTeamName = pickString(r.currentTeam);
+    const currentTeamSlug = pickString(r.currentTeamSlug, r.teamSlug, r.orgSlug);
     const team = asRecord(r.team) ??
         asRecord(r.currentTeam) ??
+        (currentTeamName || currentTeamSlug
+            ? { name: currentTeamName ?? currentTeamSlug, slug: currentTeamSlug, id: currentTeamSlug }
+            : null) ??
         (r.teamName || r.orgSlug
             ? { name: r.teamName, slug: r.orgSlug, id: r.teamId }
             : null);
@@ -24,7 +35,7 @@ function identityFrom(game, raw, idHint, slugHint) {
             ? {
                 id: pickString(asRecord(team)?.id, asRecord(team)?.teamId),
                 slug: pickString(asRecord(team)?.slug, asRecord(team)?.orgSlug),
-                name: pickString(asRecord(team)?.name) ?? '?',
+                name: pickString(asRecord(team)?.name, asRecord(team)?.slug) ?? '?',
             }
             : null,
         role: pickString(r.role, r.position) ?? null,
@@ -204,11 +215,30 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                     const rows = extractRows(res.data);
                     const first = asRecord(rows[0]);
                     if (first) {
-                        currentTeam = {
-                            id: pickString(first.id, first.teamId),
-                            slug: pickString(first.slug),
-                            name: pickString(first.name) ?? '?',
-                        };
+                        // NEVER let team history overwrite the player row's own team.
+                        // This endpoint returns showmatch and novelty orgs alongside the
+                        // real one, all marked status "current" — for Faker the first row
+                        // is literally "Faker", then "Captain Faker", then "KR with
+                        // Influencers". Taking rows[0] reported the player as their own
+                        // team. The player row's currentTeamSlug is the answer; history is
+                        // only a fallback, and then only for a row that looks like a real
+                        // club rather than the player's own name.
+                        const rows2 = rows.map((row) => asRecord(row) ?? {});
+                        const preferred = (player.team?.slug
+                            ? rows2.find((x) => pickString(x.orgSlug, x.slug) === player.team?.slug)
+                            : null) ??
+                            rows2.find((x) => x.status === 'current' && pickString(x.teamName, x.name) !== player.name) ??
+                            first;
+                        const histName = pickString(preferred.name, preferred.teamName, preferred.orgName);
+                        const histSlug = pickString(preferred.slug, preferred.orgSlug, preferred.teamSlug);
+                        const alreadyResolved = Boolean(currentTeam?.slug && currentTeam.name && currentTeam.name !== '?');
+                        if (!alreadyResolved && (histName || histSlug)) {
+                            currentTeam = {
+                                id: pickString(preferred.id, preferred.teamId) ?? histSlug ?? undefined,
+                                slug: histSlug ?? undefined,
+                                name: histName ?? histSlug ?? '?',
+                            };
+                        }
                     }
                 }
                 else {
@@ -220,6 +250,67 @@ Example: { "game": "cs2", "playerId": "cs2-player-1", "recentLimit": 10, "includ
                 }
             })());
         }
+        if (game === 'lol') {
+            // /lol/players/{id}/matches exists and returns the player's real match
+            // index; only tennis was wired to its equivalent, so every LoL profile
+            // shipped recentMatches: [].
+            tasks.push((async () => {
+                const res = await fetchJson(ctx, `/lol/players/${encodeURIComponent(idOrSlug)}/matches`, {
+                    query: { limit: String(recentLimit) },
+                });
+                upstreamCalls += 1;
+                rateLimit = { ...rateLimit, ...res.headers };
+                if (res.ok) {
+                    const startMs = (row) => {
+                        const r = asRecord(row) ?? {};
+                        const t = Date.parse(String(r.startTime ?? r.date ?? ''));
+                        return Number.isFinite(t) ? t : -Infinity;
+                    };
+                    const picked = extractRows(res.data)
+                        .slice()
+                        .sort((a, b) => startMs(b) - startMs(a))
+                        .slice(0, recentLimit);
+                    // The index carries team SLUGS and no names, so labels read
+                    // "hle vs t1". Resolve the distinct slugs once — deduplicated and
+                    // capped — rather than a lookup per match, and fall back to the
+                    // slug when a lookup fails so a label is never blank.
+                    const slugs = [
+                        ...new Set(picked.flatMap((row) => {
+                            const r = asRecord(row) ?? {};
+                            return [pickString(r.team1Slug), pickString(r.team2Slug)];
+                        }).filter((x) => Boolean(x))),
+                    ].slice(0, 12);
+                    const names = new Map();
+                    await Promise.all(slugs.map(async (sl) => {
+                        const t = await fetchJson(ctx, `/lol/teams/${encodeURIComponent(sl)}`);
+                        upstreamCalls += 1;
+                        if (!t.ok)
+                            return;
+                        const body = asRecord(t.data) ?? {};
+                        const nm = pickString(body.name, asRecord(body.data)?.name);
+                        if (nm)
+                            names.set(sl, nm);
+                    }));
+                    recentMatches = picked.map((row) => {
+                        const r = asRecord(row) ?? {};
+                        const s1 = pickString(r.team1Slug);
+                        const s2 = pickString(r.team2Slug);
+                        return normalizeMatch('lol', {
+                            ...r,
+                            ...(s1 ? { team1: { slug: s1, name: names.get(s1) ?? s1, score: r.team1Score } } : {}),
+                            ...(s2 ? { team2: { slug: s2, name: names.get(s2) ?? s2, score: r.team2Score } } : {}),
+                        });
+                    });
+                }
+                else {
+                    partial.push(partialFromRejection('recentMatches', {
+                        code: mapHttpToCode(res.status),
+                        message: `player matches HTTP ${res.status}`,
+                        httpStatus: res.status,
+                    }));
+                }
+            })());
+        }
         if (game === 'tennis') {
             if (includeTrends) {
                 tasks.push((async () => {

package/dist/tools/resolve.js

@@ -5,6 +5,20 @@ import { clampInt, decodeCursor, encodeCursor, extractRows, fetchJson, gameNotIn
 import { DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT, errorEnvelope, mapHttpToCode, newRequestId, partialFromRejection, successEnvelope, } from '../envelope.js';
 import { entityRef, rankScore } from './normalize.js';
 import { boolSchema, gameSchema, isPrimaryGame, limitSchema, parseGame, PRIMARY_GAMES, stringSchema, } from './types.js';
+/**
+ * Query aliases for orgs whose common name is not their slug. Kept deliberately
+ * small and one-directional: these map what a person types onto the canonical
+ * slug, and are only used to grant an exact-match boost, never to rewrite a
+ * result. SK Telecom T1 became T1 in 2019; sk-telecom-t1-k and -s remain
+ * separate historical rosters and are NOT folded in.
+ */
+const normalizeQueryKey = (v) => String(v || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+const ORG_ALIASES = {
+    skt: 't1',
+    sktt1: 't1',
+    sktelecomt1: 't1',
+    skt1: 't1',
+};
 function pushCandidates(out, game, type, rows, q, limit) {
     for (const row of rows) {
         const ref = entityRef(row, type, game);
@@ -268,15 +282,33 @@ async function searchGame(ctx, game, q, type, limit) {
             const tasks = [];
             if (type === 'any' || type === 'team') {
                 tasks.push((async () => {
-                    const res = await fetchJson(ctx, '/lol/teams', { query: { search: q, limit: String(limit) } });
+                    // Over-fetch before ranking. The upstream returns search hits in
+                    // alphabetical order, so asking for `limit` rows put the exact
+                    // match outside the window: "T1" returned mt1-esports, mt1-vision
+                    // and two SK Telecom rosters while the real t1 sat sixth and was
+                    // never seen. Rank a wide window, then cut.
+                    const wide = String(Math.max(50, limit * 5));
+                    const res = await fetchJson(ctx, '/lol/teams', { query: { search: q, limit: wide } });
                     calls += 1;
                     if (res.ok)
                         pushCandidates(candidates, game, 'team', extractRows(res.data), q, limit);
+                    // An alias is a name the API does not know. "SKT" returns no t1 row
+                    // at all, so ranking cannot help; search the canonical slug too and
+                    // score those rows against the canonical name.
+                    const aliasTarget = ORG_ALIASES[normalizeQueryKey(q)];
+                    if (aliasTarget) {
+                        const alt = await fetchJson(ctx, '/lol/teams', { query: { search: aliasTarget, limit: wide } });
+                        calls += 1;
+                        if (alt.ok)
+                            pushCandidates(candidates, game, 'team', extractRows(alt.data), aliasTarget, limit);
+                    }
                 })());
             }
             if (type === 'any' || type === 'player') {
                 tasks.push((async () => {
-                    const res = await fetchJson(ctx, '/lol/players', { query: { search: q, limit: String(limit) } });
+                    const res = await fetchJson(ctx, '/lol/players', {
+                        query: { search: q, limit: String(Math.max(50, limit * 5)) },
+                    });
                     calls += 1;
                     if (res.ok)
                         pushCandidates(candidates, game, 'player', extractRows(res.data), q, limit);
@@ -444,8 +476,22 @@ Example: { "q": "T1", "game": "lol", "type": "team", "limit": 5 }`,
         all.sort((a, b) => b.score - a.score);
         const candidates = all.slice(0, limit);
         const best = candidates[0] ?? null;
+        // An exact identity hit is not ambiguous, whatever else scored near it.
+        // "T1" ties with t1-rookies and t1-challengers on fuzzy score, which left
+        // the caller with needsDisambiguation and no decision to act on even though
+        // one candidate matched the query exactly. Aliases count: "SKT" resolves
+        // through ORG_ALIASES to the canonical org.
+        const qKey = normalizeQueryKey(q);
+        const aliasKey = ORG_ALIASES[qKey] ? normalizeQueryKey(ORG_ALIASES[qKey]) : null;
+        const bestIsExact = !!best &&
+            [best.slug, best.id, best.name].some((v) => {
+                const n = normalizeQueryKey(v);
+                return n && (n === qKey || (aliasKey !== null && n === aliasKey));
+            });
         const needsDisambiguation = !best ||
-            (candidates.length > 1 && (candidates[1].score >= best.score - 5 || best.score < 50));
+            (!bestIsExact &&
+                candidates.length > 1 &&
+                (candidates[1].score >= best.score - 5 || best.score < 50));
         return successEnvelope({
             source: 'resolve_entity',
             game: best?.game ?? gameParse.game ?? null,

package/package.json

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