@gotza02/sequential-thinking 10000.1.3 → 10000.1.4

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

@@ -2,7 +2,7 @@
  * SPORTS MODULE BASE CLASSES
  * Abstract base classes and interfaces for data providers
  */
-import { Match, Team, Player, TableEntry, APIResponse, ProviderStatus, ProviderType } from './types.js';
+import { Match, Team, Player, TableEntry, APIResponse, ProviderStatus, ProviderType, HeadToHead, MatchOdds } from './types.js';
 import { CacheService } from './cache.js';
 /**
  * Base interface for all data providers
@@ -48,6 +48,18 @@ export interface IDataProvider {
      * Search for players
      */
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Fetch head-to-head statistics between two teams
+     */
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    /**
+     * Fetch recent form (last N matches) for a team
+     */
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    /**
+     * Fetch odds for a match
+     */
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
 }
 /**
  * Abstract base class for API-based providers
@@ -84,6 +96,18 @@ export declare abstract class APIProviderBase implements IDataProvider {
     abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
     abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
     abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Head-to-head statistics (optional, may not be supported by all providers)
+     */
+    abstract getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    /**
+     * Team recent form (optional, may not be supported by all providers)
+     */
+    abstract getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    /**
+     * Match odds (optional, may not be supported by all providers)
+     */
+    abstract getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     /**
      * Make a rate-limited API call
      */
@@ -117,6 +141,9 @@ export declare abstract class ScraperProviderBase implements IDataProvider {
     abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
     abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
     abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     /**
      * Scrape a webpage and extract structured data
      */
@@ -143,6 +170,9 @@ export declare class FallbackProvider implements IDataProvider {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
 }
 /**
  * Base class for sports tools

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

@@ -141,6 +141,16 @@ export class ScraperProviderBase {
             quotaLimit: Infinity,
         };
     }
+    // Optional methods - may not be implemented by all scrapers
+    async getH2H(matchId, team1Id, team2Id) {
+        return { success: false, error: 'H2H not available via scraper' };
+    }
+    async getTeamForm(teamId, last) {
+        return { success: false, error: 'Team form not available via scraper' };
+    }
+    async getMatchOdds(matchId) {
+        return { success: false, error: 'Match odds not available via scraper' };
+    }
     /**
      * Scrape a webpage and extract structured data
      */
@@ -243,6 +253,21 @@ export class FallbackProvider {
         return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.searchPlayers(query)), 60 * 60 * 1000 // 1 hour
         );
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        const cacheKey = CacheService.generateKey('h2h', matchId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getH2H(matchId, team1Id, team2Id)), 30 * 60 * 1000 // 30 minutes
+        );
+    }
+    async getTeamForm(teamId, last) {
+        const cacheKey = CacheService.generateKey('form', teamId, last?.toString() || '5');
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getTeamForm(teamId, last)), 30 * 60 * 1000 // 30 minutes
+        );
+    }
+    async getMatchOdds(matchId) {
+        const cacheKey = CacheService.generateKey('odds', matchId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getMatchOdds(matchId)), 5 * 60 * 1000 // 5 minutes (odds change frequently)
+        );
+    }
 }
 /**
  * Base class for sports tools

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

@@ -377,3 +377,154 @@ export interface LiveScoreUpdate {
     events: MatchEvent[];
     timestamp: Date;
 }
+/**
+ * Probability range with uncertainty quantification
+ */
+export interface ProbabilityRange {
+    low: number;
+    mid: number;
+    high: number;
+}
+/**
+ * Data quality assessment
+ */
+export interface DataQuality {
+    score: number;
+    factors: {
+        hasAPIData: boolean;
+        hasRecentData: boolean;
+        sampleSize: 'small' | 'medium' | 'large';
+        dataAge: number;
+        missingDataPoints: string[];
+    };
+}
+/**
+ * Value bet recommendation with full analysis
+ */
+export interface ValueBetRecommendation {
+    selection: string;
+    market: '1x2' | 'over_under' | 'btts' | 'asian_handicap';
+    odds: number;
+    fairOdds: number;
+    value: number;
+    confidence: number;
+    kellyFraction: number;
+    recommendedStake: number;
+    reasoning: string;
+}
+/**
+ * Game scenario for skeptic analysis
+ */
+export interface GameScenario {
+    trigger: string;
+    probability: number;
+    impact: 'high' | 'medium' | 'low';
+    description: string;
+}
+/**
+ * Fatigue assessment
+ */
+export interface FatigueAssessment {
+    score: number;
+    daysRest: number;
+    travelDistance?: number;
+    squadDepth: number;
+    keyInjuries: string[];
+}
+/**
+ * Six-persona analysis output structure
+ */
+export interface SixPersonaAnalysis {
+    dataScientist: {
+        homeWinProbability: ProbabilityRange;
+        drawProbability: ProbabilityRange;
+        awayWinProbability: ProbabilityRange;
+        expectedGoals: {
+            home: number;
+            away: number;
+        };
+        keyStats: ComparisonMetric[];
+    };
+    tacticalScout: {
+        homeFormation?: string;
+        awayFormation?: string;
+        styleMatchup: string;
+        keyBattles: string[];
+        tacticalAdvantage: 'home' | 'away' | 'neutral';
+    };
+    physio: {
+        homeFatigue: FatigueAssessment;
+        awayFatigue: FatigueAssessment;
+        injuryImpact: string;
+    };
+    setPieceAnalyst: {
+        homeStrength: number;
+        awayStrength: number;
+        predictedCorners: number;
+        aerialAdvantage: 'home' | 'away' | 'neutral';
+    };
+    insider: {
+        marketMovement: string;
+        weatherImpact?: string;
+        refereeImpact?: string;
+        managerialContext?: string;
+    };
+    skeptic: {
+        upsetRisk: number;
+        trapIndicators: string[];
+        gameScenarios: GameScenario[];
+    };
+}
+/**
+ * Complete match analysis result (structured output)
+ */
+export interface MatchAnalysisResult {
+    match: {
+        homeTeam: string;
+        awayTeam: string;
+        league?: string;
+        date?: Date;
+        matchId?: string;
+    };
+    dataQuality: DataQuality;
+    analysis: SixPersonaAnalysis;
+    predictions: {
+        matchResult: {
+            homeWin: ProbabilityRange;
+            draw: ProbabilityRange;
+            awayWin: ProbabilityRange;
+        };
+        overUnder25: {
+            over: ProbabilityRange;
+            under: ProbabilityRange;
+        };
+        btts: {
+            yes: ProbabilityRange;
+            no: ProbabilityRange;
+        };
+    };
+    valueBets: ValueBetRecommendation[];
+    verdict: {
+        summary: string;
+        bestBet: string;
+        confidence: number;
+        riskLevel: 'low' | 'medium' | 'high';
+    };
+    metadata: {
+        generatedAt: Date;
+        dataSources: string[];
+    };
+}
+/**
+ * API Match data bundle
+ */
+export interface APIMatchData {
+    match?: Match;
+    h2h?: HeadToHead;
+    homeForm?: Match[];
+    awayForm?: Match[];
+    homeStats?: TeamStats;
+    awayStats?: TeamStats;
+    odds?: MatchOdds;
+    lastUpdated?: Date;
+}

