@gotza02/sequential-thinking 10000.1.2 → 10000.1.3

package/dist/index.js

@@ -29,7 +29,10 @@ const server = new McpServer({
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 // Start Dashboard
-startDashboard(3001);
+const historyPath = process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json';
+startDashboard(3001, historyPath).catch(err => {
+    console.error("[Dashboard] Failed to start:", err);
+});
 const knowledgeGraph = new ProjectKnowledgeGraph();
 const memoryGraph = new KnowledgeGraphManager(process.env.MEMORY_GRAPH_PATH || 'knowledge_graph.json');
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');

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

@@ -1,19 +1,18 @@
 /**
- * ENHANCED CACHE SERVICE
- * TTL-based caching with stale-while-revalidate pattern
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
  */
 /**
- * CacheService - Thread-safe TTL-based caching with stale-while-revalidate
+ * CacheService - Thread-safe TTL-based caching with persistence
  */
 export declare class CacheService {
     private cache;
     private cachePath;
     private maxAge;
-    private staleAge;
     private maxSize;
     private savePending;
     private saveTimer;
-    constructor(cachePath?: string, maxAge?: number, maxSize?: number, staleAge?: number);
+    constructor(cachePath?: string, maxAge?: number, maxSize?: number);
     /**
      * Generate a cache key from components
      */
@@ -25,16 +24,7 @@ export declare class CacheService {
     /**
      * Set a value in cache
      */
-    set<T>(key: string, data: T, ttl?: number, staleTtl?: number): void;
-    /**
-     * Get or set with stale-while-revalidate pattern
-     * Returns cached value immediately, refreshes in background if stale
-     */
-    getOrSetWithStaleRevalidate<T>(key: string, factory: () => T | Promise<T>, ttl?: number, staleTtl?: number): Promise<T>;
-    /**
-     * Refresh data in background
-     */
-    private refreshInBackground;
+    set<T>(key: string, data: T, ttl?: number): void;
     /**
      * Check if a key exists and is not expired
      */
@@ -59,7 +49,6 @@ export declare class CacheService {
             hits: number;
             age: number;
             ttl: number;
-            isStale: boolean;
         }>;
     };
     /**
@@ -67,7 +56,7 @@ export declare class CacheService {
      */
     cleanup(): number;
     /**
-     * Evict the oldest entry (LRU with hit weighting)
+     * Evict the oldest entry (LRU)
      */
     private evictOldest;
     /**
@@ -89,7 +78,7 @@ export declare class CacheService {
     /**
      * Get or set pattern - returns cached value or computes and caches it
      */
-    getOrSet<T>(key: string, factory: () => T | Promise<T>, ttl?: number, staleTtl?: number): Promise<T>;
+    getOrSet<T>(key: string, factory: () => T | Promise<T>, ttl?: number): Promise<T>;
     /**
      * Get multiple keys at once
      */
@@ -97,7 +86,7 @@ export declare class CacheService {
     /**
      * Set multiple keys at once
      */
-    setMultiple<T>(entries: Map<string, T>, ttl?: number, staleTtl?: number): void;
+    setMultiple<T>(entries: Map<string, T>, ttl?: number): void;
     /**
      * Invalidate cache by pattern
      */

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

@@ -1,26 +1,24 @@
 /**
- * ENHANCED CACHE SERVICE
- * TTL-based caching with stale-while-revalidate pattern
+ * SPORTS MODULE CACHE SERVICE
+ * TTL-based caching with file persistence for the football intelligence system
  */
 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 stale-while-revalidate
+ * CacheService - Thread-safe TTL-based caching with persistence
  */
 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, staleAge) {
+    constructor(cachePath = CACHE_CONFIG.CACHE_PATH, maxAge = CACHE_CONFIG.DEFAULT_TTL, maxSize = CACHE_CONFIG.MAX_SIZE) {
         this.cachePath = path.resolve(cachePath);
         this.maxAge = maxAge;
-        this.staleAge = staleAge || maxAge * 2;
         this.maxSize = maxSize;
         this.loadFromFile();
     }
@@ -38,12 +36,11 @@ export class CacheService {
         if (!entry) {
             return null;
         }
-        // Check if expired (including stale period)
+        // Check if expired
         const now = Date.now();
-        const totalTtl = entry.ttl + entry.staleTtl;
-        if (now - entry.timestamp > totalTtl) {
+        if (now - entry.timestamp > entry.ttl) {
             this.cache.delete(key);
-            logger.debug(`Cache expired (including stale): ${key}`);
+            logger.debug(`Cache expired: ${key}`);
             return null;
         }
         // Increment hit counter
@@ -54,7 +51,7 @@ export class CacheService {
     /**
      * Set a value in cache
      */
-    set(key, data, ttl, staleTtl) {
+    set(key, data, ttl) {
         const now = Date.now();
         // Check if we need to evict old entries
         if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
@@ -65,64 +62,11 @@ 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, Stale: ${staleTtl || this.staleAge}ms)`);
+        logger.debug(`Cache set: ${key} (TTL: ${ttl || this.maxAge}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
      */
@@ -131,8 +75,7 @@ export class CacheService {
         if (!entry)
             return false;
         const now = Date.now();
-        const totalTtl = entry.ttl + entry.staleTtl;
-        if (now - entry.timestamp > totalTtl) {
+        if (now - entry.timestamp > entry.ttl) {
             this.cache.delete(key);
             return false;
         }
@@ -157,16 +100,12 @@ export class CacheService {
      */
     getStats() {
         const now = Date.now();
-        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,
-            };
-        });
+        const entries = Array.from(this.cache.values()).map(entry => ({
+            key: entry.key,
+            hits: entry.hits,
+            age: now - entry.timestamp,
+            ttl: entry.ttl,
+        }));
         return {
             size: this.cache.size,
             maxSize: this.maxSize,
@@ -181,8 +120,7 @@ export class CacheService {
         const now = Date.now();
         let removed = 0;
         for (const [key, entry] of this.cache.entries()) {
-            const totalTtl = entry.ttl + entry.staleTtl;
-            if (now - entry.timestamp > totalTtl) {
+            if (now - entry.timestamp > entry.ttl) {
                 this.cache.delete(key);
                 removed++;
             }
@@ -194,22 +132,20 @@ export class CacheService {
         return removed;
     }
     /**
-     * Evict the oldest entry (LRU with hit weighting)
+     * Evict the oldest entry (LRU)
      */
     evictOldest() {
         let oldestKey = null;
-        let lowestScore = Infinity;
-        // Evict based on age weighted by hits
+        let oldestTime = Infinity;
         for (const [key, entry] of this.cache.entries()) {
-            const score = (Date.now() - entry.timestamp) / (entry.hits + 1);
-            if (score < lowestScore) {
-                lowestScore = score;
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
                 oldestKey = key;
             }
         }
         if (oldestKey) {
             this.cache.delete(oldestKey);
-            logger.debug(`Evicted LRU entry: ${oldestKey}`);
+            logger.debug(`Evicted oldest cache entry: ${oldestKey}`);
         }
     }
     /**
@@ -222,7 +158,7 @@ export class CacheService {
         this.saveTimer = setTimeout(() => {
             this.saveToFile();
             this.saveTimer = null;
-        }, 1000);
+        }, 1000); // Save after 1 second of inactivity
     }
     /**
      * Save cache to file
@@ -256,8 +192,7 @@ export class CacheService {
             const now = Date.now();
             let restored = 0;
             for (const [key, entry] of entries) {
-                const totalTtl = entry.ttl + entry.staleTtl;
-                if (now - entry.timestamp < totalTtl) {
+                if (now - entry.timestamp < entry.ttl) {
                     this.cache.set(key, entry);
                     restored++;
                 }
@@ -265,6 +200,7 @@ 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');
         }
     }
@@ -281,8 +217,14 @@ export class CacheService {
     /**
      * Get or set pattern - returns cached value or computes and caches it
      */
-    async getOrSet(key, factory, ttl, staleTtl) {
-        return this.getOrSetWithStaleRevalidate(key, factory, ttl, staleTtl);
+    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;
     }
     /**
      * Get multiple keys at once
@@ -300,15 +242,16 @@ export class CacheService {
     /**
      * Set multiple keys at once
      */
-    setMultiple(entries, ttl, staleTtl) {
+    setMultiple(entries, ttl) {
         for (const [key, value] of entries.entries()) {
-            this.set(key, value, ttl, staleTtl);
+            this.set(key, value, ttl);
         }
     }
     /**
      * 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()) {
@@ -345,10 +288,10 @@ let globalCache = null;
 export function getGlobalCache() {
     if (!globalCache) {
         globalCache = new CacheService();
-        // Cleanup expired entries every 2 minutes
+        // Cleanup expired entries every 5 minutes
         setInterval(() => {
             globalCache?.cleanup();
-        }, 2 * 60 * 1000);
+        }, 5 * 60 * 1000);
     }
     return globalCache;
 }

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

@@ -10,40 +10,25 @@ 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: 2000;
+    readonly MAX_SIZE: 1000;
 };
 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"];
@@ -187,53 +172,9 @@ 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: "3.0.0";
-    readonly DESCRIPTION: "Football Intelligence System for MCP Server - Realtime Edition";
+    readonly VERSION: "2.0.0";
+    readonly DESCRIPTION: "Football Intelligence System for MCP Server";
 };

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

@@ -14,49 +14,31 @@ 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 (OPTIMIZED FOR REALTIME)
+    // Specific TTLs for different data types
     TTL: {
-        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
+        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
     },
     // Cache file path
     CACHE_PATH: process.env.SPORTS_CACHE_PATH || '.sports_cache.json',
     // Max cache size (number of entries)
-    MAX_SIZE: 2000,
+    MAX_SIZE: 1000,
 };
 // ============= Scraping Configuration =============
 export const SCRAPER_CONFIG = {
@@ -170,67 +152,10 @@ 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: '3.0.0',
-    DESCRIPTION: 'Football Intelligence System for MCP Server - Realtime Edition',
+    VERSION: '2.0.0',
+    DESCRIPTION: 'Football Intelligence System for MCP Server',
 };

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

@@ -7,7 +7,7 @@ export type MatchStatus = 'scheduled' | 'live' | 'finished' | 'postponed' | 'can
 export type BetType = 'home' | 'draw' | 'away' | 'over' | 'under' | 'btts' | 'handicap';
 export type KellyVariant = 'full' | 'half' | 'quarter';
 export type QueryType = 'general' | 'h2h' | 'form' | 'news' | 'stats' | 'odds' | 'referee' | 'weather' | 'fatigue' | 'setpieces';
-export type ProviderType = 'api-football' | 'football-data' | 'sports-db' | 'odds-api' | 'sportradar' | 'scraper';
+export type ProviderType = 'api-football' | 'football-data' | 'sports-db' | 'scraper';
 export interface SearchQuery {
     type: QueryType;
     query: string;
@@ -175,8 +175,6 @@ export interface Match {
     homeSubstitutes?: Player[];
     awaySubstitutes?: Player[];
     events?: MatchEvent[];
-    dataQuality?: number;
-    lastUpdated?: Date;
 }
 export interface MatchOdds {
     homeWin: number;
@@ -346,7 +344,6 @@ export interface APIResponse<T = any> {
     provider?: ProviderType;
     cached?: boolean;
     rateLimited?: boolean;
-    quality?: number;
 }
 export interface ProviderStatus {
     name: ProviderType;
@@ -355,7 +352,6 @@ export interface ProviderStatus {
     quotaLimit: number;
     rateLimitUntil?: Date;
     lastCall?: Date;
-    circuitBreakerState?: 'closed' | 'open' | 'half-open';
 }
 export interface ComparisonResult {
     teamA: Team;
@@ -381,38 +377,3 @@ export interface LiveScoreUpdate {
     events: MatchEvent[];
     timestamp: Date;
 }
-export interface MLPrediction {
-    matchId: string;
-    homeWinProbability: number;
-    drawProbability: number;
-    awayWinProbability: number;
-    over25Probability?: number;
-    bttsProbability?: number;
-    confidence: number;
-    factors: PredictionFactor[];
-    timestamp: Date;
-}
-export interface PredictionFactor {
-    name: string;
-    weight: number;
-    impact: 'positive' | 'negative' | 'neutral';
-    description: string;
-}
-export interface HistoricalPattern {
-    pattern: string;
-    occurrence: number;
-    successRate: number;
-    avgOdds: number;
-    profit: number;
-}
-export interface TeamHistoricalPerformance {
-    team: Team;
-    totalMatches: number;
-    wins: number;
-    draws: number;
-    losses: number;
-    avgGoalsFor: number;
-    avgGoalsAgainst: number;
-    homeAdvantage: number;
-    patterns: HistoricalPattern[];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.1.2",
+  "version": "10000.1.3",
   "publishConfig": {
     "access": "public"
   },