odds-api-mcp-server 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,399 +1,571 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolMap = exports.tools = void 0;
+exports.apiRequest = apiRequest;
+exports.jsonResponse = jsonResponse;
+exports.textResponse = textResponse;
+exports.errorResponse = errorResponse;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+// ── Constants ────────────────────────────────────────────────────────────────
 const API_BASE_URL = "https://api2.odds-api.io/v3";
 const DOCS_BASE_URL = "https://docs.odds-api.io";
-// Get API key from environment
-const API_KEY = process.env.ODDS_API_KEY || "";
-if (!API_KEY) {
-    console.error("Error: ODDS_API_KEY environment variable is required");
-    process.exit(1);
-}
-// Helper function to make API requests
-async function apiRequest(endpoint, params = {}) {
+const API_KEY = process.env.ODDS_API_KEY ?? "";
+// ── API Client ───────────────────────────────────────────────────────────────
+async function apiRequest(endpoint, params = {}, method = "GET") {
+    if (!API_KEY) {
+        throw new Error("ODDS_API_KEY environment variable is not set");
+    }
     const url = new URL(`${API_BASE_URL}${endpoint}`);
     url.searchParams.set("apiKey", API_KEY);
     for (const [key, value] of Object.entries(params)) {
-        if (value) {
-            url.searchParams.set(key, value);
+        if (value !== undefined) {
+            url.searchParams.set(key, String(value));
         }
     }
-    const response = await fetch(url.toString());
+    const response = await fetch(url.toString(), { method });
     if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`API request failed: ${response.status} - ${error}`);
+        const body = await response.text();
+        throw new Error(`API error ${response.status}: ${body}`);
     }
     return response.json();
 }
-// Create the MCP server
-const server = new index_js_1.Server({
-    name: "odds-api-mcp",
-    version: "1.0.0",
-}, {
-    capabilities: {
-        tools: {},
-        resources: {},
+// ── Response Helpers ─────────────────────────────────────────────────────────
+function jsonResponse(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function textResponse(text) {
+    return { content: [{ type: "text", text }] };
+}
+function errorResponse(message) {
+    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+// ── Tool Definitions ─────────────────────────────────────────────────────────
+const tools = [
+    // ── Sports ──────────────────────────────────────────────────────
+    {
+        name: "get_sports",
+        description: "List all available sports with their name and slug identifier.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+        async handler() {
+            return jsonResponse(await apiRequest("/sports"));
+        },
     },
-});
-// Define tools
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-    return {
-        tools: [
-            {
-                name: "get_sports",
-                description: "Get list of all available sports. Returns sport name and slug for each sport.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
+    // ── Bookmakers ──────────────────────────────────────────────────
+    {
+        name: "get_bookmakers",
+        description: "List all supported bookmakers with their name and active status.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+        async handler() {
+            return jsonResponse(await apiRequest("/bookmakers"));
+        },
+    },
+    {
+        name: "get_selected_bookmakers",
+        description: "Get the authenticated user's currently selected bookmakers.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+        async handler() {
+            return jsonResponse(await apiRequest("/bookmakers/selected"));
+        },
+    },
+    {
+        name: "select_bookmakers",
+        description: "Add bookmakers to the authenticated user's selection.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bookmakers: {
+                    type: "string",
+                    description: "Comma-separated bookmaker names (e.g., 'Bet365,SingBet')",
                 },
             },
-            {
-                name: "get_bookmakers",
-                description: "Get list of all available bookmakers. Returns bookmaker name and active status.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
+            required: ["bookmakers"],
+        },
+        async handler(args) {
+            const { bookmakers } = args;
+            return jsonResponse(await apiRequest("/bookmakers/selected/select", { bookmakers }, "PUT"));
+        },
+    },
+    {
+        name: "clear_selected_bookmakers",
+        description: "Clear all selected bookmakers for the authenticated user. Limited to once every 12 hours.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+        async handler() {
+            return jsonResponse(await apiRequest("/bookmakers/selected/clear", {}, "PUT"));
+        },
+    },
+    // ── Leagues ─────────────────────────────────────────────────────
+    {
+        name: "get_leagues",
+        description: "Get leagues for a sport. Returns league name, slug, and active event count.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sport: {
+                    type: "string",
+                    description: "Sport slug (e.g., 'football', 'basketball', 'tennis')",
+                },
+                all: {
+                    type: "boolean",
+                    description: "If true, include leagues without active events",
                 },
             },