package/dist/tools/sports/providers/api.d.ts

@@ -2,7 +2,7 @@
  * SPORTS MODULE API PROVIDERS
  * Concrete implementations of football API providers
  */
-import { Match, Team, Player, TableEntry, APIResponse } from '../core/types.js';
+import { Match, Team, Player, TableEntry, APIResponse, HeadToHead, MatchOdds } from '../core/types.js';
 import { APIProviderBase, FallbackProvider } from '../core/base.js';
 /**
  * API-Football Provider (via RapidAPI)
@@ -19,12 +19,17 @@ export declare class APIFootballProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatch;
     private transformTeam;
     private transformPlayer;
     private transformTableEntry;
     private mapStatus;
     private mapPosition;
+    private transformH2H;
+    private transformOdds;
 }
 /**
  * Football-Data.org Provider
@@ -41,6 +46,9 @@ export declare class FootballDataProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatchFD;
     private transformTeamFD;
     private transformTableEntryFD;
@@ -61,6 +69,9 @@ export declare class SportsDBProvider extends APIProviderBase {
     getPlayer(playerId: string): Promise<APIResponse<Player>>;
     searchTeams(query: string): Promise<APIResponse<Team[]>>;
     searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    getH2H(matchId: string, team1Id?: string, team2Id?: string): Promise<APIResponse<HeadToHead>>;
+    getTeamForm(teamId: string, last?: number): Promise<APIResponse<Match[]>>;
+    getMatchOdds(matchId: string): Promise<APIResponse<MatchOdds>>;
     private transformMatchDB;
     private transformTeamDB;
     private transformPlayerDB;

package/dist/tools/sports/providers/api.js

@@ -88,6 +88,58 @@ export class APIFootballProvider extends APIProviderBase {
         }
         return response;
     }
+    // ============= New Methods for Enhanced Analysis =============
+    async getH2H(matchId, team1Id, team2Id) {
+        const cacheKey = `h2h:api-football:${matchId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        // Use team IDs if provided, otherwise fetch match first to get teams
+        let homeId = team1Id;
+        let awayId = team2Id;
+        if (!homeId || !awayId) {
+            const matchResult = await this.getMatch(matchId);
+            if (!matchResult.success || !matchResult.data) {
+                return { success: false, error: 'Could not resolve team IDs for H2H' };
+            }
+            homeId = matchResult.data.homeTeam.id;
+            awayId = matchResult.data.awayTeam.id;
+        }
+        const response = await this.callAPI(`/fixtures/headtohead?h2h=${homeId}-${awayId}`);
+        if (response.success && response.data?.response) {
+            const h2h = this.transformH2H(response.data.response, homeId, awayId);
+            this.cache.set(cacheKey, h2h);
+            return { success: true, data: h2h, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getTeamForm(teamId, last = 5) {
+        const cacheKey = `form:api-football:${teamId}:${last}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        const currentYear = new Date().getFullYear();
+        const response = await this.callAPI(`/fixtures?team=${teamId}&last=${last}&season=${currentYear}`);
+        if (response.success && response.data?.response) {
+            const matches = response.data.response.map((m) => this.transformMatch(m));
+            this.cache.set(cacheKey, matches);
+            return { success: true, data: matches, provider: 'api-football' };
+        }
+        return response;
+    }
+    async getMatchOdds(matchId) {
+        const cacheKey = `odds:api-football:${matchId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return { success: true, data: cached, cached: true };
+        const response = await this.callAPI(`/odds?fixture=${matchId}`);
+        if (response.success && response.data?.response?.[0]) {
+            const odds = this.transformOdds(response.data.response[0]);
+            this.cache.set(cacheKey, odds);
+            return { success: true, data: odds, provider: 'api-football' };
+        }
+        return response;
+    }
     // ============= Transformation Helpers =============
     transformMatch(data) {
         return {
@@ -194,6 +246,87 @@ export class APIFootballProvider extends APIProviderBase {
             return 'FW';
         return 'SUB';
     }
+    transformH2H(data, homeId, awayId) {
+        const matches = data.map(m => this.transformMatch(m));
+        let homeWins = 0;
+        let draws = 0;
+        let awayWins = 0;
+        let homeGoals = 0;
+        let awayGoals = 0;
+        for (const match of matches) {
+            if (!match.score)
+                continue;
+            // Determine which team was home/away in the H2H match
+            const isHomeTeam = match.homeTeam.id === homeId;
+            if (match.score.home === match.score.away) {
+                draws++;
+            }
+            else if (isHomeTeam) {
+                if (match.score.home > match.score.away)
+                    homeWins++;
+                else
+                    awayWins++;
+            }
+            else {
+                if (match.score.away > match.score.home)
+                    homeWins++;
+                else
+                    awayWins++;
+            }
+            homeGoals += isHomeTeam ? match.score.home : match.score.away;
+            awayGoals += isHomeTeam ? match.score.away : match.score.home;
+        }
+        return {
+            homeTeam: matches[0]?.homeTeam.id === homeId ? matches[0].homeTeam : matches[0]?.awayTeam,
+            awayTeam: matches[0]?.homeTeam.id === awayId ? matches[0].homeTeam : matches[0]?.awayTeam,
+            totalMatches: matches.length,
+            homeWins,
+            draws,
+            awayWins,
+            homeGoals,
+            awayGoals,
+            recentMatches: matches.slice(0, 5),
+        };
+    }
+    transformOdds(data) {
+        // Find 1x2 odds from the first bookmaker
+        const bookmaker = data.bookmakers?.[0];
+        const matchWinnerBet = bookmaker?.bets?.find((b) => b.name === 'Match Winner');
+        const homeWinOdds = matchWinnerBet?.values?.find((v) => v.value === 'Home')?.odd;
+        const drawOdds = matchWinnerBet?.values?.find((v) => v.value === 'Draw')?.odd;
+        const awayWinOdds = matchWinnerBet?.values?.find((v) => v.value === 'Away')?.odd;
+        // Default odds if not found
+        const result = {
+            homeWin: parseFloat(homeWinOdds) || 2.0,
+            draw: parseFloat(drawOdds) || 3.0,
+            awayWin: parseFloat(awayWinOdds) || 2.0,
+            provider: bookmaker?.name || 'Unknown',
+            timestamp: new Date(data.update || Date.now()),
+        };
+        // Try to find Asian Handicap odds
+        const ahBet = bookmaker?.bets?.find((b) => b.name?.toLowerCase().includes('asian') ||
+            b.name?.toLowerCase().includes('handicap'));
+        if (ahBet?.values?.[0]) {
+            const ahValue = ahBet.values[0];
+            result.asianHandicap = {
+                home: parseFloat(ahValue.odd) || 2.0,
+                away: parseFloat(ahValue.odd) || 2.0,
+                line: parseFloat(ahValue.value) || 0,
+            };
+        }
+        // Try to find Over/Under odds
+        const ouBet = bookmaker?.bets?.find((b) => b.name?.toLowerCase().includes('over/under'));
+        if (ouBet?.values?.[0]) {
+            const ouValue = ouBet.values[0];
+            const line = parseFloat(ouValue.value?.replace('Over ', '').replace('Under ', '')) || 2.5;
+            result.overUnder = {
+                line,
+                over: parseFloat(ouValue.odd) || 2.0,
+                under: parseFloat(ouValue.odd) || 2.0,
+            };
+        }
+        return result;
+    }
 }
 /**
  * Football-Data.org Provider
@@ -263,6 +396,25 @@ export class FootballDataProvider extends APIProviderBase {
             error: 'Search not available via Football-Data.org',
         };
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        return {
+            success: false,
+            error: 'H2H data not available via Football-Data.org',
+        };
+    }
+    async getTeamForm(teamId, last) {
+        // Football-Data.org has limited form data in match endpoints
+        return {
+            success: false,
+            error: 'Team form not directly available via Football-Data.org',
+        };
+    }
+    async getMatchOdds(matchId) {
+        return {
+            success: false,
+            error: 'Odds not available via Football-Data.org',
+        };
+    }
     // ============= Transformation Helpers (Football-Data.org format) =============
     transformMatchFD(data) {
         return {
@@ -416,6 +568,24 @@ export class SportsDBProvider extends APIProviderBase {
         }
         return response;
     }
+    async getH2H(matchId, team1Id, team2Id) {
+        return {
+            success: false,
+            error: 'H2H data not available via TheSportsDB',
+        };
+    }
+    async getTeamForm(teamId, last) {
+        return {
+            success: false,
+            error: 'Team form not directly available via TheSportsDB',
+        };
+    }
+    async getMatchOdds(matchId) {
+        return {
+            success: false,
+            error: 'Odds not available via TheSportsDB',
+        };
+    }
     // ============= Transformation Helpers (TheSportsDB format) =============
     transformMatchDB(data) {
         return {

package/dist/tools/sports/tools/match.d.ts

@@ -3,8 +3,13 @@
  * Tools for match analysis and live scores
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { MatchAnalysisResult } from '../core/types.js';
 /**
  * Perform comprehensive match analysis using web search
  */
 export declare function performMatchAnalysis(homeTeam: string, awayTeam: string, league?: string, context?: string): Promise<string>;
