@davincibets/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,211 @@
+# Da Vinci Bets MCP Server
+
+Give your AI assistant native access to AI-powered sports predictions.
+
+Works with **Claude Desktop**, **Claude Code**, **Cursor**, **Windsurf**, and any MCP-compatible client.
+
+## Quick Start
+
+### 1. Get your API key
+
+Go to [davincibets.io/settings](https://www.davincibets.io/settings) → **API** tab → Generate Key.
+
+Your key looks like: `dvb_live_a3f2...` — copy it immediately (shown once).
+
+### 2. Add to your AI assistant
+
+#### Claude Desktop
+
+Edit `~/.config/Claude/claude_desktop_config.json` (Mac/Linux) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "davinci-bets": {
+      "command": "npx",
+      "args": ["-y", "@davincibets/mcp-server@latest"],
+      "env": {
+        "DVB_API_KEY": "dvb_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+#### Claude Code
+
+```bash
+claude mcp add davinci-bets -- npx -y @davincibets/mcp-server@latest
+```
+
+Then set the environment variable:
+```bash
+export DVB_API_KEY="dvb_live_your_key_here"
+```
+
+Or add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "davinci-bets": {
+      "command": "npx",
+      "args": ["-y", "@davincibets/mcp-server@latest"],
+      "env": {
+        "DVB_API_KEY": "dvb_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+#### Cursor
+
+Open Settings → MCP Servers → Add:
+
+- **Name:** `davinci-bets`
+- **Command:** `npx`
+- **Args:** `-y @davincibets/mcp-server@latest`
+- **Env:** `DVB_API_KEY=dvb_live_your_key_here`
+
+#### Windsurf
+
+Add to your Windsurf MCP config:
+
+```json
+{
+  "mcpServers": {
+    "davinci-bets": {
+      "command": "npx",
+      "args": ["-y", "@davincibets/mcp-server@latest"],
+      "env": {
+        "DVB_API_KEY": "dvb_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### 3. Ask your AI
+
+Once connected, you can ask naturally:
+
+- *"What are today's highest confidence NBA picks?"*
+- *"Show me NFL spread predictions for this week"*
+- *"Get the top 5 picks across all sports"*
+- *"Generate a pick card image for the Lakers game"*
+- *"What's the MLB schedule with predictions?"*
+
+## Tools
+
+### `get_predictions`
+
+Fetch AI predictions by sport, market, and confidence.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `sport` | NBA, NFL, NHL, MLB | all | Filter by sport |
+| `market` | moneyline, spread, totals | moneyline | Betting market |
+| `sort` | confidence, edge, game_time | confidence | Sort order |
+| `limit` | 1-50 | 25 | Max results |
+| `min_confidence` | 0-100 | 60 | Minimum confidence % |
+
+### `get_top_picks`
+
+Get the highest-conviction picks across all sports and markets.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `count` | 1-20 | 10 | Number of top picks |
+| `min_confidence` | 0-100 | 65 | Minimum confidence % |
+
+### `get_schedule`
+
+Get today's game schedule with predictions for a sport.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `sport` | NBA, NFL, NHL, MLB | Yes | Which sport |
+
+### `get_pick_card`
+
+Render a prediction as a shareable 1080x1350 PNG image.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `game_id` | string | Yes | Game ID from predictions |
+| `sport` | NBA, NFL, NHL, MLB | No | Sport hint |
+
+### `get_batch_cards`
+
+Render multiple pick cards at once (up to 10). Designed for marketing teams.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `game_ids` | string[] | Yes | Array of game IDs (max 10) |
+| `sport` | NBA, NFL, NHL, MLB | No | Sport hint |
+
+### `get_performance`
+
+Get current prediction performance snapshot.
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `sport` | NBA, NFL, NHL, MLB | all | Filter by sport |
+| `market` | moneyline, spread, totals | all | Filter by market |
+
+## Rate Limits
+
+| Tier | Per Hour | Per Day | Who |
+|------|----------|---------|-----|
+| Personal | 50 | 500 | $8/mo subscribers |
+| Partner | 500 | 10,000 | Marketing agencies (DVB-Social) |
+| Internal | Unlimited | Unlimited | Da Vinci Bets systems |
+
+Rate limit info is included in prediction responses. When limits are hit, the server returns a clear error with retry timing.
+
+## For Marketing Teams (Partner Tier)
+
+DVB-Social and marketing partners get elevated rate limits for batch content generation:
+
+```
+# Example workflow in Claude:
+1. "Get today's NBA moneyline predictions"
+2. "Generate pick cards for all games above 70% confidence"
+3. "Also get the NHL schedule and render those cards too"
+```
+
+The `get_batch_cards` tool can render up to 10 cards per call — ideal for daily social media pipelines.
+
+Contact support@davincibets.io for partner API key provisioning.
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `DVB_API_KEY` | Yes | Your API key (`dvb_live_xxx`) |
+| `DVB_API_URL` | No | Override API base URL (default: `https://www.davincibets.io`) |
+
+## Requirements
+
+- Node.js 18+
+- A Da Vinci Bets premium subscription ($8/mo)
+- An API key from Settings → API tab
+
+## Development
+
+```bash
+# Clone and install
+cd packages/mcp-server
+npm install
+
+# Run locally
+DVB_API_KEY=dvb_live_xxx npm run dev
+
+# Build
+npm run build
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Da Vinci Bets MCP Server
+ *
+ * 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_top_picks     — Get highest-conviction picks across all sports
+ *   get_pick_card     — Render a pick as a shareable PNG (partner tier)
+ *   get_performance   — Win rates and track record stats
+ *
+ * Auth: DVB_API_KEY env var (dvb_live_xxx from Settings → API tab)
+ * Docs: https://www.davincibets.io/features
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,543 @@
+#!/usr/bin/env node
+/**
+ * Da Vinci Bets MCP Server
+ *
+ * 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_top_picks     — Get highest-conviction picks across all sports
+ *   get_pick_card     — Render a pick as a shareable PNG (partner tier)
+ *   get_performance   — Win rates and track record stats
+ *
+ * Auth: DVB_API_KEY env var (dvb_live_xxx from Settings → API tab)
+ * Docs: https://www.davincibets.io/features
+ */
+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 _rawUrl = process.env.DVB_API_URL || "https://www.davincibets.io";
+try {
+    const parsed = new URL(_rawUrl);
+    if (!ALLOWED_API_HOSTS.has(parsed.hostname)) {
+        console.error(`ERROR: DVB_API_URL host "${parsed.hostname}" is not allowed.\n` +
+            `Permitted: ${[...ALLOWED_API_HOSTS].join(", ")}`);
+        process.exit(1);
+    }
+}
+catch {
+    console.error(`ERROR: DVB_API_URL "${_rawUrl}" is not a valid URL.`);
+    process.exit(1);
+}
+const API_BASE = _rawUrl;
+const _rawKey = process.env.DVB_API_KEY;
+if (!_rawKey) {
+    console.error("ERROR: DVB_API_KEY is required.\n" +
+        "Generate one at https://www.davincibets.io/settings (API tab).\n" +
+        'Set it in your MCP config: "env": { "DVB_API_KEY": "dvb_live_xxx" }');
+    process.exit(1);
+}
+if (!_rawKey.startsWith("dvb_live_")) {
+    console.error('ERROR: DVB_API_KEY must start with "dvb_live_".\n' +
+        "Generate a valid key at https://www.davincibets.io/settings");
+    process.exit(1);
+}
+const API_KEY = _rawKey;
+async function apiFetch(opts) {
+    const url = new URL(opts.path, API_BASE);
+    if (opts.params) {
+        for (const [k, v] of Object.entries(opts.params)) {
+            if (v)
+                url.searchParams.set(k, v);
+        }
+    }
+    let res;
+    try {
+        res = await fetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${API_KEY}`,
+                Accept: opts.raw ? "image/png" : "application/json",
+            },
+            signal: AbortSignal.timeout(opts.raw ? 30_000 : 15_000),
+        });
+    }
+    catch {
+        throw new Error("Unable to reach Da Vinci Bets API. Check your internet connection.");
+    }
+    if (!res.ok) {
+        const status = res.status;
+        if (status === 401)
+            throw new Error("Invalid or expired API key. Regenerate at davincibets.io/settings.");
+        if (status === 429) {
+            const retryAfter = res.headers.get("Retry-After") || "60";
+            const remainHour = res.headers.get("X-RateLimit-Remaining-Hour") || "0";
+            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)
+            throw new Error("Resource not found.");
+        if (status >= 500)
+            throw new Error("Da Vinci Bets API is temporarily unavailable. Try again shortly.");
+        throw new Error(`API request failed (HTTP ${status}).`);
+    }
+    if (opts.raw) {
+        return (await res.arrayBuffer());
+    }
+    return (await res.json());
+}
+// ─── Server Setup ───────────────────────────────────────────────────────────
+const server = new McpServer({
+    name: "Da Vinci Bets",
+    version: "1.0.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.", {
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Filter by sport. Omit for all sports."),
+    market: z
+        .enum(["moneyline", "spread", "totals"])
+        .default("moneyline")
+        .describe("Betting market type."),
+    sort: z
+        .enum(["confidence", "edge", "game_time"])
+        .default("confidence")
+        .describe("Sort order for results."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(25)
+        .describe("Maximum number of predictions to return."),
+    min_confidence: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .default(60)
+        .describe("Minimum confidence percentage (0-100)."),
+}, async ({ sport, market, sort, limit, min_confidence }) => {
+    try {
+        const params = {
+            market,
+            sort,
+            limit: String(limit),
+            min_confidence: String(min_confidence),
+        };
+        if (sport)
+            params.sport = sport;
+        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");
+        return {
+            content: [
+                { type: "text", text: summary },
+                {
+                    type: "text",
+                    text: "\n---\nRaw JSON:\n" + JSON.stringify(data.predictions, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
+// ─── 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.", {
+    count: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .default(10)
+        .describe("Number of top picks to return."),
+    min_confidence: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .default(65)
+        .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",
+            params: {
+                market,
+                sort: "confidence",
+                limit: String(count),
+                min_confidence: String(min_confidence),
+            },
+        })));
+        const allPicks = [];
+        const failedMarkets = [];
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            if (r.status === "fulfilled" && r.value.predictions) {
+                for (const p of r.value.predictions) {
+                    allPicks.push({ ...p, _market: markets[i] });
+                }
+            }
+            else {
+                failedMarkets.push(markets[i]);
+            }
+        }
+        // Sort by confidence descending, take top N
+        allPicks.sort((a, b) => Number(b.confidence || 0) - Number(a.confidence || 0));
+        const topN = allPicks.slice(0, count);
+        if (topN.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No picks found above ${min_confidence}% confidence. Games may not be scheduled today, or try lowering the threshold.`,
+                    },
+                ],
+            };
+        }
+        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;
+        });
+        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.`;
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: header + "\n\n" + lines.join("\n\n"),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
+// ─── Tool: get_pick_card ────────────────────────────────────────────────────
+server.tool("get_pick_card", "Render a prediction as a shareable 1080×1350 PNG image card. " +
+    "Returns the card image directly. Great for social media posts and marketing. " +
+    "Requires a game_id from get_predictions results. " +
+    "Partner-tier keys recommended (higher rate limits for batch image 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."),
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Sport for the game (helps with lookup speed)."),
+}, async ({ game_id, sport }) => {
+    try {
+        const params = {};
+        if (sport)
+            params.sport = sport;
+        const imageBuffer = await apiFetch({
+            path: `/api/card-image/${encodeURIComponent(game_id)}`,
+            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).`,
+                },
+            ],
+        };
+    }
+    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.", {
+    game_ids: z
+        .array(z
+        .string()
+        .regex(/^[a-zA-Z0-9_-]+$/, "game_id must be alphanumeric")
+        .max(100))
+        .min(1)
+        .max(10)
+        .describe("Array of game_ids to render. Max 10 per call."),
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Sport hint for faster lookups."),
+}, async ({ game_ids, sport }) => {
+    try {
+        const params = {};
+        if (sport)
+            params.sport = sport;
+        const results = await Promise.allSettled(game_ids.map(async (gid) => {
+            const buf = await apiFetch({
+                path: `/api/card-image/${encodeURIComponent(gid)}`,
+                params,
+                raw: true,
+            });
+            return { game_id: gid, buffer: buf };
+        }));
+        const content = [];
+        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",
+                });
+                content.push({
+                    type: "text",
+                    text: `Card: ${r.value.game_id} (${Math.round(r.value.buffer.byteLength / 1024)}KB)`,
+                });
+                successCount++;
+            }
+            else {
+                content.push({
+                    type: "text",
+                    text: `Failed: ${r.reason instanceof Error ? r.reason.message : String(r.reason)}`,
+                });
+            }
+        }
+        content.unshift({
+            type: "text",
+            text: `Rendered ${successCount}/${game_ids.length} pick cards.`,
+        });
+        return { content };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
+// ─── 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.", {
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .optional()
+        .describe("Filter performance 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",
+            min_confidence: "50",
+        };
+        if (sport)
+            params.sport = sport;
+        if (market)
+            params.market = market;
+        const data = await apiFetch({
+            path: "/api/v1/predictions",
+            params,
+        });
+        // Summarize available predictions as a performance snapshot
+        const byMarket = {};
+        const bySport = {};
+        const confBuckets = { high: 0, medium: 0 };
+        for (const p of data.predictions) {
+            const m = String(p.market || "moneyline");
+            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)
+                confBuckets.high++;
+            else
+                confBuckets.medium++;
+        }
+        const lines = [
+            "Da Vinci Bets — Current Predictions Snapshot",
+            "═══════════════════════════════════════════════",
+            `Total active predictions: ${data.meta?.total ?? data.predictions.length}`,
+            "",
+            "By Sport:",
+            ...Object.entries(bySport).map(([s, n]) => `  ${s}: ${n} picks`),
+            "",
+            "By Market:",
+            ...Object.entries(byMarket).map(([m, n]) => `  ${m}: ${n} picks`),
+            "",
+            "Confidence Distribution:",
+            `  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.",
+        ];
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    }
+    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.", {
+    sport: z
+        .enum(["NBA", "NFL", "NHL", "MLB"])
+        .describe("Which sport's schedule to retrieve."),
+}, async ({ sport }) => {
+    try {
+        const data = await apiFetch({
+            path: "/api/v1/predictions",
+            params: {
+                sport,
+                market: "moneyline",
+                sort: "game_time",
+                limit: "50",
+                min_confidence: "0",
+            },
+        });
+        const total = data.meta?.total ?? data.predictions.length;
+        if (total === 0) {
+            return {
+                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.`,
+                    },
+                ],
+            };
+        }
+        const lines = [
+            `${sport} Schedule — ${total} games with predictions`,
+            "─".repeat(50),
+            "",
+        ];
+        for (const p of data.predictions) {
+            const time = p.commence_time
+                ? new Date(String(p.commence_time)).toLocaleString("en-US", {
+                    timeZone: "America/New_York",
+                    weekday: "short",
+                    month: "short",
+                    day: "numeric",
+                    hour: "numeric",
+                    minute: "2-digit",
+                    timeZoneName: "short",
+                })
+                : "TBD";
+            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("");
+        }
+        lines.push("Use game_id values with get_pick_card to render shareable images.");
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+        };
+    }
+    catch (err) {
+        return errorResult(err);
+    }
+});
+// ─── Error Helper ───────────────────────────────────────────────────────────
+function errorResult(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}
+// ─── Start Server ───────────────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Da Vinci Bets MCP Server v1.0.0 — connected via stdio");
+    console.error(`API: ${API_BASE}`);
+    console.error(`Key: dvb_live_***`);
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@davincibets/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for Da Vinci Bets — AI sports predictions in your AI assistant",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "davincibets-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "claude",
+    "sports-betting",
+    "predictions",
+    "davincibets"
+  ],
+  "author": "Da Vinci Bets <support@davincibets.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DaVinciii/davincibets-mcp"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.7.0"
+  }
+}