-            {
-                name: "get_leagues",
-                description: "Get leagues for a specific sport. Returns league name, slug, and event count.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        sport: {
-                            type: "string",
-                            description: "Sport slug (e.g., 'football', 'basketball', 'tennis')",
-                        },
-                    },
-                    required: ["sport"],
+            required: ["sport"],
+        },
+        async handler(args) {
+            const { sport, all } = args;
+            return jsonResponse(await apiRequest("/leagues", { sport, all: all || undefined }));
+        },
+    },
+    // ── Events ──────────────────────────────────────────────────────
+    {
+        name: "get_events",
+        description: "Get events for a sport with filtering by league, participant, status, date range, bookmaker availability, and pagination support.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sport: {
+                    type: "string",
+                    description: "Sport slug (e.g., 'football', 'basketball')",
+                },
+                league: {
+                    type: "string",
+                    description: "League slug (e.g., 'england-premier-league')",
+                },
+                participantId: {
+                    type: "number",
+                    description: "Filter by participant/team ID (matches home or away)",
+                },
+                status: {
+                    type: "string",
+                    description: "Comma-separated event statuses: pending, live, settled",
+                },
+                from: {
+                    type: "string",
+                    description: "Start date/time in RFC3339 format (e.g., '2025-10-28T10:00:00Z')",
+                },
+                to: {
+                    type: "string",
+                    description: "End date/time in RFC3339 format (e.g., '2025-10-28T23:59:59Z')",
+                },
+                bookmaker: {
+                    type: "string",
+                    description: "Only return events with odds from this bookmaker (e.g., 'Bet365')",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of events to return",
+                },
+                skip: {
+                    type: "number",
+                    description: "Number of events to skip for pagination",
                 },
             },
-            {
-                name: "get_events",
-                description: "Get events for a sport, optionally filtered by league, status, or date range.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        sport: {
-                            type: "string",
-                            description: "Sport slug (e.g., 'football', 'basketball')",
-                        },
-                        league: {
-                            type: "string",
-                            description: "Optional league slug (e.g., 'england-premier-league')",
-                        },
-                        status: {
-                            type: "string",
-                            description: "Optional comma-separated statuses (pending, live, settled)",
-                        },
-                    },
-                    required: ["sport"],
+            required: ["sport"],
+        },
+        async handler(args) {
+            const { sport, league, participantId, status, from, to, bookmaker, limit, skip } = args;
+            return jsonResponse(await apiRequest("/events", {
+                sport,
+                league,
+                participantId,
+                status,
+                from,
+                to,
+                bookmaker,
+                limit,
+                skip,
+            }));
+        },
+    },
+    {
+        name: "get_event",
+        description: "Get a single event by its unique ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "Event ID" },
+            },
+            required: ["id"],
+        },
+        async handler(args) {
+            const { id } = args;
+            return jsonResponse(await apiRequest(`/events/${id}`));
+        },
+    },
+    {
+        name: "get_live_events",
+        description: "Get all currently live events across all sports, optionally filtered by sport.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sport: {
+                    type: "string",
+                    description: "Sport slug to filter live events (e.g., 'football')",
                 },
             },