+/**
+ * Perform structured match analysis with JSON output
+ */
+export declare function performStructuredMatchAnalysis(homeTeam: string, awayTeam: string, league?: string, context?: string): Promise<MatchAnalysisResult>;
 export declare function registerMatchTools(server: McpServer): void;

package/dist/tools/sports/tools/match.js

@@ -9,6 +9,7 @@ import { scrapeMatchContent, findBestMatchUrl, findBestNewsUrl } from '../provid
 import { getGlobalCache, CacheService } from '../core/cache.js';
 import { formatMatchesTable, formatScore, formatMatchStatus } from '../utils/formatter.js';
 import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
+import { logger } from '../../../utils.js';
 // ============= Helper Functions =============
 /**
  * Get date context for search queries
@@ -62,6 +63,200 @@ async function findMatchId(homeTeam, awayTeam, league) {
     }
     return null;
 }
+/**
+ * Fetch comprehensive API data for a match
+ */
+async function fetchAPIMatchData(api, matchId, homeTeam, awayTeam) {
+    try {
+        // Fetch all data in parallel
+        const [matchResult, h2hResult, oddsResult] = await Promise.all([
+            api.getMatch(matchId),
+            api.getH2H(matchId),
+            api.getMatchOdds(matchId),
+        ]);
+        let homeForm;
+        let awayForm;
+        // Get team form if we have match data
+        if (matchResult.success && matchResult.data) {
+            const [homeFormResult, awayFormResult] = await Promise.all([
+                api.getTeamForm(matchResult.data.homeTeam.id, 5),
+                api.getTeamForm(matchResult.data.awayTeam.id, 5),
+            ]);
+            if (homeFormResult.success && homeFormResult.data) {
+                homeForm = homeFormResult.data;
+            }
+            if (awayFormResult.success && awayFormResult.data) {
+                awayForm = awayFormResult.data;
+            }
+        }
+        return {
+            match: matchResult.success ? matchResult.data : undefined,
+            h2h: h2hResult.success ? h2hResult.data : undefined,
+            homeForm,
+            awayForm,
+            odds: oddsResult.success ? oddsResult.data : undefined,
+            lastUpdated: new Date(),
+        };
+    }
+    catch (error) {
+        logger.error(`Error fetching API match data: ${error}`);
+        return null;
+    }
+}
+/**
+ * Assess what data coverage we have from API
+ */
+function assessDataCoverage(apiData) {
+    if (!apiData) {
+        return {
+            score: 0,
+            factors: {
+                hasAPIData: false,
+                hasRecentData: false,
+                sampleSize: 'small',
+                dataAge: 999,
+                missingDataPoints: ['all'],
+            },
+        };
+    }
+    let score = 0;
+    const missingDataPoints = [];
+    // Base match data
+    if (apiData.match) {
+        score += 40;
+    }
+    else {
+        missingDataPoints.push('match');
+    }
+    // H2H data
+    if (apiData.h2h && apiData.h2h.totalMatches > 0) {
+        score += 20;
+    }
+    else {
+        missingDataPoints.push('h2h');
+    }
+    // Form data
+    if (apiData.homeForm && apiData.homeForm.length >= 3) {
+        score += 15;
+    }
+    else {
+        missingDataPoints.push('homeForm');
+    }
+    if (apiData.awayForm && apiData.awayForm.length >= 3) {
+        score += 15;
+    }
+    else {
+        missingDataPoints.push('awayForm');
+    }
+    // Odds data
+    if (apiData.odds) {
+        score += 10;
+    }
+    else {
+        missingDataPoints.push('odds');
+    }
+    // Calculate data age
+    const dataAge = apiData.lastUpdated
+        ? (Date.now() - apiData.lastUpdated.getTime()) / (1000 * 60 * 60)
+        : 999;
+    // Determine sample size
+    let sampleSize = 'small';
+    const totalMatches = (apiData.homeForm?.length || 0) + (apiData.awayForm?.length || 0);
+    if (totalMatches >= 10)
+        sampleSize = 'large';
+    else if (totalMatches >= 5)
+        sampleSize = 'medium';
+    return {
+        score: Math.min(100, score),
+        factors: {
+            hasAPIData: score > 0,
+            hasRecentData: dataAge < 24,
+            sampleSize,
+            dataAge,
+            missingDataPoints,
+        },
+    };
+}
+/**
+ * Optimize search queries based on API data coverage
+ */
+function optimizeQueries(coverage, baseQueries) {
+    // Always search for these (API doesn't cover well)
+    const alwaysSearch = ['fatigue', 'setpieces', 'referee', 'weather'];
+    return baseQueries.filter(q => {
+        // Always include critical queries
+        if (alwaysSearch.includes(q.type))
+            return true;
+        // Skip queries that API already covers well
+        switch (q.type) {
+            case 'h2h':
+                // Skip H2H search if we have good H2H data
+                return !coverage.factors.hasAPIData || coverage.factors.missingDataPoints.includes('h2h');
+            case 'form':
+                // Skip form search if we have form data
+                return !coverage.factors.hasAPIData ||
+                    (coverage.factors.missingDataPoints.includes('homeForm') ||
+                        coverage.factors.missingDataPoints.includes('awayForm'));
+            case 'stats':
+                // Stats need web search for xG
+                return true;
+            case 'news':
+                // Always search for news/lineups
+                return true;
+            case 'odds':
+                // Skip odds search if we have API odds
+                return !coverage.factors.hasAPIData || coverage.factors.missingDataPoints.includes('odds');
+            default:
+                return true;
+        }
+    });
+}
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+function calculateAdaptiveTTL(dataType, matchDate) {
+    const now = Date.now();
+    const hoursUntilMatch = matchDate
+        ? (matchDate.getTime() - now) / (1000 * 60 * 60)
+        : Infinity;
+    switch (dataType) {
+        case 'odds':
+            // Odds change frequently - short TTL
+            if (hoursUntilMatch < 1)
+                return 60 * 1000; // 1 minute
+            if (hoursUntilMatch < 24)
+                return 5 * 60 * 1000; // 5 minutes
+            return 15 * 60 * 1000; // 15 minutes
+        case 'lineups':
+            // Lineups announced ~1 hour before match
+            if (hoursUntilMatch < 2)
+                return 5 * 60 * 1000; // 5 minutes
+            return 60 * 60 * 1000; // 1 hour
+        case 'news':
+            // News changes throughout the day
+            if (hoursUntilMatch < 24)
+                return 15 * 60 * 1000; // 15 minutes
+            return 60 * 60 * 1000; // 1 hour
+        case 'stats':
+        case 'h2h':
+            // Historical stats don't change
+            return 24 * 60 * 60 * 1000; // 24 hours
+        case 'form':
+            // Form updates after each match
+            if (hoursUntilMatch < 0)
+                return 60 * 1000; // Live match - 1 minute
+            return 6 * 60 * 60 * 1000; // 6 hours
+        case 'match':
+            // Match data changes based on timing
+            if (hoursUntilMatch < 0)
+                return 60 * 1000; // Live - 1 minute
+            if (hoursUntilMatch < 1)
+                return 5 * 60 * 1000; // 5 minutes
+            return 30 * 60 * 1000; // 30 minutes
+        default:
+            return 30 * 60 * 1000; // 30 minutes default
+    }
+}
 /**
  * Perform comprehensive match analysis using web search
  */
