npm - @davincibets/mcp-server - Versions diffs - 1.0.1 → 1.3.1 - Mend

@davincibets/mcp-server 1.0.1 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -1,15 +1,20 @@
 #!/usr/bin/env node
 /**
- * Da Vinci Bets MCP Server
+ * Da Vinci Bets MCP Server v1.3.1
  *
  * Gives any AI assistant (Claude, Cursor, Windsurf, etc.) native access
  * to Da Vinci Bets predictions via the user's personal API key.
  *
  * Tools:
- *   get_predictions   — Fetch AI predictions by sport, market, confidence
+ *   get_predictions   — Fetch AI predictions by sport, market, team, confidence
  *   get_top_picks     — Get highest-conviction picks across all sports
+ *   get_game          — Find a specific game by team name (intelligent lookup)
+ *   lookup_teams      — Search/list teams by name, abbreviation, city, or sport
  *   get_pick_card     — Render a pick as a shareable PNG (partner tier)
- *   get_performance   — Win rates and track record stats
+ *   get_batch_cards   — Render multiple pick cards in batch
+ *   get_performance   — Active predictions snapshot
+ *   get_track_record  — Verified win rates, ROI, streaks from settled picks
+ *   get_schedule      — Today's games with prediction coverage
  *
  * Auth: DVB_API_KEY env var (dvb_live_xxx from Settings → API tab)
  * Docs: https://www.davincibets.io/features
@@ -18,13 +23,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 // ─── Configuration ──────────────────────────────────────────────────────────
-// FINDING 4 FIX: Validate DVB_API_URL to prevent key exfiltration via SSRF
-const ALLOWED_API_HOSTS = new Set([
-    "www.davincibets.io",
-    "davincibets.io",
-    "localhost",
-    "127.0.0.1",
-]);
+const ALLOWED_API_HOSTS = new Set(["www.davincibets.io", "davincibets.io"]);
 const _rawUrl = process.env.DVB_API_URL || "https://www.davincibets.io";
 try {
     const parsed = new URL(_rawUrl);
@@ -52,6 +51,1062 @@ if (!_rawKey.startsWith("dvb_live_")) {
     process.exit(1);
 }
 const API_KEY = _rawKey;
+const TEAMS = [
+    // ── NBA (30) ────────────────────────────────────────────────────────────
+    {
+        abbr: "ATL",
+        nickname: "Hawks",
+        city: "Atlanta",
+        fullName: "Atlanta Hawks",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "BOS",
+        nickname: "Celtics",
+        city: "Boston",
+        fullName: "Boston Celtics",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "BKN",
+        nickname: "Nets",
+        city: "Brooklyn",
+        fullName: "Brooklyn Nets",
+        sport: "NBA",
+        aliases: ["BRK"],
+    },
+    {
+        abbr: "CHA",
+        nickname: "Hornets",
+        city: "Charlotte",
+        fullName: "Charlotte Hornets",
+        sport: "NBA",
+        aliases: ["CHH"],
+    },
+    {
+        abbr: "CHI",
+        nickname: "Bulls",
+        city: "Chicago",
+        fullName: "Chicago Bulls",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "CLE",
+        nickname: "Cavaliers",
+        city: "Cleveland",
+        fullName: "Cleveland Cavaliers",
+        sport: "NBA",
+        aliases: ["Cavs"],
+    },
+    {
+        abbr: "DAL",
+        nickname: "Mavericks",
+        city: "Dallas",
+        fullName: "Dallas Mavericks",
+        sport: "NBA",
+        aliases: ["Mavs"],
+    },
+    {
+        abbr: "DEN",
+        nickname: "Nuggets",
+        city: "Denver",
+        fullName: "Denver Nuggets",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "DET",
+        nickname: "Pistons",
+        city: "Detroit",
+        fullName: "Detroit Pistons",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "GSW",
+        nickname: "Warriors",
+        city: "Golden State",
+        fullName: "Golden State Warriors",
+        sport: "NBA",
+        aliases: ["GS", "SF Warriors"],
+    },
+    {
+        abbr: "HOU",
+        nickname: "Rockets",
+        city: "Houston",
+        fullName: "Houston Rockets",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "IND",
+        nickname: "Pacers",
+        city: "Indiana",
+        fullName: "Indiana Pacers",
+        sport: "NBA",
+        aliases: ["Indianapolis"],
+    },
+    {
+        abbr: "LAC",
+        nickname: "Clippers",
+        city: "Los Angeles",
+        fullName: "Los Angeles Clippers",
+        sport: "NBA",
+        aliases: ["LA Clippers"],
+    },
+    {
+        abbr: "LAL",
+        nickname: "Lakers",
+        city: "Los Angeles",
+        fullName: "Los Angeles Lakers",
+        sport: "NBA",
+        aliases: ["LA Lakers"],
+    },
+    {
+        abbr: "MEM",
+        nickname: "Grizzlies",
+        city: "Memphis",
+        fullName: "Memphis Grizzlies",
+        sport: "NBA",
+        aliases: ["Grizz"],
+    },
+    {
+        abbr: "MIA",
+        nickname: "Heat",
+        city: "Miami",
+        fullName: "Miami Heat",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "MIL",
+        nickname: "Bucks",
+        city: "Milwaukee",
+        fullName: "Milwaukee Bucks",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "MIN",
+        nickname: "Timberwolves",
+        city: "Minnesota",
+        fullName: "Minnesota Timberwolves",
+        sport: "NBA",
+        aliases: ["Wolves", "TWolves", "Minneapolis"],
+    },
+    {
+        abbr: "NOP",
+        nickname: "Pelicans",
+        city: "New Orleans",
+        fullName: "New Orleans Pelicans",
+        sport: "NBA",
+        aliases: ["NO", "NOLA", "Pels"],
+    },
+    {
+        abbr: "NYK",
+        nickname: "Knicks",
+        city: "New York",
+        fullName: "New York Knicks",
+        sport: "NBA",
+        aliases: ["NY Knicks"],
+    },
+    {
+        abbr: "OKC",
+        nickname: "Thunder",
+        city: "Oklahoma City",
+        fullName: "Oklahoma City Thunder",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "ORL",
+        nickname: "Magic",
+        city: "Orlando",
+        fullName: "Orlando Magic",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "PHI",
+        nickname: "76ers",
+        city: "Philadelphia",
+        fullName: "Philadelphia 76ers",
+        sport: "NBA",
+        aliases: ["Sixers", "Philly"],
+    },
+    {
+        abbr: "PHX",
+        nickname: "Suns",
+        city: "Phoenix",
+        fullName: "Phoenix Suns",
+        sport: "NBA",
+        aliases: ["PHO"],
+    },
+    {
+        abbr: "POR",
+        nickname: "Trail Blazers",
+        city: "Portland",
+        fullName: "Portland Trail Blazers",
+        sport: "NBA",
+        aliases: ["Blazers"],
+    },
+    {
+        abbr: "SAC",
+        nickname: "Kings",
+        city: "Sacramento",
+        fullName: "Sacramento Kings",
+        sport: "NBA",
+        aliases: [],
+    },
+    {
+        abbr: "SAS",
+        nickname: "Spurs",
+        city: "San Antonio",
+        fullName: "San Antonio Spurs",
+        sport: "NBA",
+        aliases: ["SA"],
+    },
+    {
+        abbr: "TOR",
+        nickname: "Raptors",
+        city: "Toronto",
+        fullName: "Toronto Raptors",
+        sport: "NBA",
+        aliases: ["Raps"],
+    },
+    {
+        abbr: "UTA",
+        nickname: "Jazz",
+        city: "Utah",
+        fullName: "Utah Jazz",
+        sport: "NBA",
+        aliases: ["SLC", "Salt Lake"],
+    },
+    {
+        abbr: "WAS",
+        nickname: "Wizards",
+        city: "Washington",
+        fullName: "Washington Wizards",
+        sport: "NBA",
+        aliases: ["DC", "Wiz"],
+    },
+    // ── NFL (32) ────────────────────────────────────────────────────────────
+    {
+        abbr: "ARI",
+        nickname: "Cardinals",
+        city: "Arizona",
+        fullName: "Arizona Cardinals",
+        sport: "NFL",
+        aliases: ["Phoenix"],
+    },
+    {
+        abbr: "ATL",
+        nickname: "Falcons",
+        city: "Atlanta",
+        fullName: "Atlanta Falcons",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "BAL",
+        nickname: "Ravens",
+        city: "Baltimore",
+        fullName: "Baltimore Ravens",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "BUF",
+        nickname: "Bills",
+        city: "Buffalo",
+        fullName: "Buffalo Bills",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "CAR",
+        nickname: "Panthers",
+        city: "Carolina",
+        fullName: "Carolina Panthers",
+        sport: "NFL",
+        aliases: ["Charlotte"],
+    },
+    {
+        abbr: "CHI",
+        nickname: "Bears",
+        city: "Chicago",
+        fullName: "Chicago Bears",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "CIN",
+        nickname: "Bengals",
+        city: "Cincinnati",
+        fullName: "Cincinnati Bengals",
+        sport: "NFL",
+        aliases: ["Cincy"],
+    },
+    {
+        abbr: "CLE",
+        nickname: "Browns",
+        city: "Cleveland",
+        fullName: "Cleveland Browns",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "DAL",
+        nickname: "Cowboys",
+        city: "Dallas",
+        fullName: "Dallas Cowboys",
+        sport: "NFL",
+        aliases: ["America's Team"],
+    },
+    {
+        abbr: "DEN",
+        nickname: "Broncos",
+        city: "Denver",
+        fullName: "Denver Broncos",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "DET",
+        nickname: "Lions",
+        city: "Detroit",
+        fullName: "Detroit Lions",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "GB",
+        nickname: "Packers",
+        city: "Green Bay",
+        fullName: "Green Bay Packers",
+        sport: "NFL",
+        aliases: ["GNB"],
+    },
+    {
+        abbr: "HOU",
+        nickname: "Texans",
+        city: "Houston",
+        fullName: "Houston Texans",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "IND",
+        nickname: "Colts",
+        city: "Indianapolis",
+        fullName: "Indianapolis Colts",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "JAX",
+        nickname: "Jaguars",
+        city: "Jacksonville",
+        fullName: "Jacksonville Jaguars",
+        sport: "NFL",
+        aliases: ["Jags", "JAC"],
+    },
+    {
+        abbr: "KC",
+        nickname: "Chiefs",
+        city: "Kansas City",
+        fullName: "Kansas City Chiefs",
+        sport: "NFL",
+        aliases: ["KCC"],
+    },
+    {
+        abbr: "LV",
+        nickname: "Raiders",
+        city: "Las Vegas",
+        fullName: "Las Vegas Raiders",
+        sport: "NFL",
+        aliases: ["LVR", "Oakland"],
+    },
+    {
+        abbr: "LAC",
+        nickname: "Chargers",
+        city: "Los Angeles",
+        fullName: "Los Angeles Chargers",
+        sport: "NFL",
+        aliases: ["LA Chargers", "San Diego"],
+    },
+    {
+        abbr: "LAR",
+        nickname: "Rams",
+        city: "Los Angeles",
+        fullName: "Los Angeles Rams",
+        sport: "NFL",
+        aliases: ["LA Rams", "STL Rams"],
+    },
+    {
+        abbr: "MIA",
+        nickname: "Dolphins",
+        city: "Miami",
+        fullName: "Miami Dolphins",
+        sport: "NFL",
+        aliases: ["Fins"],
+    },
+    {
+        abbr: "MIN",
+        nickname: "Vikings",
+        city: "Minnesota",
+        fullName: "Minnesota Vikings",
+        sport: "NFL",
+        aliases: ["Minneapolis"],
+    },
+    {
+        abbr: "NE",
+        nickname: "Patriots",
+        city: "New England",
+        fullName: "New England Patriots",
+        sport: "NFL",
+        aliases: ["Pats", "NEP", "Boston Patriots"],
+    },
+    {
+        abbr: "NO",
+        nickname: "Saints",
+        city: "New Orleans",
+        fullName: "New Orleans Saints",
+        sport: "NFL",
+        aliases: ["NOLA", "NOS"],
+    },
+    {
+        abbr: "NYG",
+        nickname: "Giants",
+        city: "New York",
+        fullName: "New York Giants",
+        sport: "NFL",
+        aliases: ["NY Giants"],
+    },
+    {
+        abbr: "NYJ",
+        nickname: "Jets",
+        city: "New York",
+        fullName: "New York Jets",
+        sport: "NFL",
+        aliases: ["NY Jets"],
+    },
+    {
+        abbr: "PHI",
+        nickname: "Eagles",
+        city: "Philadelphia",
+        fullName: "Philadelphia Eagles",
+        sport: "NFL",
+        aliases: ["Philly"],
+    },
+    {
+        abbr: "PIT",
+        nickname: "Steelers",
+        city: "Pittsburgh",
+        fullName: "Pittsburgh Steelers",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "SF",
+        nickname: "49ers",
+        city: "San Francisco",
+        fullName: "San Francisco 49ers",
+        sport: "NFL",
+        aliases: ["Niners", "SFO"],
+    },
+    {
+        abbr: "SEA",
+        nickname: "Seahawks",
+        city: "Seattle",
+        fullName: "Seattle Seahawks",
+        sport: "NFL",
+        aliases: [],
+    },
+    {
+        abbr: "TB",
+        nickname: "Buccaneers",
+        city: "Tampa Bay",
+        fullName: "Tampa Bay Buccaneers",
+        sport: "NFL",
+        aliases: ["Bucs", "TBB", "Tampa"],
+    },
+    {
+        abbr: "TEN",
+        nickname: "Titans",
+        city: "Tennessee",
+        fullName: "Tennessee Titans",
+        sport: "NFL",
+        aliases: ["Nashville"],
+    },
+    {
+        abbr: "WAS",
+        nickname: "Commanders",
+        city: "Washington",
+        fullName: "Washington Commanders",
+        sport: "NFL",
+        aliases: ["DC", "WSH"],
+    },
+    // ── NHL (32) ────────────────────────────────────────────────────────────
+    {
+        abbr: "ANA",
+        nickname: "Ducks",
+        city: "Anaheim",
+        fullName: "Anaheim Ducks",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "BOS",
+        nickname: "Bruins",
+        city: "Boston",
+        fullName: "Boston Bruins",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "BUF",
+        nickname: "Sabres",
+        city: "Buffalo",
+        fullName: "Buffalo Sabres",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "CGY",
+        nickname: "Flames",
+        city: "Calgary",
+        fullName: "Calgary Flames",
+        sport: "NHL",
+        aliases: ["CAL"],
+    },
+    {
+        abbr: "CAR",
+        nickname: "Hurricanes",
+        city: "Carolina",
+        fullName: "Carolina Hurricanes",
+        sport: "NHL",
+        aliases: ["Canes", "Raleigh"],
+    },
+    {
+        abbr: "CHI",
+        nickname: "Blackhawks",
+        city: "Chicago",
+        fullName: "Chicago Blackhawks",
+        sport: "NHL",
+        aliases: ["Hawks"],
+    },
+    {
+        abbr: "COL",
+        nickname: "Avalanche",
+        city: "Colorado",
+        fullName: "Colorado Avalanche",
+        sport: "NHL",
+        aliases: ["Avs", "Denver"],
+    },
+    {
+        abbr: "CBJ",
+        nickname: "Blue Jackets",
+        city: "Columbus",
+        fullName: "Columbus Blue Jackets",
+        sport: "NHL",
+        aliases: ["Jackets"],
+    },
+    {
+        abbr: "DAL",
+        nickname: "Stars",
+        city: "Dallas",
+        fullName: "Dallas Stars",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "DET",
+        nickname: "Red Wings",
+        city: "Detroit",
+        fullName: "Detroit Red Wings",
+        sport: "NHL",
+        aliases: ["Wings"],
+    },
+    {
+        abbr: "EDM",
+        nickname: "Oilers",
+        city: "Edmonton",
+        fullName: "Edmonton Oilers",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "FLA",
+        nickname: "Panthers",
+        city: "Florida",
+        fullName: "Florida Panthers",
+        sport: "NHL",
+        aliases: ["Cats", "Sunrise"],
+    },
+    {
+        abbr: "LAK",
+        nickname: "Kings",
+        city: "Los Angeles",
+        fullName: "Los Angeles Kings",
+        sport: "NHL",
+        aliases: ["LA Kings"],
+    },
+    {
+        abbr: "MIN",
+        nickname: "Wild",
+        city: "Minnesota",
+        fullName: "Minnesota Wild",
+        sport: "NHL",
+        aliases: ["Minneapolis", "St Paul"],
+    },
+    {
+        abbr: "MTL",
+        nickname: "Canadiens",
+        city: "Montreal",
+        fullName: "Montreal Canadiens",
+        sport: "NHL",
+        aliases: ["Habs", "MON"],
+    },
+    {
+        abbr: "NSH",
+        nickname: "Predators",
+        city: "Nashville",
+        fullName: "Nashville Predators",
+        sport: "NHL",
+        aliases: ["Preds"],
+    },
+    {
+        abbr: "NJD",
+        nickname: "Devils",
+        city: "New Jersey",
+        fullName: "New Jersey Devils",
+        sport: "NHL",
+        aliases: ["NJ", "Newark"],
+    },
+    {
+        abbr: "NYI",
+        nickname: "Islanders",
+        city: "New York",
+        fullName: "New York Islanders",
+        sport: "NHL",
+        aliases: ["Isles", "NY Islanders"],
+    },
+    {
+        abbr: "NYR",
+        nickname: "Rangers",
+        city: "New York",
+        fullName: "New York Rangers",
+        sport: "NHL",
+        aliases: ["NY Rangers"],
+    },
+    {
+        abbr: "OTT",
+        nickname: "Senators",
+        city: "Ottawa",
+        fullName: "Ottawa Senators",
+        sport: "NHL",
+        aliases: ["Sens"],
+    },
+    {
+        abbr: "PHI",
+        nickname: "Flyers",
+        city: "Philadelphia",
+        fullName: "Philadelphia Flyers",
+        sport: "NHL",
+        aliases: ["Philly"],
+    },
+    {
+        abbr: "PIT",
+        nickname: "Penguins",
+        city: "Pittsburgh",
+        fullName: "Pittsburgh Penguins",
+        sport: "NHL",
+        aliases: ["Pens"],
+    },
+    {
+        abbr: "SJS",
+        nickname: "Sharks",
+        city: "San Jose",
+        fullName: "San Jose Sharks",
+        sport: "NHL",
+        aliases: ["SJ"],
+    },
+    {
+        abbr: "SEA",
+        nickname: "Kraken",
+        city: "Seattle",
+        fullName: "Seattle Kraken",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "STL",
+        nickname: "Blues",
+        city: "St. Louis",
+        fullName: "St. Louis Blues",
+        sport: "NHL",
+        aliases: ["Saint Louis", "St Louis"],
+    },
+    {
+        abbr: "TBL",
+        nickname: "Lightning",
+        city: "Tampa Bay",
+        fullName: "Tampa Bay Lightning",
+        sport: "NHL",
+        aliases: ["Bolts", "TB", "Tampa"],
+    },
+    {
+        abbr: "TOR",
+        nickname: "Maple Leafs",
+        city: "Toronto",
+        fullName: "Toronto Maple Leafs",
+        sport: "NHL",
+        aliases: ["Leafs"],
+    },
+    {
+        abbr: "VAN",
+        nickname: "Canucks",
+        city: "Vancouver",
+        fullName: "Vancouver Canucks",
+        sport: "NHL",
+        aliases: [],
+    },
+    {
+        abbr: "VGK",
+        nickname: "Golden Knights",
+        city: "Vegas",
+        fullName: "Vegas Golden Knights",
+        sport: "NHL",
+        aliases: ["VGS", "Las Vegas", "Knights"],
+    },
+    {
+        abbr: "WAS",
+        nickname: "Capitals",
+        city: "Washington",
+        fullName: "Washington Capitals",
+        sport: "NHL",
+        aliases: ["DC", "WSH", "Caps"],
+    },
+    {
+        abbr: "WPG",
+        nickname: "Jets",
+        city: "Winnipeg",
+        fullName: "Winnipeg Jets",
+        sport: "NHL",
+        aliases: ["WIN"],
+    },
+    {
+        abbr: "UTA",
+        nickname: "Hockey Club",
+        city: "Utah",
+        fullName: "Utah Hockey Club",
+        sport: "NHL",
+        aliases: ["UHC", "Salt Lake"],
+    },
+    // ── MLB (30) ────────────────────────────────────────────────────────────
+    {
+        abbr: "ARI",
+        nickname: "Diamondbacks",
+        city: "Arizona",
+        fullName: "Arizona Diamondbacks",
+        sport: "MLB",
+        aliases: ["D-backs", "Dbacks", "Phoenix"],
+    },
+    {
+        abbr: "ATL",
+        nickname: "Braves",
+        city: "Atlanta",
+        fullName: "Atlanta Braves",
+        sport: "MLB",
+        aliases: [],
+    },
+    {
+        abbr: "BAL",
+        nickname: "Orioles",
+        city: "Baltimore",
+        fullName: "Baltimore Orioles",
+        sport: "MLB",
+        aliases: ["O's"],
+    },
+    {
+        abbr: "BOS",
+        nickname: "Red Sox",
+        city: "Boston",
+        fullName: "Boston Red Sox",
+        sport: "MLB",
+        aliases: ["Sox", "BoSox"],
+    },
+    {
+        abbr: "CHC",
+        nickname: "Cubs",
+        city: "Chicago",
+        fullName: "Chicago Cubs",
+        sport: "MLB",
+        aliases: [],
+    },
+    {
+        abbr: "CHW",
+        nickname: "White Sox",
+        city: "Chicago",
+        fullName: "Chicago White Sox",
+        sport: "MLB",
+        aliases: ["CWS", "Sox"],
+    },
+    {
+        abbr: "CIN",
+        nickname: "Reds",
+        city: "Cincinnati",
+        fullName: "Cincinnati Reds",
+        sport: "MLB",
+        aliases: ["Cincy"],
+    },
+    {
+        abbr: "CLE",
+        nickname: "Guardians",
+        city: "Cleveland",
+        fullName: "Cleveland Guardians",
+        sport: "MLB",
+        aliases: ["Guards"],
+    },
+    {
+        abbr: "COL",
+        nickname: "Rockies",
+        city: "Colorado",
+        fullName: "Colorado Rockies",
+        sport: "MLB",
+        aliases: ["Denver"],
+    },
+    {
+        abbr: "DET",
+        nickname: "Tigers",
+        city: "Detroit",
+        fullName: "Detroit Tigers",
+        sport: "MLB",
+        aliases: [],
+    },
+    {
+        abbr: "HOU",
+        nickname: "Astros",
+        city: "Houston",
+        fullName: "Houston Astros",
+        sport: "MLB",
+        aliases: ["Stros"],
+    },
+    {
+        abbr: "KC",
+        nickname: "Royals",
+        city: "Kansas City",
+        fullName: "Kansas City Royals",
+        sport: "MLB",
+        aliases: ["KCR"],
+    },
+    {
+        abbr: "LAA",
+        nickname: "Angels",
+        city: "Los Angeles",
+        fullName: "Los Angeles Angels",
+        sport: "MLB",
+        aliases: ["LA Angels", "Anaheim", "Halos"],
+    },
+    {
+        abbr: "LAD",
+        nickname: "Dodgers",
+        city: "Los Angeles",
+        fullName: "Los Angeles Dodgers",
+        sport: "MLB",
+        aliases: ["LA Dodgers"],
+    },
+    {
+        abbr: "MIA",
+        nickname: "Marlins",
+        city: "Miami",
+        fullName: "Miami Marlins",
+        sport: "MLB",
+        aliases: ["Fish"],
+    },
+    {
+        abbr: "MIL",
+        nickname: "Brewers",
+        city: "Milwaukee",
+        fullName: "Milwaukee Brewers",
+        sport: "MLB",
+        aliases: ["Brew Crew"],
+    },
+    {
+        abbr: "MIN",
+        nickname: "Twins",
+        city: "Minnesota",
+        fullName: "Minnesota Twins",
+        sport: "MLB",
+        aliases: ["Minneapolis"],
+    },
+    {
+        abbr: "NYM",
+        nickname: "Mets",
+        city: "New York",
+        fullName: "New York Mets",
+        sport: "MLB",
+        aliases: ["NY Mets"],
+    },
+    {
+        abbr: "NYY",
+        nickname: "Yankees",
+        city: "New York",
+        fullName: "New York Yankees",
+        sport: "MLB",
+        aliases: ["NY Yankees", "Yanks", "Bronx Bombers"],
+    },
+    {
+        abbr: "OAK",
+        nickname: "Athletics",
+        city: "Oakland",
+        fullName: "Oakland Athletics",
+        sport: "MLB",
+        aliases: ["A's", "As"],
+    },
+    {
+        abbr: "PHI",
+        nickname: "Phillies",
+        city: "Philadelphia",
+        fullName: "Philadelphia Phillies",
+        sport: "MLB",
+        aliases: ["Philly"],
+    },
+    {
+        abbr: "PIT",
+        nickname: "Pirates",
+        city: "Pittsburgh",
+        fullName: "Pittsburgh Pirates",
+        sport: "MLB",
+        aliases: ["Bucs"],
+    },
+    {
+        abbr: "SD",
+        nickname: "Padres",
+        city: "San Diego",
+        fullName: "San Diego Padres",
+        sport: "MLB",
+        aliases: ["SDP"],
+    },
+    {
+        abbr: "SF",
+        nickname: "Giants",
+        city: "San Francisco",
+        fullName: "San Francisco Giants",
+        sport: "MLB",
+        aliases: ["SFG"],
+    },
+    {
+        abbr: "SEA",
+        nickname: "Mariners",
+        city: "Seattle",
+        fullName: "Seattle Mariners",
+        sport: "MLB",
+        aliases: ["M's", "Ms"],
+    },
+    {
+        abbr: "STL",
+        nickname: "Cardinals",
+        city: "St. Louis",
+        fullName: "St. Louis Cardinals",
+        sport: "MLB",
+        aliases: ["Cards", "Saint Louis", "St Louis"],
+    },
+    {
+        abbr: "TB",
+        nickname: "Rays",
+        city: "Tampa Bay",
+        fullName: "Tampa Bay Rays",
+        sport: "MLB",
+        aliases: ["TBR", "Tampa"],
+    },
+    {
+        abbr: "TEX",
+        nickname: "Rangers",
+        city: "Texas",
+        fullName: "Texas Rangers",
+        sport: "MLB",
+        aliases: ["Arlington"],
+    },
+    {
+        abbr: "TOR",
+        nickname: "Blue Jays",
+        city: "Toronto",
+        fullName: "Toronto Blue Jays",
+        sport: "MLB",
+        aliases: ["Jays"],
+    },
+    {
+        abbr: "WAS",
+        nickname: "Nationals",
+        city: "Washington",
+        fullName: "Washington Nationals",
+        sport: "MLB",
+        aliases: ["DC", "WSH", "Nats"],
+    },
+];
+/**
+ * Fuzzy team search — matches query against abbreviation, nickname, city,
+ * fullName, and aliases. Returns scored results sorted by match quality.
+ */
+function searchTeams(query, sportFilter) {
+    const q = query.toLowerCase().trim();
+    if (!q)
+        return [];
+    const results = [];
+    for (const team of TEAMS) {
+        if (sportFilter && team.sport !== sportFilter)
+            continue;
+        let score = 0;
+        const abbrL = team.abbr.toLowerCase();
+        const nickL = team.nickname.toLowerCase();
+        const cityL = team.city.toLowerCase();
+        const fullL = team.fullName.toLowerCase();
+        // Exact matches (highest priority)
+        if (abbrL === q)
+            score = 100;
+        else if (nickL === q)
+            score = 95;
+        else if (fullL === q)
+            score = 90;
+        else if (cityL === q)
+            score = 85;
+        // Alias exact match
+        else if (team.aliases.some((a) => a.toLowerCase() === q))
+            score = 80;
+        // Starts-with matches
+        else if (nickL.startsWith(q))
+            score = 70;
+        else if (cityL.startsWith(q))
+            score = 65;
+        else if (abbrL.startsWith(q))
+            score = 60;
+        // Contains matches
+        else if (fullL.includes(q))
+            score = 50;
+        else if (nickL.includes(q))
+            score = 45;
+        else if (team.aliases.some((a) => a.toLowerCase().includes(q)))
+            score = 40;
+        if (score > 0) {
+            results.push({ ...team, score });
+        }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+/**
+ * Resolve a query to the single best-matching team.
+ * If sport is given, only matches within that sport.
+ */
+function resolveTeam(query, sport) {
+    const matches = searchTeams(query, sport);
+    return matches.length > 0 ? matches[0] : null;
+}
 async function apiFetch(opts) {
     const url = new URL(opts.path, API_BASE);
     if (opts.params) {
@@ -83,7 +1138,6 @@ async function apiFetch(opts) {
             const remainDay = res.headers.get("X-RateLimit-Remaining-Day") || "0";
             throw new Error(`Rate limit exceeded. Remaining: ${remainHour}/hour, ${remainDay}/day. Retry after ${retryAfter}s.`);
         }
-        // FINDING 5 FIX: Don't forward raw response body — may contain internal details
         if (status === 403)
             throw new Error("Access denied. Your subscription may have expired.");
         if (status === 404)
@@ -97,15 +1151,59 @@ async function apiFetch(opts) {
     }
     return (await res.json());
 }
+// ─── Formatting Helpers ─────────────────────────────────────────────────────
+function formatPick(p) {
+    const pick = p.predicted_winner || p.predicted_pick || p.predicted_direction;
+    const isHomePick = pick === p.home_team || pick === "HOME" || pick === "OVER";
+    const edge = isHomePick
+        ? (p.home_edge ?? p.away_edge)
+        : (p.away_edge ?? p.home_edge);
+    const tier = p.confidence_tier ? ` [${p.confidence_tier}]` : "";
+    let line = `${p.away_team} @ ${p.home_team}`;
+    line += `\n  Game ID: ${p.game_id}`;
+    line += `\n  Pick: ${pick} (${p.confidence}% conf`;
+    if (edge)
+        line += `, ${edge}% edge`;
+    line += `)${tier}`;
+    if (p.market === "spread" && p.spread_line != null) {
+        line += `\n  Line: ${p.spread_line}`;
+    }
+    if (p.market === "totals" && p.totals_line != null) {
+        line += `\n  Line: ${p.totals_line}`;
+    }
+    if (p.home_odds) {
+        line += `\n  Odds: ${p.home_odds}/${p.away_odds}`;
+    }
+    if (p.commence_time) {
+        const time = new Date(p.commence_time).toLocaleString("en-US", {
+            timeZone: "America/New_York",
+            weekday: "short",
+            month: "short",
+            day: "numeric",
+            hour: "numeric",
+            minute: "2-digit",
+            timeZoneName: "short",
+        });
+        line += `\n  Game: ${time}`;
+    }
+    return line;
+}
+function formatRateLimit(rl) {
+    if (!rl)
+        return "";
+    return `\nRate limit: ${rl.remaining_hour}/hour, ${rl.remaining_day}/day remaining.`;
+}
 // ─── Server Setup ───────────────────────────────────────────────────────────
 const server = new McpServer({
     name: "Da Vinci Bets",
-    version: "1.0.1",
+    version: "1.3.0",
 });
 // ─── Tool: get_predictions ──────────────────────────────────────────────────
-server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by sport, market, and confidence. " +
-    "Returns predictions with win probabilities, odds, edge values, and confidence tiers. " +
-    "Covers NBA, NFL, NHL, and MLB across moneylines, spreads, and totals.", {
+server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by sport, market, team, and confidence. " +
+    "Returns predictions with win probabilities, odds, edge values, confidence tiers, and game IDs. " +
+    "Covers NBA, NFL, NHL, and MLB across moneylines, spreads, and totals. " +
+    "Use the team parameter to find predictions for a specific team (e.g., 'Lakers', 'NYY', 'Chiefs'). " +
+    "Game IDs from results can be used with get_pick_card to render shareable images.", {
     sport: z
         .enum(["NBA", "NFL", "NHL", "MLB"])
         .optional()
@@ -114,6 +1212,12 @@ server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by
         .enum(["moneyline", "spread", "totals"])
         .default("moneyline")
         .describe("Betting market type."),
+    team: z
+        .string()
+        .optional()
+        .describe("Filter by team name, abbreviation, or city. " +
+        "Examples: 'Lakers', 'LAL', 'NYY', 'Chiefs', 'Boston'. " +
+        "Resolved intelligently — abbreviations, nicknames, and cities all work."),
     sort: z
         .enum(["confidence", "edge", "game_time"])
         .default("confidence")
@@ -132,7 +1236,7 @@ server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by
         .max(100)
         .default(60)
         .describe("Minimum confidence percentage (0-100)."),
-}, async ({ sport, market, sort, limit, min_confidence }) => {
+}, async ({ sport, market, team, sort, limit, min_confidence }) => {
     try {
         const params = {
             market,
@@ -142,37 +1246,45 @@ server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by
         };
         if (sport)
             params.sport = sport;
+        // Resolve team name to canonical form for API filter
+        if (team) {
+            const resolved = resolveTeam(team, sport || undefined);
+            if (resolved) {
+                params.team = resolved.nickname;
+                if (!sport)
+                    params.sport = resolved.sport;
+            }
+            else {
+                // Pass raw query — API does ILIKE matching
+                params.team = team;
+            }
+        }
         const data = await apiFetch({
             path: "/api/v1/predictions",
             params,
         });
-        const summary = [
-            `Found ${data.meta?.total ?? data.predictions.length} ${market} predictions${sport ? ` for ${sport}` : ""}.`,
-            `Rate limit: ${data.rate_limit?.remaining_hour ?? "?"}/hour, ${data.rate_limit?.remaining_day ?? "?"}/day remaining.`,
-            "",
-            ...data.predictions.map((p, i) => {
-                const conf = p.confidence;
-                const pick = p.predicted_winner || p.predicted_pick || p.predicted_direction;
-                const edge = p.home_edge || p.away_edge;
-                let line = `${i + 1}. ${p.away_team} @ ${p.home_team} — Pick: ${pick} (${conf}% conf`;
-                if (edge)
-                    line += `, ${edge}% edge`;
-                line += ")";
-                if (market === "spread" && p.spread_line != null) {
-                    line += ` | Line: ${p.spread_line}`;
-                }
-                if (market === "totals" && p.totals_line != null) {
-                    line += ` | Line: ${p.totals_line}`;
-                }
-                if (p.home_odds) {
-                    line += ` | Odds: ${p.home_odds}/${p.away_odds}`;
-                }
-                return line;
-            }),
-        ].join("\n");
+        if (data.predictions.length === 0) {
+            const teamHint = team ? ` for "${team}"` : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No ${market} predictions found${teamHint}${sport ? ` in ${sport}` : ""}. ` +
+                            `Games may not be scheduled, or try lowering min_confidence (currently ${min_confidence}%).`,
+                    },
+                ],
+            };
+        }
+        const lines = data.predictions.map((p, i) => `${i + 1}. ${formatPick(p)}`);
+        const header = [
+            `Found ${data.meta.total} ${market} predictions${sport ? ` for ${sport}` : ""}${team ? ` matching "${team}"` : ""}.`,
+            formatRateLimit(data.rate_limit),
+        ]
+            .filter(Boolean)
+            .join("");
         return {
             content: [
-                { type: "text", text: summary },
+                { type: "text", text: header + "\n\n" + lines.join("\n\n") },
                 {
                     type: "text",
                     text: "\n---\nRaw JSON:\n" + JSON.stringify(data.predictions, null, 2),
@@ -184,10 +1296,196 @@ server.tool("get_predictions", "Fetch AI-powered sports predictions filtered by
         return errorResult(err);
     }
 });
+// ─── Tool: get_game ─────────────────────────────────────────────────────────
+server.tool("get_game", "Find a specific game's prediction by team name. This is the intelligent lookup tool — " +
+    "give it a team name (nickname, abbreviation, or city) and it finds the matching game. " +
+    "Returns the full prediction with game_id, confidence, odds, edge, and game time. " +
+    "Optionally specify an opponent to find a specific matchup (e.g., team='Lakers', opponent='Celtics'). " +
+    "The game_id in the response can be used with get_pick_card to render a shareable image.", {
+    team: z
+        .string()
+        .describe("Team to look up. Accepts nickname ('Lakers'), abbreviation ('LAL'), " +
+        "city ('Los Angeles'), or full name ('Los Angeles Lakers')."),
+    opponent: z
+        .string()
+        .optional()
+        .describe("Optional opponent to narrow to a specific matchup. " +
+        "Example: team='Lakers', opponent='Celtics'."),
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Sport hint. Auto-detected from team name if omitted."),
+    market: z
+        .enum(["moneyline", "spread", "totals"])
+        .default("moneyline")
+        .describe("Which market to look up."),
+}, async ({ team, opponent, sport, market }) => {
+    try {
+        // Resolve team
+        const resolved = resolveTeam(team, sport || undefined);
+        if (!resolved) {
+            // Suggest closest matches
+            const suggestions = searchTeams(team)
+                .slice(0, 5)
+                .map((t) => `  ${t.abbr} — ${t.fullName} (${t.sport})`)
+                .join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Could not resolve team "${team}". ` +
+                            (suggestions
+                                ? `Did you mean:\n${suggestions}`
+                                : "Try using the full team name or abbreviation."),
+                    },
+                ],
+            };
+        }
+        const detectedSport = sport || resolved.sport;
+        // Fetch predictions for this team
+        const params = {
+            sport: detectedSport,
+            market,
+            sort: "game_time",
+            limit: "10",
+            min_confidence: "0",
+            team: resolved.nickname,
+        };
+        const data = await apiFetch({
+            path: "/api/v1/predictions",
+            params,
+        });
+        let matches = data.predictions;
+        // Filter by opponent if specified
+        if (opponent && matches.length > 0) {
+            const oppResolved = resolveTeam(opponent, detectedSport);
+            const oppName = oppResolved
+                ? oppResolved.nickname.toLowerCase()
+                : opponent.toLowerCase();
+            matches = matches.filter((p) => p.home_team.toLowerCase().includes(oppName) ||
+                p.away_team.toLowerCase().includes(oppName));
+        }
+        if (matches.length === 0) {
+            const oppHint = opponent ? ` vs ${opponent}` : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No upcoming ${market} prediction found for ${resolved.fullName}${oppHint}. ` +
+                            `The team may not have games scheduled in the current prediction window.`,
+                    },
+                ],
+            };
+        }
+        // Return the best match (first upcoming game)
+        const game = matches[0];
+        const allGames = matches.length > 1
+            ? `\n\n─── Other upcoming games ───\n${matches
+                .slice(1)
+                .map((p) => `${p.away_team} @ ${p.home_team} | Game ID: ${p.game_id}`)
+                .join("\n")}`
+            : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${resolved.fullName} (${resolved.abbr}) — ${detectedSport} ${market}\n` +
+                        `${"═".repeat(50)}\n\n` +
+                        formatPick(game) +
+                        allGames +
+                        formatRateLimit(data.rate_limit) +
+                        `\n\nUse game_id "${game.game_id}" with get_pick_card to render a shareable image.`,
+                },
+                {
+                    type: "text",
+                    text: "\n---\nRaw JSON:\n" + JSON.stringify(game, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
+// ─── Tool: lookup_teams ─────────────────────────────────────────────────────
+server.tool("lookup_teams", "Search the team registry by name, abbreviation, city, or sport. " +
+    "Returns matching teams with their abbreviation, full name, sport, and aliases. " +
+    "Useful for discovering team names before using get_game or get_predictions. " +
+    "Omit query to list all teams for a sport. " +
+    "Does not call the API — instant local lookup, no rate limit impact.", {
+    query: z
+        .string()
+        .optional()
+        .describe("Search query — team name, abbreviation, or city. " +
+        "Examples: 'NY', 'Lakers', 'CHI', 'Boston'. Omit to list all teams for a sport."),
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Filter to a specific sport. Omit for all sports."),
+}, async ({ query, sport }) => {
+    if (!query && !sport) {
+        // List summary
+        const counts = { NBA: 0, NFL: 0, NHL: 0, MLB: 0 };
+        for (const t of TEAMS)
+            counts[t.sport]++;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Da Vinci Bets covers ${TEAMS.length} teams:\n` +
+                        Object.entries(counts)
+                            .map(([s, n]) => `  ${s}: ${n} teams`)
+                            .join("\n") +
+                        `\n\nUse query or sport to search. Examples:\n` +
+                        `  lookup_teams(query="NY") — all NY teams\n` +
+                        `  lookup_teams(sport="NBA") — all NBA teams\n` +
+                        `  lookup_teams(query="CHI", sport="MLB") — Chicago MLB teams`,
+                },
+            ],
+        };
+    }
+    let results;
+    if (query) {
+        results = searchTeams(query, sport || undefined);
+    }
+    else {
+        // List all teams for the sport
+        results = TEAMS.filter((t) => t.sport === sport);
+    }
+    if (results.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No teams found${query ? ` matching "${query}"` : ""}${sport ? ` in ${sport}` : ""}.`,
+                },
+            ],
+        };
+    }
+    const lines = results.map((t) => {
+        let line = `${t.abbr.padEnd(4)} ${t.fullName} (${t.sport})`;
+        if (t.aliases.length > 0) {
+            line += ` — also: ${t.aliases.join(", ")}`;
+        }
+        return line;
+    });
+    const header = query
+        ? `Found ${results.length} teams matching "${query}"${sport ? ` in ${sport}` : ""}:`
+        : `All ${results.length} ${sport} teams:`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: header + "\n\n" + lines.join("\n"),
+            },
+        ],
+    };
+});
 // ─── Tool: get_top_picks ────────────────────────────────────────────────────
 server.tool("get_top_picks", "Get the highest-conviction AI picks across all sports and markets. " +
-    "Returns the top predictions sorted by confidence, great for daily briefings. " +
-    "Note: this fetches from 3 markets in parallel, consuming 3 API requests toward your rate limit.", {
+    "Returns the top predictions sorted by confidence with game IDs, great for daily briefings. " +
+    "Each pick includes a game_id you can use with get_pick_card. " +
+    "Note: fetches from 3 markets in parallel, consuming 3 API requests.", {
     count: z
         .number()
         .int()
@@ -204,7 +1502,6 @@ server.tool("get_top_picks", "Get the highest-conviction AI picks across all spo
         .describe("Minimum confidence percentage."),
 }, async ({ count, min_confidence }) => {
     try {
-        // Fetch top picks across all markets in parallel
         const markets = ["moneyline", "spread", "totals"];
         const results = await Promise.allSettled(markets.map((market) => apiFetch({
             path: "/api/v1/predictions",
@@ -228,8 +1525,7 @@ server.tool("get_top_picks", "Get the highest-conviction AI picks across all spo
                 failedMarkets.push(markets[i]);
             }
         }
-        // Sort by confidence descending, take top N
-        allPicks.sort((a, b) => Number(b.confidence || 0) - Number(a.confidence || 0));
+        allPicks.sort((a, b) => Number(b.confidence) - Number(a.confidence));
         const topN = allPicks.slice(0, count);
         if (topN.length === 0) {
             return {
@@ -242,39 +1538,22 @@ server.tool("get_top_picks", "Get the highest-conviction AI picks across all spo
             };
         }
         const lines = topN.map((p, i) => {
-            const conf = p.confidence;
-            const pick = p.predicted_winner ||
-                p.predicted_pick ||
-                p.predicted_direction ||
-                "N/A";
-            const sport = p.sport;
-            const market = p._market;
-            let line = `${i + 1}. [${sport}/${market}] ${p.away_team} @ ${p.home_team}`;
-            line += `\n   Pick: ${pick} | ${conf}% confidence`;
-            if (p.home_edge)
-                line += ` | ${p.home_edge}% edge`;
-            if (p.commence_time) {
-                const time = new Date(String(p.commence_time)).toLocaleString("en-US", {
-                    timeZone: "America/New_York",
-                    month: "short",
-                    day: "numeric",
-                    hour: "numeric",
-                    minute: "2-digit",
-                    timeZoneName: "short",
-                });
-                line += `\n   Game: ${time}`;
-            }
-            return line;
+            return `${i + 1}. [${p.sport}/${p._market}] ${formatPick(p)}`;
         });
-        let header = `Top ${topN.length} AI Picks (≥${min_confidence}% confidence):`;
+        let header = `Top ${topN.length} AI Picks (>=${min_confidence}% confidence):`;
         if (failedMarkets.length > 0) {
-            header += `\n⚠ Could not fetch ${failedMarkets.join(", ")} predictions. Results may be partial.`;
+            header += `\nWarning: Could not fetch ${failedMarkets.join(", ")} predictions.`;
         }
+        // Collect game IDs for quick reference
+        const gameIds = topN.map((p) => p.game_id);
         return {
             content: [
                 {
                     type: "text",
-                    text: header + "\n\n" + lines.join("\n\n"),
+                    text: header +
+                        "\n\n" +
+                        lines.join("\n\n") +
+                        `\n\n─── Game IDs (for get_pick_card) ───\n${gameIds.join("\n")}`,
                 },
             ],
         };
@@ -284,54 +1563,138 @@ server.tool("get_top_picks", "Get the highest-conviction AI picks across all spo
     }
 });
 // ─── Tool: get_pick_card ────────────────────────────────────────────────────
-server.tool("get_pick_card", "Render a prediction as a shareable 1080×1350 PNG image card with ESPN logos, " +
+server.tool("get_pick_card", "Render a prediction as a shareable 1080x1350 PNG image card with ESPN logos, " +
     "L5 form dots, confidence bar, expanded AI analysis, and injuries. " +
-    "Powered by Browserless screenshot engine. Great for social media. " +
-    "Requires a game_id from get_predictions results. " +
+    "Returns a permanent public URL (cached in Supabase Storage) plus an inline image preview. " +
+    "Use the URL for video editing, social media posts, or embedding anywhere. " +
+    "Accepts a game_id from get_predictions, get_game, or get_top_picks results. " +
+    "You can also pass a team name instead of game_id — it will resolve automatically. " +
     "Partner-tier keys recommended (higher rate limits for batch generation).", {
     game_id: z
         .string()
-        .regex(/^[a-zA-Z0-9_-]+$/, "game_id must be alphanumeric with _ or -")
-        .max(100)
-        .describe("The game_id from a prediction result. Use get_predictions first to find game IDs."),
+        .optional()
+        .describe("The game_id from a prediction result. Use get_predictions or get_game to find game IDs."),
+    team: z
+        .string()
+        .optional()
+        .describe("Alternative to game_id — pass a team name and the card for their next game is rendered. " +
+        "Examples: 'Lakers', 'NYY'. Requires an extra API call to resolve."),
     sport: z
         .enum(["NBA", "NFL", "NHL", "MLB"])
         .optional()
         .describe("Sport for the game (helps with lookup speed)."),
-}, async ({ game_id, sport }) => {
+}, async ({ game_id, team, sport }) => {
     try {
+        let resolvedGameId = game_id;
+        // If team given instead of game_id, resolve it
+        if (!resolvedGameId && team) {
+            const resolved = resolveTeam(team, sport || undefined);
+            const teamName = resolved ? resolved.nickname : team;
+            const teamSport = sport || resolved?.sport;
+            const params = {
+                market: "moneyline",
+                sort: "game_time",
+                limit: "1",
+                min_confidence: "0",
+                team: teamName,
+            };
+            if (teamSport)
+                params.sport = teamSport;
+            const data = await apiFetch({
+                path: "/api/v1/predictions",
+                params,
+            });
+            if (data.predictions.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No upcoming game found for "${team}". Cannot render card.`,
+                        },
+                    ],
+                };
+            }
+            resolvedGameId = data.predictions[0].game_id;
+        }
+        if (!resolvedGameId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Please provide either a game_id or team name.",
+                    },
+                ],
+            };
+        }
+        // Validate game_id format
+        if (!/^[a-zA-Z0-9_-]+$/.test(resolvedGameId)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Invalid game_id format. Must be alphanumeric with _ or -.",
+                    },
+                ],
+            };
+        }
         const params = {};
         if (sport)
             params.sport = sport;
-        const imageBuffer = await apiFetch({
-            path: `/api/social/card-render/${encodeURIComponent(game_id)}`,
+        // Get permanent public URL
+        const cardData = await apiFetch({
+            path: `/api/social/card-url/${encodeURIComponent(resolvedGameId)}`,
             params,
-            raw: true,
         });
-        const base64 = Buffer.from(imageBuffer).toString("base64");
-        return {
-            content: [
-                {
-                    type: "image",
-                    data: base64,
-                    mimeType: "image/png",
-                },
-                {
-                    type: "text",
-                    text: `Pick card rendered for game ${game_id} (1080×1350 PNG, ${Math.round(imageBuffer.byteLength / 1024)}KB).`,
-                },
-            ],
-        };
+        // Also fetch the actual image for inline preview
+        let imageContent = null;
+        try {
+            const imageBuffer = await apiFetch({
+                path: `/api/social/card-render/${encodeURIComponent(resolvedGameId)}`,
+                params,
+                raw: true,
+            });
+            imageContent = {
+                type: "image",
+                data: Buffer.from(imageBuffer).toString("base64"),
+                mimeType: "image/png",
+            };
+        }
+        catch {
+            // Image preview is optional
+        }
+        const content = [];
+        if (imageContent) {
+            content.push(imageContent);
+        }
+        const sizeKB = cardData.size
+            ? `${Math.round(cardData.size / 1024)}KB`
+            : "unknown size";
+        content.push({
+            type: "text",
+            text: [
+                `Pick card for game ${resolvedGameId} (1080x1350 PNG, ${sizeKB})`,
+                ``,
+                `Public URL: ${cardData.url}`,
+                `Cached: ${cardData.cached}`,
+                cardData.rendered_at ? `Rendered: ${cardData.rendered_at}` : "",
+                ``,
+                `Use this URL in videos, social media posts, or anywhere you need the image.`,
+            ]
+                .filter(Boolean)
+                .join("\n"),
+        });
+        return { content };
     }
     catch (err) {
         return errorResult(err);
     }
 });
 // ─── Tool: get_batch_cards ──────────────────────────────────────────────────
-server.tool("get_batch_cards", "Render multiple pick cards as PNG images in one call. " +
-    "Designed for marketing teams generating social media content. " +
-    "Partner-tier API key required for batch operations. " +
-    "Returns one image per game_id.", {
+server.tool("get_batch_cards", "Render multiple pick cards and return permanent public URLs for each. " +
+    "Designed for marketing teams generating social media content and video assets. " +
+    "Each card is cached in Supabase Storage — subsequent calls return cached URLs instantly. " +
+    "Partner-tier API key recommended. Max 10 per call. " +
+    "Returns URLs suitable for video editing, social posts, or any image embed.", {
     game_ids: z
         .array(z
         .string()
@@ -350,26 +1713,25 @@ server.tool("get_batch_cards", "Render multiple pick cards as PNG images in one
         if (sport)
             params.sport = sport;
         const results = await Promise.allSettled(game_ids.map(async (gid) => {
-            const buf = await apiFetch({
-                path: `/api/social/card-render/${encodeURIComponent(gid)}`,
+            const data = await apiFetch({
+                path: `/api/social/card-url/${encodeURIComponent(gid)}`,
                 params,
-                raw: true,
             });
-            return { game_id: gid, buffer: buf };
+            return data;
         }));
         const content = [];
+        const urls = [];
         let successCount = 0;
         for (const r of results) {
             if (r.status === "fulfilled") {
-                const base64 = Buffer.from(r.value.buffer).toString("base64");
-                content.push({
-                    type: "image",
-                    data: base64,
-                    mimeType: "image/png",
-                });
+                urls.push(r.value.url);
+                const sizeKB = r.value.size
+                    ? `${Math.round(r.value.size / 1024)}KB`
+                    : "";
+                const cached = r.value.cached ? " (cached)" : " (fresh render)";
                 content.push({
                     type: "text",
-                    text: `Card: ${r.value.game_id} (${Math.round(r.value.buffer.byteLength / 1024)}KB)`,
+                    text: `${r.value.game_id}: ${r.value.url}${sizeKB ? ` — ${sizeKB}` : ""}${cached}`,
                 });
                 successCount++;
             }
@@ -382,8 +1744,14 @@ server.tool("get_batch_cards", "Render multiple pick cards as PNG images in one
         }
         content.unshift({
             type: "text",
-            text: `Rendered ${successCount}/${game_ids.length} pick cards.`,
+            text: `Rendered ${successCount}/${game_ids.length} pick cards.\n\nPublic URLs:`,
         });
+        if (urls.length > 0) {
+            content.push({
+                type: "text",
+                text: `\n---\nAll URLs:\n${urls.join("\n")}`,
+            });
+        }
         return { content };
     }
     catch (err) {
@@ -392,20 +1760,17 @@ server.tool("get_batch_cards", "Render multiple pick cards as PNG images in one
 });
 // ─── Tool: get_performance ──────────────────────────────────────────────────
 server.tool("get_performance", "Get a snapshot of current active predictions across sports and markets. " +
-    "Shows prediction counts, confidence distribution, and available coverage. " +
-    "For historical win rates, visit davincibets.io/analytics.", {
+    "Shows prediction counts, confidence distribution, and available coverage.", {
     sport: z
         .enum(["NBA", "NFL", "NHL", "MLB"])
         .optional()
-        .describe("Filter performance to a specific sport."),
+        .describe("Filter to a specific sport."),
     market: z
         .enum(["moneyline", "spread", "totals"])
         .optional()
         .describe("Filter to a specific market."),
 }, async ({ sport, market }) => {
     try {
-        // Pull recent settled predictions to compute win rates
-        // We use the predictions endpoint with high confidence to show quality
         const params = {
             sort: "confidence",
             limit: "50",
@@ -419,7 +1784,6 @@ server.tool("get_performance", "Get a snapshot of current active predictions acr
             path: "/api/v1/predictions",
             params,
         });
-        // Summarize available predictions as a performance snapshot
         const byMarket = {};
         const bySport = {};
         const confBuckets = { high: 0, medium: 0 };
@@ -428,15 +1792,14 @@ server.tool("get_performance", "Get a snapshot of current active predictions acr
             const s = String(p.sport || "?");
             byMarket[m] = (byMarket[m] || 0) + 1;
             bySport[s] = (bySport[s] || 0) + 1;
-            const conf = Number(p.confidence || 0);
-            if (conf >= 65)
+            if (p.confidence >= 65)
                 confBuckets.high++;
             else
                 confBuckets.medium++;
         }
         const lines = [
             "Da Vinci Bets — Current Predictions Snapshot",
-            "═══════════════════════════════════════════════",
+            "═".repeat(50),
             `Total active predictions: ${data.meta?.total ?? data.predictions.length}`,
             "",
             "By Sport:",
@@ -446,13 +1809,9 @@ server.tool("get_performance", "Get a snapshot of current active predictions acr
             ...Object.entries(byMarket).map(([m, n]) => `  ${m}: ${n} picks`),
             "",
             "Confidence Distribution:",
-            `  High (≥65%): ${confBuckets.high} picks`,
+            `  High (>=65%): ${confBuckets.high} picks`,
             `  Medium (50-64%): ${confBuckets.medium} picks`,
-            "",
-            `Rate limit: ${data.rate_limit?.remaining_hour ?? "?"}/hour, ${data.rate_limit?.remaining_day ?? "?"}/day remaining.`,
-            "",
-            "Note: Historical win rates are available on the Da Vinci Bets analytics dashboard.",
-            "Visit https://www.davincibets.io/analytics for full performance tracking.",
+            formatRateLimit(data.rate_limit),
         ];
         return {
             content: [{ type: "text", text: lines.join("\n") }],
@@ -462,9 +1821,86 @@ server.tool("get_performance", "Get a snapshot of current active predictions acr
         return errorResult(err);
     }
 });
+// ─── Tool: get_track_record ─────────────────────────────────────────────────
+server.tool("get_track_record", "Get verified win rates, ROI, and historical performance from settled predictions. " +
+    "Shows actual results broken down by sport, market, and confidence tier. " +
+    "Includes current streak and recent settled picks. " +
+    "Public endpoint — does not count against your API rate limit.", {
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Filter to a specific sport. Omit for all."),
+    days: z
+        .number()
+        .int()
+        .min(7)
+        .max(365)
+        .default(30)
+        .describe("Lookback period in days (7-365)."),
+}, async ({ sport, days }) => {
+    try {
+        const params = { days: String(days) };
+        if (sport)
+            params.sport = sport;
+        const url = new URL("/api/track-record", API_BASE);
+        for (const [k, v] of Object.entries(params)) {
+            url.searchParams.set(k, v);
+        }
+        const res = await fetch(url.toString(), {
+            headers: { Accept: "application/json" },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!res.ok) {
+            throw new Error(`Track record request failed (HTTP ${res.status}).`);
+        }
+        const data = (await res.json());
+        const breakdownLines = data.breakdown.map((b) => {
+            const emoji = b.win_rate >= 55 ? "+" : b.win_rate >= 50 ? "~" : "-";
+            return `  ${b.sport} ${b.market_type}: ${b.wins}-${b.losses}${b.pushes ? `-${b.pushes}P` : ""} (${b.win_rate}% WR, ${emoji}${b.roi}% ROI)`;
+        });
+        const tierLines = data.confidenceTiers.map((t) => `  ${t.tier}%: ${t.wins}/${t.total} (${t.win_rate}% WR)`);
+        const recentLines = data.recentPicks.slice(0, 10).map((p) => {
+            const icon = p.result === "win" ? "W" : p.result === "loss" ? "L" : "P";
+            return `  [${icon}] ${p.sport} ${p.market_type}: ${p.pick_team}`;
+        });
+        const lines = [
+            `Da Vinci Bets — Track Record (${data.period})`,
+            "═".repeat(50),
+            data.streak ? `Current Streak: ${data.streak}` : "",
+            "",
+            "Performance by Sport & Market:",
+            ...breakdownLines,
+            "",
+            "By Confidence Tier:",
+            ...tierLines,
+            "",
+            `Recent Settled Picks (last ${Math.min(data.recentPicks.length, 10)}):`,
+            ...recentLines,
+        ].filter(Boolean);
+        return {
+            content: [
+                { type: "text", text: lines.join("\n") },
+                {
+                    type: "text",
+                    text: "\n---\nRaw JSON:\n" +
+                        JSON.stringify({
+                            period: data.period,
+                            streak: data.streak,
+                            breakdown: data.breakdown,
+                            confidenceTiers: data.confidenceTiers,
+                        }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
 // ─── Tool: get_schedule ─────────────────────────────────────────────────────
 server.tool("get_schedule", "Get today's game schedule with predictions summary. " +
-    "Shows which games have predictions available and their confidence levels.", {
+    "Shows which games have predictions available, their confidence levels, and game IDs. " +
+    "Game IDs can be used with get_pick_card or get_game for more details.", {
     sport: z
         .enum(["NBA", "NFL", "NHL", "MLB"])
         .describe("Which sport's schedule to retrieve."),
@@ -486,7 +1922,7 @@ server.tool("get_schedule", "Get today's game schedule with predictions summary.
                 content: [
                     {
                         type: "text",
-                        text: `No ${sport} games found in the current prediction window. The ${sport} season may be in offseason, or no games are scheduled for the next 48 hours.`,
+                        text: `No ${sport} games found in the current prediction window. The ${sport} season may be in offseason, or no games are scheduled.`,
                     },
                 ],
             };
@@ -498,7 +1934,7 @@ server.tool("get_schedule", "Get today's game schedule with predictions summary.
         ];
         for (const p of data.predictions) {
             const time = p.commence_time
-                ? new Date(String(p.commence_time)).toLocaleString("en-US", {
+                ? new Date(p.commence_time).toLocaleString("en-US", {
                     timeZone: "America/New_York",
                     weekday: "short",
                     month: "short",
@@ -508,12 +1944,14 @@ server.tool("get_schedule", "Get today's game schedule with predictions summary.
                     timeZoneName: "short",
                 })
                 : "TBD";
+            const tier = p.confidence_tier ? ` [${p.confidence_tier}]` : "";
             lines.push(`${time}`);
             lines.push(`  ${p.away_team} @ ${p.home_team}`);
-            lines.push(`  Pick: ${p.predicted_winner} (${p.confidence}% conf) | Game ID: ${p.game_id}`);
+            lines.push(`  Pick: ${p.predicted_winner} (${p.confidence}% conf)${tier}`);
+            lines.push(`  Game ID: ${p.game_id}`);
             lines.push("");
         }
-        lines.push("Use game_id values with get_pick_card to render shareable images.");
+        lines.push("Use game IDs with get_pick_card to render shareable images, or get_game for full details.");
         return {
             content: [{ type: "text", text: lines.join("\n") }],
         };
@@ -534,9 +1972,10 @@ function errorResult(err) {
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Da Vinci Bets MCP Server v1.0.1 — connected via stdio");
+    console.error("Da Vinci Bets MCP Server v1.3.1 — connected via stdio");
     console.error(`API: ${API_BASE}`);
     console.error(`Key: dvb_live_***`);
+    console.error(`Teams: ${TEAMS.length} teams loaded across 4 sports`);
 }
 main().catch((err) => {
     console.error("Fatal:", err);