-            {
-                name: "get_live_events",
-                description: "Get all currently live events, optionally filtered by sport.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        sport: {
-                            type: "string",
-                            description: "Optional sport slug to filter live events",
-                        },
-                    },
-                    required: [],
+            required: [],
+        },
+        async handler(args) {
+            const { sport } = args;
+            return jsonResponse(await apiRequest("/events/live", { sport }));
+        },
+    },
+    {
+        name: "search_events",
+        description: "Search events by team name or text query. Returns up to 10 matching results.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search term (minimum 3 characters)",
                 },
             },
-            {
-                name: "search_events",
-                description: "Search events by team name or other text. Returns up to 10 matching events.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Search term (minimum 3 characters)",
-                        },
-                    },
-                    required: ["query"],
+            required: ["query"],
+        },
+        async handler(args) {
+            const { query } = args;
+            return jsonResponse(await apiRequest("/events/search", { query }));
+        },
+    },
+    // ── Odds ────────────────────────────────────────────────────────
+    {
+        name: "get_odds",
+        description: "Get betting odds for a specific event from selected bookmakers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                eventId: { type: "string", description: "Event ID" },
+                bookmakers: {
+                    type: "string",
+                    description: "Comma-separated bookmaker names, max 30 (e.g., 'Bet365,Pinnacle,Unibet')",
                 },
             },
-            {
-                name: "get_odds",
-                description: "Get betting odds for a specific event from selected bookmakers.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        eventId: {
-                            type: "string",
-                            description: "Event ID",
-                        },
-                        bookmakers: {
-                            type: "string",
-                            description: "Comma-separated list of bookmaker names (e.g., 'Bet365,Pinnacle,Unibet')",
-                        },
-                    },
-                    required: ["eventId", "bookmakers"],
+            required: ["eventId", "bookmakers"],
+        },
+        async handler(args) {
+            const { eventId, bookmakers } = args;
+            return jsonResponse(await apiRequest("/odds", { eventId, bookmakers }));
+        },
+    },
+    {
+        name: "get_multi_odds",
+        description: "Get odds for multiple events in a single request (up to 10 events). Counts as only 1 API call.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                eventIds: {
+                    type: "string",
+                    description: "Comma-separated event IDs (max 10)",
+                },
+                bookmakers: {
+                    type: "string",
+                    description: "Comma-separated bookmaker names (max 30)",
                 },
             },
-            {
-                name: "get_multi_odds",
-                description: "Get odds for multiple events in a single request (up to 10 events). Counts as 1 API call.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        eventIds: {
-                            type: "string",
-                            description: "Comma-separated list of event IDs (max 10)",
-                        },
-                        bookmakers: {
-                            type: "string",
-                            description: "Comma-separated list of bookmaker names",
-                        },
-                    },
-                    required: ["eventIds", "bookmakers"],
+            required: ["eventIds", "bookmakers"],
+        },
+        async handler(args) {
+            const { eventIds, bookmakers } = args;
+            return jsonResponse(await apiRequest("/odds/multi", { eventIds, bookmakers }));
+        },
+    },
+    {
+        name: "get_odds_movements",
+        description: "Get historical odds line movements for an event from a bookmaker. Returns opening, latest, and all intermediate price changes for a specific market.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                eventId: { type: "string", description: "Event ID" },
+                bookmaker: {
+                    type: "string",
+                    description: "Bookmaker name (e.g., 'Bet365')",
+                },
+                market: {
+                    type: "string",
+                    description: "Market type (e.g., 'ML', 'Spread', 'Totals')",
+                },
+                marketLine: {
+                    type: "string",
+                    description: "Handicap/total line (e.g., '0.5', '2.5'). Not required for ML markets.",
                 },
             },