@@ -83,15 +278,73 @@ export async function performMatchAnalysis(homeTeam, awayTeam, league, context)
     if (context) {
         queries.push({ type: 'general', query: `${baseQuery} ${context}${dateQuery}`, title: 'Specific Context' });
     }
-    // Optimization: Skip some web searches if we have a matchId (API should cover these)
+    // Try to get API data first
+    const api = createAPIProvider();
     const matchId = await findMatchId(homeTeam, awayTeam, league);
-    const queriesToExecute = matchId
-        ? queries.filter(q => !['news', 'stats'].includes(q.type)) // API covers lineups and basic stats
-        : queries;
+    let apiData = null;
+    if (matchId) {
+        apiData = await fetchAPIMatchData(api, matchId, homeTeam, awayTeam);
+    }
+    // Assess data coverage and optimize queries
+    const coverage = assessDataCoverage(apiData);
+    const queriesToExecute = optimizeQueries(coverage, queries);
     let combinedResults = `--- FOOTBALL MATCH DATA: ${homeTeam} vs ${awayTeam} ---\n`;
     if (matchId)
         combinedResults += `Resolved API Match ID: ${matchId}\n`;
+    combinedResults += `Data Quality Score: ${coverage.score}/100\n`;
     combinedResults += `Match Context Date: ${new Date().toLocaleDateString()}\n\n`;
