@gotza02/sequential-thinking 10000.0.8 → 10000.1.0

package/dist/tools/sports/core/cache.js

@@ -1,24 +1,26 @@
 /**
- * SPORTS MODULE CACHE SERVICE
- * TTL-based caching with file persistence for the football intelligence system
+ * ENHANCED CACHE SERVICE
+ * TTL-based caching with stale-while-revalidate pattern
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { CACHE_CONFIG } from './constants.js';
 import { logger, createSafeRegex } from '../../../utils.js';
 /**
- * CacheService - Thread-safe TTL-based caching with persistence
+ * CacheService - Thread-safe TTL-based caching with stale-while-revalidate
  */
 export class CacheService {
     cache = new Map();
     cachePath;
     maxAge;
+    staleAge;
     maxSize;
     savePending = false;
     saveTimer = null;
-    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE) {
+    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE, staleAge) {
         this.cachePath = path.resolve(cachePath);
         this.maxAge = maxAge;
+        this.staleAge = staleAge || maxAge * 2;
         this.maxSize = maxSize;
         this.loadFromFile();
     }
@@ -36,11 +38,12 @@ export class CacheService {
         if (!entry) {
             return null;
         }
-        // Check if expired
+        // Check if expired (including stale period)
         const now = Date.now();
-        if (now - entry.timestamp > entry.ttl) {
+        const totalTtl = entry.ttl + entry.staleTtl;
+        if (now - entry.timestamp > totalTtl) {
             this.cache.delete(key);
-            logger.debug(`Cache expired: ${key}`);
+            logger.debug(`Cache expired (including stale): ${key}`);
             return null;
         }
         // Increment hit counter
@@ -51,7 +54,7 @@ export class CacheService {
     /**
      * Set a value in cache
      */
-    set(key, data, ttl) {
+    set(key, data, ttl, staleTtl) {
         const now = Date.now();
         // Check if we need to evict old entries
         if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
@@ -62,11 +65,64 @@ export class CacheService {
             data,
             timestamp: now,
             ttl: ttl || this.maxAge,
+            staleTtl: staleTtl || this.staleAge,
             hits: 0,
         });
-        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}ms)`);
+        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}ms, Stale: ${staleTtl || this.staleAge}ms)`);
         this.scheduleSave();
     }
+    /**
+     * Get or set with stale-while-revalidate pattern
+     * Returns cached value immediately, refreshes in background if stale
+     */
+    async getOrSetWithStaleRevalidate(key, factory, ttl, staleTtl) {
+        const entry = this.cache.get(key);
+        const now = Date.now();
+        const effectiveTtl = ttl || this.maxAge;
+        const effectiveStaleTtl = staleTtl || this.staleAge;
+        if (entry) {
+            const age = now - entry.timestamp;
+            // Data is fresh - use it
+            if (age < effectiveTtl) {
+                entry.hits++;
+                return entry.data;
+            }
+            // Data is stale but within stale TTL - use it and refresh in background
+            if (age < effectiveTtl + effectiveStaleTtl) {
+                entry.hits++;
+                if (!entry.isRefreshing) {
+                    this.refreshInBackground(key, factory, effectiveTtl, effectiveStaleTtl);
+                }
+                return entry.data;
+            }
+        }
+        // No data or expired beyond stale TTL - fetch new data
+        const value = await factory();
+        this.set(key, value, effectiveTtl, effectiveStaleTtl);
+        return value;
+    }
+    /**
+     * Refresh data in background
+     */
+    async refreshInBackground(key, factory, ttl, staleTtl) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            entry.isRefreshing = true;
+        }
+        try {
+            const value = await factory();
+            this.set(key, value, ttl, staleTtl);
+            logger.debug(`Background refresh successful: ${key}`);
+        }
+        catch (error) {
+            logger.error(`Background refresh failed for ${key}: ${error}`);
+        }
+        finally {
+            if (entry) {
+                entry.isRefreshing = false;
+            }
+        }
+    }
     /**
      * Check if a key exists and is not expired
      */