-            {
-                name: "get_value_bets",
-                description: "Get value betting opportunities for a specific bookmaker. Returns bets where expected value is positive.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        bookmaker: {
-                            type: "string",
-                            description: "Bookmaker name (e.g., 'Bet365')",
-                        },
-                        includeEventDetails: {
-                            type: "boolean",
-                            description: "Include full event details in response",
-                        },
-                    },
-                    required: ["bookmaker"],
+            required: ["eventId", "bookmaker", "market"],
+        },
+        async handler(args) {
+            const { eventId, bookmaker, market, marketLine } = args;
+            return jsonResponse(await apiRequest("/odds/movements", { eventId, bookmaker, market, marketLine }));
+        },
+    },
+    {
+        name: "get_updated_odds",
+        description: "Get odds updated since a Unix timestamp for a bookmaker and sport. The timestamp must be at most 1 minute old. Useful for efficient polling.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                since: {
+                    type: "number",
+                    description: "Unix timestamp (must be within the last 60 seconds)",
+                },
+                bookmaker: {
+                    type: "string",
+                    description: "Bookmaker name (e.g., 'Bet365')",
+                },
+                sport: {
+                    type: "string",
+                    description: "Sport slug (e.g., 'football')",
                 },
             },
-            {
-                name: "get_arbitrage_bets",
-                description: "Get arbitrage betting opportunities across specified bookmakers.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        bookmakers: {
-                            type: "string",
-                            description: "Comma-separated list of bookmaker names",
-                        },
-                        limit: {
-                            type: "number",
-                            description: "Maximum number of results (default 50, max 500)",
-                        },
-                        includeEventDetails: {
-                            type: "boolean",
-                            description: "Include full event details in response",
-                        },
-                    },
-                    required: ["bookmakers"],
+            required: ["since", "bookmaker", "sport"],
+        },
+        async handler(args) {
+            const { since, bookmaker, sport } = args;
+            return jsonResponse(await apiRequest("/odds/updated", { since, bookmaker, sport }));
+        },
+    },
+    // ── Historical ──────────────────────────────────────────────────
+    {
+        name: "get_historical_events",
+        description: "Get finished events for a sport and league within a date range (max 31-day span).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sport: {
+                    type: "string",
+                    description: "Sport slug (e.g., 'football')",
+                },
+                league: {
+                    type: "string",
+                    description: "League slug (e.g., 'england-premier-league')",
+                },
+                from: {
+                    type: "string",
+                    description: "Start date in RFC3339 format (e.g., '2026-01-01T00:00:00Z')",
+                },
+                to: {
+                    type: "string",
+                    description: "End date in RFC3339 format (e.g., '2026-01-31T23:59:59Z')",
                 },
             },
-            {
-                name: "get_participants",
-                description: "Get teams/participants for a sport, optionally filtered by search term.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        sport: {
-                            type: "string",
-                            description: "Sport slug (e.g., 'football')",
-                        },
-                        search: {
-                            type: "string",
-                            description: "Optional search term to filter by name",
-                        },
-                    },
-                    required: ["sport"],
+            required: ["sport", "league", "from", "to"],
+        },
+        async handler(args) {
+            const { sport, league, from, to } = args;
+            return jsonResponse(await apiRequest("/historical/events", { sport, league, from, to }));
+        },
+    },
+    {
+        name: "get_historical_odds",
+        description: "Get closing odds and final scores for a finished event from selected bookmakers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                eventId: {
+                    type: "string",
+                    description: "Event ID (from get_historical_events)",
+                },
+                bookmakers: {
+                    type: "string",
+                    description: "Comma-separated bookmaker names (max 30)",
                 },
             },
-            {
-                name: "get_documentation",
-                description: "Get Odds-API.io documentation. Returns the full documentation text.",
-                inputSchema: {
-                    type: "object",
-                    properties: {},
-                    required: [],
+            required: ["eventId", "bookmakers"],
+        },
+        async handler(args) {
+            const { eventId, bookmakers } = args;
+            return jsonResponse(await apiRequest("/historical/odds", { eventId, bookmakers }));
+        },
+    },
+    // ── Value Bets ──────────────────────────────────────────────────
+    {
+        name: "get_value_bets",
+        description: "Get positive expected value betting opportunities for a bookmaker. Updated every 5 seconds. EV formula: (Probability x Odds) - 1.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bookmaker: {
+                    type: "string",
+                    description: "Bookmaker name (e.g., 'Bet365')",
+                },
+                includeEventDetails: {
+                    type: "boolean",
+                    description: "Include full event details (sport, league, teams, date) in response",
                 },
             },