+    // Add API Data section if available
+    if (apiData && coverage.score > 0) {
+        combinedResults += `--- API DATA (Reliable Source) ---\n\n`;
+        if (apiData.h2h) {
+            combinedResults += `### Head-to-Head Record\n`;
+            combinedResults += `- Total Matches: ${apiData.h2h.totalMatches}\n`;
+            combinedResults += `- ${homeTeam} Wins: ${apiData.h2h.homeWins}\n`;
+            combinedResults += `- Draws: ${apiData.h2h.draws}\n`;
+            combinedResults += `- ${awayTeam} Wins: ${apiData.h2h.awayWins}\n`;
+            combinedResults += `- Goals: ${apiData.h2h.homeGoals}-${apiData.h2h.awayGoals}\n\n`;
+        }
+        if (apiData.homeForm?.length) {
+            combinedResults += `### ${homeTeam} Recent Form (Last ${apiData.homeForm.length})\n`;
+            combinedResults += apiData.homeForm.map(m => {
+                const isHome = m.homeTeam.name.includes(homeTeam);
+                const score = m.score ? `${m.score.home}-${m.score.away}` : '?';
+                const opponent = isHome ? m.awayTeam.name : m.homeTeam.name;
+                const result = isHome
+                    ? (m.score?.home ?? 0) > (m.score?.away ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L')
+                    : (m.score?.away ?? 0) > (m.score?.home ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L');
+                return `- ${result} vs ${opponent} (${score})`;
+            }).join('\n');
+            combinedResults += '\n\n';
+        }
+        if (apiData.awayForm?.length) {
+            combinedResults += `### ${awayTeam} Recent Form (Last ${apiData.awayForm.length})\n`;
+            combinedResults += apiData.awayForm.map(m => {
+                const isAway = m.awayTeam.name.includes(awayTeam);
+                const score = m.score ? `${m.score.home}-${m.score.away}` : '?';
+                const opponent = isAway ? m.homeTeam.name : m.awayTeam.name;
+                const result = isAway
+                    ? (m.score?.away ?? 0) > (m.score?.home ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L')
+                    : (m.score?.home ?? 0) > (m.score?.away ?? 0) ? 'W' : (m.score?.home === m.score?.away ? 'D' : 'L');
+                return `- ${result} vs ${opponent} (${score})`;
+            }).join('\n');
+            combinedResults += '\n\n';
+        }
+        if (apiData.odds) {
+            combinedResults += `### Current Odds (from API)\n`;
+            combinedResults += `- Home Win: ${apiData.odds.homeWin.toFixed(2)}\n`;
+            combinedResults += `- Draw: ${apiData.odds.draw.toFixed(2)}\n`;
+            combinedResults += `- Away Win: ${apiData.odds.awayWin.toFixed(2)}\n`;
+            if (apiData.odds.asianHandicap) {
+                combinedResults += `- Asian Handicap: ${apiData.odds.asianHandicap.line}\n`;
+            }
+            combinedResults += '\n';
+        }
+        combinedResults += `--- END API DATA ---\n\n`;
+    }
+    if (coverage.factors.missingDataPoints.length > 0) {
+        combinedResults += `*Note: Using web search to supplement: ${coverage.factors.missingDataPoints.join(', ')}*\n\n`;
+    }
     const candidateUrls = [];
     // Execute searches in parallel (in batches)
     const BATCH_SIZE = 4;
@@ -164,6 +417,225 @@ export async function performMatchAnalysis(homeTeam, awayTeam, league, context)
     combinedResults += `🏆 FINAL VERDICT:\n   - Asian Handicap Leans\n   - Goal Line (Over/Under)\n   - The "Value Pick"`;
     return combinedResults;
 }
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+function calculateProbabilityRange(baseProbability, dataQuality) {
+    // Higher data quality = narrower range
+    const qualityFactor = dataQuality.score / 100;
+    const baseUncertainty = 0.15; // 15% base uncertainty
+    // Adjust uncertainty based on data quality
+    const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
+    // Calculate range
+    const mid = baseProbability;
+    const margin = adjustedUncertainty * Math.sqrt(baseProbability * (1 - baseProbability));
+    return {
+        low: Math.max(0, mid - margin * 1.645), // 5th percentile
+        mid,
+        high: Math.min(1, mid + margin * 1.645), // 95th percentile
+    };
+}
+/**
+ * Detect value bets from predictions and odds
+ */
+async function detectValueBets(apiData, homeTeam, awayTeam) {
+    const valueBets = [];
+    if (!apiData?.odds)
+        return valueBets;
+    // Estimate probabilities from API data
+    // Simple model: use form and H2H to estimate
+    let homeWinProb = 0.33;
+    let drawProb = 0.33;
+    let awayWinProb = 0.33;
+    if (apiData.homeForm && apiData.awayForm) {
+        const homeWins = apiData.homeForm.filter(m => {
+            const isHome = m.homeTeam.name.includes(homeTeam);
+            return isHome ? (m.score?.home ?? 0) > (m.score?.away ?? 0) : (m.score?.away ?? 0) > (m.score?.home ?? 0);
+        }).length;
+        const awayWins = apiData.awayForm.filter(m => {
+            const isAway = m.awayTeam.name.includes(awayTeam);
+            return isAway ? (m.score?.away ?? 0) > (m.score?.home ?? 0) : (m.score?.home ?? 0) > (m.score?.away ?? 0);
+        }).length;
+        // Normalize to probabilities
+        const total = homeWins + awayWins + 2; // +2 for draws
+        homeWinProb = (homeWins + 1) / total;
+        awayWinProb = (awayWins + 1) / total;
+        drawProb = 1 - homeWinProb - awayWinProb;
+    }
+    // Calculate value for each market
+    const markets = [
+        { selection: `${homeTeam} Win`, prob: homeWinProb, odds: apiData.odds.homeWin },
+        { selection: 'Draw', prob: drawProb, odds: apiData.odds.draw },
+        { selection: `${awayTeam} Win`, prob: awayWinProb, odds: apiData.odds.awayWin },
+    ];
+    for (const market of markets) {
+        if (!market.odds || market.prob <= 0)
+            continue;
+        const fairOdds = 1 / market.prob;
+        const value = (market.odds / fairOdds) - 1;
+        // Only include if value > 5%
+        if (value >= 0.05) {
+            const kelly = (market.prob * market.odds - 1) / (market.odds - 1);
+            valueBets.push({
+                selection: market.selection,
+                market: '1x2',
+                odds: market.odds,
+                fairOdds,
+                value,
+                confidence: Math.min(90, 50 + value * 200), // Scale value to confidence
+                kellyFraction: Math.max(0, kelly / 2), // Half Kelly
+                recommendedStake: Math.max(0, kelly / 2) * 100, // Based on 100 unit bankroll
+                reasoning: `Estimated probability ${(market.prob * 100).toFixed(1)}% vs implied ${((1 / market.odds) * 100).toFixed(1)}%`,
+            });
+        }
+    }
+    return valueBets.sort((a, b) => b.value - a.value);
+}
+/**
+ * Build structured analysis result from API and web data
+ */
+async function buildStructuredAnalysis(homeTeam, awayTeam, league, apiData, coverage) {
+    // Calculate base probabilities
+    let homeWinProb = 0.35;
+    let drawProb = 0.30;
+    let awayWinProb = 0.35;
+    // Adjust based on form if available
+    if (apiData?.homeForm && apiData?.awayForm) {
+        const homePoints = apiData.homeForm.reduce((sum, m) => {
+            const isHome = m.homeTeam.name.includes(homeTeam);
+            const score = m.score;
+            if (!score)
+                return sum;
+            if (isHome) {
+                return sum + (score.home > score.away ? 3 : score.home === score.away ? 1 : 0);
+            }
+            else {
+                return sum + (score.away > score.home ? 3 : score.away === score.home ? 1 : 0);
+            }
+        }, 0);
+        const awayPoints = apiData.awayForm.reduce((sum, m) => {
+            const isAway = m.awayTeam.name.includes(awayTeam);
+            const score = m.score;
+            if (!score)
+                return sum;
+            if (isAway) {
+                return sum + (score.away > score.home ? 3 : score.away === score.home ? 1 : 0);
+            }
+            else {
+                return sum + (score.home > score.away ? 3 : score.home === score.away ? 1 : 0);
+            }
+        }, 0);
+        const totalPoints = homePoints + awayPoints + 5; // +5 for draw possibility
+        homeWinProb = (homePoints + 1.5) / totalPoints;
+        awayWinProb = (awayPoints + 1.5) / totalPoints;
+        drawProb = 1 - homeWinProb - awayWinProb;
+    }
+    // Calculate probability ranges
+    const predictions = {
+        matchResult: {
+            homeWin: calculateProbabilityRange(homeWinProb, coverage),
+            draw: calculateProbabilityRange(drawProb, coverage),
+            awayWin: calculateProbabilityRange(awayWinProb, coverage),
+        },
+        overUnder25: {
+            over: calculateProbabilityRange(0.50, coverage), // Placeholder
+            under: calculateProbabilityRange(0.50, coverage),
+        },
+        btts: {
+            yes: calculateProbabilityRange(0.50, coverage), // Placeholder
+            no: calculateProbabilityRange(0.50, coverage),
+        },
+    };
+    // Detect value bets
+    const valueBets = await detectValueBets(apiData, homeTeam, awayTeam);
+    // Build six-persona analysis
+    const analysis = {
+        dataScientist: {
+            homeWinProbability: predictions.matchResult.homeWin,
+            drawProbability: predictions.matchResult.draw,
+            awayWinProbability: predictions.matchResult.awayWin,
+            expectedGoals: { home: 1.3, away: 1.2 }, // Placeholder - would need xG data
+            keyStats: [],
+        },
+        tacticalScout: {
+            styleMatchup: 'Analysis requires detailed tactical data',
+            keyBattles: [],
+            tacticalAdvantage: 'neutral',
+        },
+        physio: {
+            homeFatigue: {
+                score: 50,
+                daysRest: 3,
+                squadDepth: 5,
+                keyInjuries: [],
+            },
+            awayFatigue: {
+                score: 50,
+                daysRest: 3,
+                squadDepth: 5,
+                keyInjuries: [],
+            },
+            injuryImpact: 'Analysis requires injury data',
+        },
+        setPieceAnalyst: {
+            homeStrength: 5,
+            awayStrength: 5,
+            predictedCorners: 10,
+            aerialAdvantage: 'neutral',
+        },
+        insider: {
+            marketMovement: apiData?.odds ? `Home: ${apiData.odds.homeWin.toFixed(2)}, Draw: ${apiData.odds.draw.toFixed(2)}, Away: ${apiData.odds.awayWin.toFixed(2)}` : 'No odds data',
+        },
+        skeptic: {
+            upsetRisk: 0.25,
+            trapIndicators: [],
+            gameScenarios: [],
+        },
+    };
+    // Determine best bet
+    const bestBet = valueBets.length > 0
+        ? valueBets[0].selection
+        : `${homeTeam} Win or Draw (Double Chance)`;
+    return {
+        match: {
+            homeTeam,
+            awayTeam,
+            league,
+            matchId: apiData?.match?.id,
+        },
+        dataQuality: coverage,
+        analysis,
+        predictions,
+        valueBets,
+        verdict: {
+            summary: `Analysis based on ${coverage.score}/100 data quality. ${apiData?.h2h ? `H2H: ${apiData.h2h.homeWins}-${apiData.h2h.draws}-${apiData.h2h.awayWins}` : 'No H2H data'}`,
+            bestBet,
+            confidence: coverage.score,
+            riskLevel: coverage.score >= 70 ? 'low' : coverage.score >= 40 ? 'medium' : 'high',
+        },
+        metadata: {
+            generatedAt: new Date(),
+            dataSources: apiData ? ['api-football'] : ['web-search'],
+        },
+    };
+}
+/**
+ * Perform structured match analysis with JSON output
+ */
+export async function performStructuredMatchAnalysis(homeTeam, awayTeam, league, context) {
+    // Fetch API data
+    const api = createAPIProvider();
+    const matchId = await findMatchId(homeTeam, awayTeam, league);
+    let apiData = null;
+    if (matchId) {
+        apiData = await fetchAPIMatchData(api, matchId, homeTeam, awayTeam);
+    }
+    // Assess data coverage
+    const coverage = assessDataCoverage(apiData);
+    // Build structured analysis
+    const result = await buildStructuredAnalysis(homeTeam, awayTeam, league, apiData, coverage);
+    return result;
+}
 // ============= Tool Registration =============
 export function registerMatchTools(server) {
     /**
@@ -211,7 +683,60 @@ Market Intelligence, Referee stats, Weather, Fatigue analysis, Set Pieces.`, {
         };
     });
     /**
-     * Tool 2: get_live_scores
+     * Tool 2: analyze_football_match_structured
+     * Structured JSON output for programmatic use
+     */
+    server.tool('analyze_football_match_structured', `Comprehensive football match analysis with structured JSON output.
+Returns: Probabilities with confidence ranges, 6-persona analysis, value bets, data quality score.
+Use this for programmatic access to match analysis.`, {
+        homeTeam: z.string().describe('Name of the home team'),
+        awayTeam: z.string().describe('Name of the away team'),
+        league: z.string().optional().describe('League name (optional, helps with accuracy)'),
+        includeOdds: z.boolean().optional().default(true).describe('Include current odds in analysis'),
+    }, async ({ homeTeam, awayTeam, league, includeOdds }) => {
+        try {
+            const result = await performStructuredMatchAnalysis(homeTeam, awayTeam, league);
+            // Format as readable JSON with summary
+            const output = {
+                summary: `${homeTeam} vs ${awayTeam}`,
+                dataQuality: `${result.dataQuality.score}/100`,
+                predictions: {
+                    homeWin: `${(result.predictions.matchResult.homeWin.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.homeWin.low * 100).toFixed(1)}%-${(result.predictions.matchResult.homeWin.high * 100).toFixed(1)}%)`,
+                    draw: `${(result.predictions.matchResult.draw.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.draw.low * 100).toFixed(1)}%-${(result.predictions.matchResult.draw.high * 100).toFixed(1)}%)`,
+                    awayWin: `${(result.predictions.matchResult.awayWin.mid * 100).toFixed(1)}% (${(result.predictions.matchResult.awayWin.low * 100).toFixed(1)}%-${(result.predictions.matchResult.awayWin.high * 100).toFixed(1)}%)`,
+                },
+                valueBets: result.valueBets.length > 0
+                    ? result.valueBets.map(vb => ({
+                        selection: vb.selection,
+                        odds: vb.odds.toFixed(2),
+                        value: `${(vb.value * 100).toFixed(1)}%`,
+                        stake: `${vb.recommendedStake.toFixed(1)}u`
+                    }))
+                    : 'No value bets detected',
+                bestBet: result.verdict.bestBet,
+                confidence: `${result.verdict.confidence}/100`,
+                riskLevel: result.verdict.riskLevel,
+                fullAnalysis: result,
+            };
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true,
+            };
+        }
+    });
+    /**
+     * Tool 3: get_live_scores
      * Get live football scores for a league or team
      */
     server.tool('get_live_scores', `Get live football scores.

package/package.json

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