@@ -75,7 +131,8 @@ export class CacheService {
         if (!entry)
             return false;
         const now = Date.now();
-        if (now - entry.timestamp > entry.ttl) {
+        const totalTtl = entry.ttl + entry.staleTtl;
+        if (now - entry.timestamp > totalTtl) {
             this.cache.delete(key);
             return false;
         }
@@ -100,12 +157,16 @@ export class CacheService {
      */
     getStats() {
         const now = Date.now();
-        const entries = Array.from(this.cache.values()).map(entry => ({
-            key: entry.key,
-            hits: entry.hits,
-            age: now - entry.timestamp,
-            ttl: entry.ttl,
-        }));
+        const entries = Array.from(this.cache.values()).map(entry => {
+            const age = now - entry.timestamp;
+            return {
+                key: entry.key,
+                hits: entry.hits,
+                age,
+                ttl: entry.ttl,
+                isStale: age > entry.ttl,
+            };
+        });
         return {
             size: this.cache.size,
             maxSize: this.maxSize,
@@ -120,7 +181,8 @@ export class CacheService {
         const now = Date.now();
         let removed = 0;
         for (const [key, entry] of this.cache.entries()) {
-            if (now - entry.timestamp > entry.ttl) {
+            const totalTtl = entry.ttl + entry.staleTtl;
+            if (now - entry.timestamp > totalTtl) {
                 this.cache.delete(key);
                 removed++;
             }
@@ -132,20 +194,22 @@ export class CacheService {
         return removed;
     }
     /**
-     * Evict the oldest entry (LRU)
+     * Evict the oldest entry (LRU with hit weighting)
      */
     evictOldest() {
         let oldestKey = null;
-        let oldestTime = Infinity;
+        let lowestScore = Infinity;
+        // Evict based on age weighted by hits
         for (const [key, entry] of this.cache.entries()) {
-            if (entry.timestamp < oldestTime) {
-                oldestTime = entry.timestamp;
+            const score = (Date.now() - entry.timestamp) / (entry.hits + 1);
+            if (score < lowestScore) {
+                lowestScore = score;
                 oldestKey = key;
             }
         }
         if (oldestKey) {
             this.cache.delete(oldestKey);
-            logger.debug(`Evicted oldest cache entry: ${oldestKey}`);
+            logger.debug(`Evicted LRU entry: ${oldestKey}`);
         }
     }
     /**
@@ -158,7 +222,7 @@ export class CacheService {
         this.saveTimer = setTimeout(() => {
             this.saveToFile();
             this.saveTimer = null;
-        }, 1000); // Save after 1 second of inactivity
+        }, 1000);
     }
     /**
      * Save cache to file
@@ -192,7 +256,8 @@ export class CacheService {
             const now = Date.now();
             let restored = 0;
             for (const [key, entry] of entries) {
-                if (now - entry.timestamp < entry.ttl) {
+                const totalTtl = entry.ttl + entry.staleTtl;
+                if (now - entry.timestamp < totalTtl) {
                     this.cache.set(key, entry);
                     restored++;
                 }
@@ -200,7 +265,6 @@ export class CacheService {
             logger.info(`Cache loaded: ${restored}/${entries.length} entries restored`);
         }
         catch (error) {
-            // File doesn't exist or is invalid - start fresh
             logger.debug('No existing cache file found, starting fresh');
         }
     }
@@ -217,14 +281,8 @@ export class CacheService {
     /**
      * Get or set pattern - returns cached value or computes and caches it
      */
-    async getOrSet(key, factory, ttl) {
-        const cached = this.get(key);
-        if (cached !== null) {
-            return cached;
-        }
-        const value = await factory();
-        this.set(key, value, ttl);
-        return value;
+    async getOrSet(key, factory, ttl, staleTtl) {
+        return this.getOrSetWithStaleRevalidate(key, factory, ttl, staleTtl);
     }
     /**
      * Get multiple keys at once
@@ -242,16 +300,15 @@ export class CacheService {
     /**
      * Set multiple keys at once
      */
-    setMultiple(entries, ttl) {
+    setMultiple(entries, ttl, staleTtl) {
         for (const [key, value] of entries.entries()) {
-            this.set(key, value, ttl);
+            this.set(key, value, ttl, staleTtl);
         }
     }
     /**
      * Invalidate cache by pattern
      */
     invalidatePattern(pattern) {
-        // Use safe regex creation to prevent ReDoS attacks
         const regex = createSafeRegex(pattern);
         let removed = 0;
         for (const key of this.cache.keys()) {
@@ -288,10 +345,10 @@ let globalCache = null;
 export function getGlobalCache() {
     if (!globalCache) {
         globalCache = new CacheService();
-        // Cleanup expired entries every 5 minutes
+        // Cleanup expired entries every 2 minutes
         setInterval(() => {
             globalCache?.cleanup();
-        }, 5 * 60 * 1000);
+        }, 2 * 60 * 1000);
     }
     return globalCache;
 }

package/dist/tools/sports/core/circuit-breaker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * CIRCUIT BREAKER PATTERN
+ * Prevents cascading failures by stopping requests to failing services
+ */
+export declare class CircuitBreaker {
+    private readonly name;
+    private readonly failureThreshold;
+    private readonly resetTimeout;
+    private readonly halfOpenMaxCalls;
+    private failures;
+    private lastFailureTime;
+    private state;
+    private successCount;
+    constructor(name: string, failureThreshold?: number, resetTimeout?: number, halfOpenMaxCalls?: number);
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    execute<T>(fn: () => Promise<T>, context?: string): Promise<T>;
+    private onSuccess;
+    private onFailure;
+    getStatus(): {
+        name: string;
+        state: "closed" | "open" | "half-open";
+        failures: number;
+        lastFailure: number | null;
+    };
+}
+export declare class CircuitBreakerOpenError extends Error {
+    readonly retryAfter: number;
+    constructor(message: string, retryAfter: number);
+}
+export declare function getCircuitBreaker(name: string, config?: {
+    failureThreshold?: number;
+    resetTimeout?: number;
+}): CircuitBreaker;
+export declare function getAllCircuitBreakerStatus(): Array<{
+    name: string;
+    state: string;
+    failures: number;
+}>;

package/dist/tools/sports/core/circuit-breaker.js

@@ -0,0 +1,99 @@
+/**
+ * CIRCUIT BREAKER PATTERN
+ * Prevents cascading failures by stopping requests to failing services
+ */
+import { logger } from '../../../utils.js';
+export class CircuitBreaker {
+    name;
+    failureThreshold;
+    resetTimeout;
+    halfOpenMaxCalls;
+    failures = 0;
+    lastFailureTime = null;
+    state = 'closed';
+    successCount = 0;
+    constructor(name, failureThreshold = 5, resetTimeout = 60000, halfOpenMaxCalls = 3) {
+        this.name = name;
+        this.failureThreshold = failureThreshold;
+        this.resetTimeout = resetTimeout;
+        this.halfOpenMaxCalls = halfOpenMaxCalls;
+    }
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    async execute(fn, context) {
+        if (this.state === 'open') {
+            const timeSinceLastFailure = Date.now() - (this.lastFailureTime || 0);
+            if (timeSinceLastFailure > this.resetTimeout) {
+                logger.info(`[CircuitBreaker:${this.name}] Transitioning to HALF-OPEN`);
+                this.state = 'half-open';
+                this.successCount = 0;
+            }
+            else {
+                const remainingTime = Math.ceil((this.resetTimeout - timeSinceLastFailure) / 1000);
+                throw new CircuitBreakerOpenError(`Circuit breaker '${this.name}' is OPEN. Retry in ${remainingTime}s`, remainingTime);
+            }
+        }
+        try {
+            const result = await fn();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    onSuccess() {
+        if (this.state === 'half-open') {
+            this.successCount++;
+            if (this.successCount >= this.halfOpenMaxCalls) {
+                logger.info(`[CircuitBreaker:${this.name}] Transitioning to CLOSED`);
+                this.state = 'closed';
+                this.failures = 0;
+                this.successCount = 0;
+            }
+        }
+        else {
+            this.failures = Math.max(0, this.failures - 1);
+        }
+    }
+    onFailure(error) {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        logger.warn(`[CircuitBreaker:${this.name}] Failure ${this.failures}/${this.failureThreshold}: ${error.message}`);
+        if (this.failures >= this.failureThreshold) {
+            logger.error(`[CircuitBreaker:${this.name}] Threshold reached. Transitioning to OPEN`);
+            this.state = 'open';
+        }
+    }
+    getStatus() {
+        return {
+            name: this.name,
+            state: this.state,
+            failures: this.failures,
+            lastFailure: this.lastFailureTime,
+        };
+    }
+}
+export class CircuitBreakerOpenError extends Error {
+    retryAfter;
+    constructor(message, retryAfter) {
+        super(message);
+        this.retryAfter = retryAfter;
+        this.name = 'CircuitBreakerOpenError';
+    }
+}
+// Global circuit breakers registry
+const circuitBreakers = new Map();
+export function getCircuitBreaker(name, config) {
+    if (!circuitBreakers.has(name)) {
+        circuitBreakers.set(name, new CircuitBreaker(name, config?.failureThreshold, config?.resetTimeout));
+    }
+    return circuitBreakers.get(name);
+}
+export function getAllCircuitBreakerStatus() {
+    return Array.from(circuitBreakers.values()).map(cb => ({
+        ...cb.getStatus()
+    }));
+}

package/dist/tools/sports/core/constants.d.ts

@@ -10,25 +10,40 @@ export declare const API_CONFIG: {
     readonly FOOTBALL_DATA_BASE: "https://api.football-data.org/v4";
     readonly SPORTS_DB_KEY: string;
     readonly SPORTS_DB_BASE: "https://www.thesportsdb.com/api/v1/json";
+    readonly ODDS_API_KEY: string;
+    readonly ODDS_API_BASE: "https://api.the-odds-api.com/v4";
+    readonly SPORTRADAR_KEY: string;
+    readonly SPORTRADAR_BASE: "https://api.sportradar.us/soccer/trial/v4";
     readonly RATE_LIMITS: {
         readonly API_FOOTBALL: 10;
         readonly FOOTBALL_DATA: 10;
         readonly SPORTS_DB: 30;
+        readonly ODDS_API: 20;
+        readonly SPORTRADAR: 100;
     };
 };
 export declare const CACHE_CONFIG: {
     readonly DEFAULT_TTL: number;
     readonly TTL: {
         readonly LIVE_SCORES: number;
+        readonly LIVE_EVENTS: number;
+        readonly ODDS: number;
         readonly MATCH_DETAILS: number;
         readonly STANDINGS: number;
         readonly TEAM_STATS: number;
         readonly PLAYER_STATS: number;
-        readonly ODDS: number;
         readonly TRANSFER_NEWS: number;
+        readonly PREDICTIONS: number;
+    };
+    readonly STALE_MULTIPLIERS: {
+        readonly LIVE_SCORES: 2;
+        readonly ODDS: 2;
+        readonly MATCH_DETAILS: 2;
+        readonly STANDINGS: 1.5;
+        readonly TEAM_STATS: 1.5;
     };
     readonly CACHE_PATH: string;
-    readonly MAX_SIZE: 1000;
+    readonly MAX_SIZE: 2000;
 };
 export declare const SCRAPER_CONFIG: {
     readonly PRIORITY_DOMAINS: readonly ["understat.com", "bbc.co.uk/sport", "sportsmole.co.uk", "skysports.com", "goal.com", "thesquareball.net", "fbref.com", "whoscored.com", "sofascore.com", "flashscore.com"];
@@ -172,9 +187,53 @@ export declare const ERRORS: {
     readonly TIMEOUT: "Request timed out.";
     readonly INVALID_RESPONSE: "Invalid response from API.";
     readonly ALL_PROVIDERS_FAILED: "All data providers failed.";
+    readonly CIRCUIT_BREAKER_OPEN: "Service temporarily unavailable due to repeated failures.";
+};
+export declare const ALERT_CONFIG: {
+    readonly CHECK_INTERVAL: 10000;
+    readonly DEFAULT_COOLDOWN: 300000;
+    readonly MAX_ALERTS_PER_HOUR: 10;
+    readonly TYPES: {
+        readonly ODDS_DROP: "odds_drop";
+        readonly ODDS_VALUE: "odds_value";
+        readonly GOAL: "goal";
+        readonly RED_CARD: "red_card";
+        readonly LINEUP_CHANGE: "lineup_change";
+        readonly MATCH_START: "match_start";
+        readonly MATCH_END: "match_end";
+        readonly CUSTOM: "custom";
+    };
+};
+export declare const REALTIME_CONFIG: {
+    readonly WS_RECONNECT_INTERVAL: 5000;
+    readonly WS_MAX_RECONNECT_ATTEMPTS: 10;
+    readonly POLLING_INTERVALS: {
+        readonly LIVE_SCORES: 15000;
+        readonly ODDS: 30000;
+        readonly MATCH_EVENTS: 5000;
+    };
+    readonly EVENT_BATCH_SIZE: 10;
+    readonly EVENT_BATCH_TIMEOUT: 1000;
+};
+export declare const ML_CONFIG: {
+    readonly MIN_TRAINING_MATCHES: 50;
+    readonly FEATURE_WEIGHTS: {
+        readonly form: 0.25;
+        readonly h2h: 0.2;
+        readonly home_advantage: 0.15;
+        readonly xg: 0.15;
+        readonly injuries: 0.1;
+        readonly fatigue: 0.1;
+        readonly weather: 0.05;
+    };
+    readonly CONFIDENCE_THRESHOLDS: {
+        readonly high: 0.7;
+        readonly medium: 0.55;
+        readonly low: 0.4;
+    };
 };
 export declare const MODULE_INFO: {
     readonly NAME: "sports-module";
-    readonly VERSION: "2.0.0";
-    readonly DESCRIPTION: "Football Intelligence System for MCP Server";
+    readonly VERSION: "3.0.0";
+    readonly DESCRIPTION: "Football Intelligence System for MCP Server - Realtime Edition";
 };

package/dist/tools/sports/core/constants.js

@@ -14,31 +14,49 @@ export const API_CONFIG = {
     // TheSportsDB
     SPORTS_DB_KEY: process.env.SPORTS_DB_KEY || '',
     SPORTS_DB_BASE: 'https://www.thesportsdb.com/api/v1/json',
+    // Odds API
+    ODDS_API_KEY: process.env.ODDS_API_KEY || '',
+    ODDS_API_BASE: 'https://api.the-odds-api.com/v4',
+    // SportRadar (requires enterprise license)
+    SPORTRADAR_KEY: process.env.SPORTRADAR_KEY || '',
+    SPORTRADAR_BASE: 'https://api.sportradar.us/soccer/trial/v4',
     // Rate limits (requests per minute)
     RATE_LIMITS: {
         API_FOOTBALL: 10,
         FOOTBALL_DATA: 10,
         SPORTS_DB: 30,
+        ODDS_API: 20,
+        SPORTRADAR: 100,
     }
 };
 // ============= Cache Configuration =============
 export const CACHE_CONFIG = {
     // Default TTL in milliseconds
     DEFAULT_TTL: parseInt(process.env.SPORTS_CACHE_TTL || '300000'), // 5 minutes
-    // Specific TTLs for different data types
+    // Specific TTLs for different data types (OPTIMIZED FOR REALTIME)
     TTL: {
-        LIVE_SCORES: 60 * 1000, // 1 minute
-        MATCH_DETAILS: 5 * 60 * 1000, // 5 minutes
-        STANDINGS: 30 * 60 * 1000, // 30 minutes
-        TEAM_STATS: 60 * 60 * 1000, // 1 hour
-        PLAYER_STATS: 60 * 60 * 1000, // 1 hour
-        ODDS: 2 * 60 * 1000, // 2 minutes
-        TRANSFER_NEWS: 15 * 60 * 1000, // 15 minutes
+        LIVE_SCORES: 15 * 1000, // 15 seconds (was 1 minute)
+        LIVE_EVENTS: 5 * 1000, // 5 seconds for live match events
+        ODDS: 30 * 1000, // 30 seconds (was 2 minutes)
+        MATCH_DETAILS: 2 * 60 * 1000, // 2 minutes (was 5 minutes)
+        STANDINGS: 15 * 60 * 1000, // 15 minutes (was 30 minutes)
+        TEAM_STATS: 30 * 60 * 1000, // 30 minutes (was 1 hour)
+        PLAYER_STATS: 30 * 60 * 1000, // 30 minutes (was 1 hour)
+        TRANSFER_NEWS: 10 * 60 * 1000, // 10 minutes (was 15 minutes)
+        PREDICTIONS: 60 * 60 * 1000, // 1 hour
+    },
+    // Stale-while-revalidate multipliers
+    STALE_MULTIPLIERS: {
+        LIVE_SCORES: 2, // Stale for 30 seconds (15s * 2)
+        ODDS: 2, // Stale for 1 minute (30s * 2)
+        MATCH_DETAILS: 2, // Stale for 4 minutes
+        STANDINGS: 1.5, // Stale for 22.5 minutes
+        TEAM_STATS: 1.5, // Stale for 45 minutes
     },
     // Cache file path
     CACHE_PATH: process.env.SPORTS_CACHE_PATH || '.sports_cache.json',
     // Max cache size (number of entries)
-    MAX_SIZE: 1000,
+    MAX_SIZE: 2000,
 };
 // ============= Scraping Configuration =============
 export const SCRAPER_CONFIG = {
@@ -152,10 +170,67 @@ export const ERRORS = {
     TIMEOUT: 'Request timed out.',
     INVALID_RESPONSE: 'Invalid response from API.',
     ALL_PROVIDERS_FAILED: 'All data providers failed.',
+    CIRCUIT_BREAKER_OPEN: 'Service temporarily unavailable due to repeated failures.',
+};
+// ============= Alert Configuration =============
+export const ALERT_CONFIG = {
+    // Check interval for alerts (milliseconds)
+    CHECK_INTERVAL: 10000, // 10 seconds
+    // Default cooldown between same alert (milliseconds)
+    DEFAULT_COOLDOWN: 300000, // 5 minutes
+    // Max alerts per hour per rule
+    MAX_ALERTS_PER_HOUR: 10,
+    // Alert types
+    TYPES: {
+        ODDS_DROP: 'odds_drop',
+        ODDS_VALUE: 'odds_value',
+        GOAL: 'goal',
+        RED_CARD: 'red_card',
+        LINEUP_CHANGE: 'lineup_change',
+        MATCH_START: 'match_start',
+        MATCH_END: 'match_end',
+        CUSTOM: 'custom',
+    },
+};
+// ============= Realtime Configuration =============
+export const REALTIME_CONFIG = {
+    // WebSocket reconnection
+    WS_RECONNECT_INTERVAL: 5000,
+    WS_MAX_RECONNECT_ATTEMPTS: 10,
+    // Polling intervals (fallback when WebSocket unavailable)
+    POLLING_INTERVALS: {
+        LIVE_SCORES: 15000, // 15 seconds
+        ODDS: 30000, // 30 seconds
+        MATCH_EVENTS: 5000, // 5 seconds
+    },
+    // Event batching
+    EVENT_BATCH_SIZE: 10,
+    EVENT_BATCH_TIMEOUT: 1000,
+};
+// ============= ML Prediction Configuration =============
+export const ML_CONFIG = {
+    // Minimum matches for training
+    MIN_TRAINING_MATCHES: 50,
+    // Feature weights
+    FEATURE_WEIGHTS: {
+        form: 0.25,
+        h2h: 0.20,
+        home_advantage: 0.15,
+        xg: 0.15,
+        injuries: 0.10,
+        fatigue: 0.10,
+        weather: 0.05,
+    },
+    // Confidence thresholds
+    CONFIDENCE_THRESHOLDS: {
+        high: 0.70,
+        medium: 0.55,
+        low: 0.40,
+    },
 };
 // ============= Version Info =============
 export const MODULE_INFO = {
     NAME: 'sports-module',
-    VERSION: '2.0.0',
-    DESCRIPTION: 'Football Intelligence System for MCP Server',
+    VERSION: '3.0.0',
+    DESCRIPTION: 'Football Intelligence System for MCP Server - Realtime Edition',
 };