-        ],
-    };
-});
-// Handle tool calls
+            required: ["bookmaker"],
+        },
+        async handler(args) {
+            const { bookmaker, includeEventDetails } = args;
+            return jsonResponse(await apiRequest("/value-bets", {
+                bookmaker,
+                includeEventDetails: includeEventDetails || undefined,
+            }));
+        },
+    },
+    // ── Arbitrage Bets ──────────────────────────────────────────────
+    {
+        name: "get_arbitrage_bets",
+        description: "Get arbitrage opportunities across bookmakers. Returns profit margin, optimal stake distribution, and direct bet links for each leg.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bookmakers: {
+                    type: "string",
+                    description: "Comma-separated bookmaker names (e.g., 'Bet365,SingBet')",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum results (default 50, max 500)",
+                },
+                includeEventDetails: {
+                    type: "boolean",
+                    description: "Include full event details in response",
+                },
+            },
+            required: ["bookmakers"],
+        },
+        async handler(args) {
+            const { bookmakers, limit, includeEventDetails } = args;
+            return jsonResponse(await apiRequest("/arbitrage-bets", {
+                bookmakers,
+                limit,
+                includeEventDetails: includeEventDetails || undefined,
+            }));
+        },
+    },
+    // ── Participants ────────────────────────────────────────────────
+    {
+        name: "get_participants",
+        description: "Get teams/participants for a sport, optionally filtered by name search.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sport: {
+                    type: "string",
+                    description: "Sport slug (e.g., 'football')",
+                },
+                search: {
+                    type: "string",
+                    description: "Search term to filter by team/participant name",
+                },
+            },
+            required: ["sport"],
+        },
+        async handler(args) {
+            const { sport, search } = args;
+            return jsonResponse(await apiRequest("/participants", { sport, search }));
+        },
+    },
+    {
+        name: "get_participant",
+        description: "Get a single participant/team by their unique ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "Participant ID" },
+            },
+            required: ["id"],
+        },
+        async handler(args) {
+            const { id } = args;
+            return jsonResponse(await apiRequest(`/participants/${id}`));
+        },
+    },
+    // ── Documentation ───────────────────────────────────────────────
+    {
+        name: "get_documentation",
+        description: "Fetch the complete Odds-API.io API documentation.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+        async handler() {
+            const response = await fetch(`${DOCS_BASE_URL}/llms-full.txt`);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch documentation: ${response.status}`);
+            }
+            return textResponse(await response.text());
+        },
+    },
+];
+exports.tools = tools;
+// ── Server Setup ─────────────────────────────────────────────────────────────
+const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
+exports.toolMap = toolMap;
+const server = new index_js_1.Server({ name: "odds-api-mcp", version: "1.1.0" }, { capabilities: { tools: {}, resources: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: tools.map(({ name, description, inputSchema }) => ({
+        name,
+        description,
+        inputSchema,
+    })),
+}));
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    const tool = toolMap.get(name);
+    if (!tool) {
+        return errorResponse(`Unknown tool: ${name}`);
+    }
     try {
-        switch (name) {
-            case "get_sports": {
-                const data = await apiRequest("/sports");
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_bookmakers": {
-                const data = await apiRequest("/bookmakers");
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_leagues": {
-                const params = args;
-                const data = await apiRequest("/leagues", { sport: params.sport });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_events": {
-                const params = args;
-                const data = await apiRequest("/events", {
-                    sport: params.sport,
-                    league: params.league || "",
-                    status: params.status || "",
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_live_events": {
-                const params = args;
-                const data = await apiRequest("/events/live", {
-                    sport: params.sport || "",
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "search_events": {
-                const params = args;
-                const data = await apiRequest("/events/search", { query: params.query });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_odds": {
-                const params = args;
-                const data = await apiRequest("/odds", {
-                    eventId: params.eventId,
-                    bookmakers: params.bookmakers,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_multi_odds": {
-                const params = args;
-                const data = await apiRequest("/odds/multi", {
-                    eventIds: params.eventIds,
-                    bookmakers: params.bookmakers,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_value_bets": {
-                const params = args;
-                const data = await apiRequest("/value-bets", {
-                    bookmaker: params.bookmaker,
-                    includeEventDetails: params.includeEventDetails ? "true" : "false",
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_arbitrage_bets": {
-                const params = args;
-                const data = await apiRequest("/arbitrage-bets", {
-                    bookmakers: params.bookmakers,
-                    limit: params.limit?.toString() || "",
-                    includeEventDetails: params.includeEventDetails ? "true" : "false",
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_participants": {
-                const params = args;
-                const data = await apiRequest("/participants", {
-                    sport: params.sport,
-                    search: params.search || "",
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-                };
-            }
-            case "get_documentation": {
-                const response = await fetch(`${DOCS_BASE_URL}/llms-full.txt`);
-                const text = await response.text();
-                return {
-                    content: [{ type: "text", text }],
-                };
-            }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
-        }
+        return await tool.handler(args ?? {});
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
+        const message = error instanceof Error ? error.message : String(error);
+        return errorResponse(message);
     }
 });
-// Define resources
-server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
-    return {
-        resources: [
-            {
-                uri: "odds-api://documentation",
-                name: "Odds-API.io Documentation",
-                description: "Complete API documentation for Odds-API.io",
-                mimeType: "text/plain",
-            },
-            {
-                uri: "odds-api://openapi",
-                name: "OpenAPI Specification",
-                description: "OpenAPI/Swagger specification for Odds-API.io",
-                mimeType: "application/json",
-            },
-        ],
-    };
-});
-// Handle resource reads
+// ── Resources ────────────────────────────────────────────────────────────────
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => ({
+    resources: [
+        {
+            uri: "odds-api://documentation",
+            name: "Odds-API.io Documentation",
+            description: "Complete API documentation for Odds-API.io",
+            mimeType: "text/plain",
+        },
+        {
+            uri: "odds-api://openapi",
+            name: "OpenAPI Specification",
+            description: "OpenAPI/Swagger specification for Odds-API.io",
+            mimeType: "application/json",
+        },
+    ],
+}));
 server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
     const { uri } = request.params;
     switch (uri) {
         case "odds-api://documentation": {
             const response = await fetch(`${DOCS_BASE_URL}/llms-full.txt`);
-            const text = await response.text();
+            if (!response.ok)
+                throw new Error(`Failed to fetch docs: ${response.status}`);
             return {
-                contents: [{ uri, mimeType: "text/plain", text }],
+                contents: [{ uri, mimeType: "text/plain", text: await response.text() }],
             };
         }
         case "odds-api://openapi": {
             const response = await fetch(`${DOCS_BASE_URL}/api-reference/openapi.json`);
-            const json = await response.json();
+            if (!response.ok)
+                throw new Error(`Failed to fetch OpenAPI spec: ${response.status}`);
             return {
-                contents: [{ uri, mimeType: "application/json", text: JSON.stringify(json, null, 2) }],
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify(await response.json(), null, 2),
+                    },
+                ],
             };
         }
         default:
             throw new Error(`Unknown resource: ${uri}`);
     }
 });
-// Start the server
+// ── Bootstrap ────────────────────────────────────────────────────────────────
 async function main() {
+    if (!API_KEY) {
+        console.error("Error: ODDS_API_KEY environment variable is required");
+        process.exit(1);
+    }
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
     console.error("Odds-API.io MCP Server running on stdio");