@gotza02/sequential-thinking 10000.2.0 → 10000.2.2

package/dist/lib.js

@@ -1,10 +1,11 @@
-import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
 import { ContextManager } from './core/ContextManager.js';
 import { RuleManager } from './core/RuleManager.js';
+import { formatThought, generateMermaid } from './lib/formatters.js';
+import { detectLoopsAndStalling, validateSolution, checkAntiInsanity, checkConfidenceCritical, calculateConfidenceScore } from './lib/validators.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     blocks = [];
@@ -390,79 +391,7 @@ export class SequentialThinkingServer {
         }
     }
     formatThought(thoughtData) {
-        const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId, thoughtType, score, options, selectedOption, blockId, relatedToolCall, complexity } = thoughtData;
-        const typeEmoji = {
-            'analysis': '🔍',
-            'planning': '📋',
-            'critique': '😈',
-            'execution': '⚡',
-            'observation': '👁️',
-            'hypothesis': '💡',
-            'reflexion': '🔄',
-            'solution': '✅',
-            'generation': '💭',
-            'evaluation': '⚖️',
-            'selection': '🎯'
-        };
-        let prefix = '';
-        let context = '';
-        const type = thoughtType || 'analysis';
-        const emoji = typeEmoji[type] || '💭';
-        if (type === 'reflexion' || isRevision) {
-            prefix = chalk.yellow(`${emoji} Reflexion`);
-            if (revisesThought)
-                context += ` (revising #${revisesThought})`;
-        }
-        else if (type === 'critique') {
-            prefix = chalk.redBright(`${emoji} Critique`);
-        }
-        else if (type === 'execution') {
-            prefix = chalk.magenta(`${emoji} Execution`);
-            if (relatedToolCall)
-                context += ` [Tool: ${relatedToolCall}]`;
-        }
-        else if (type === 'observation') {
-            prefix = chalk.cyan(`${emoji} Observation`);
-        }
-        else if (type === 'planning') {
-            prefix = chalk.blue(`${emoji} Planning`);
-        }
-        else if (type === 'solution') {
-            prefix = chalk.green(`${emoji} Solution`);
-        }
-        else if (branchFromThought) {
-            prefix = chalk.green(`🌿 Branch`);
-            context = ` (from #${branchFromThought}, ID: ${branchId})`;
-        }
-        else {
-            prefix = chalk.blue(`${emoji} ${type.charAt(0).toUpperCase() + type.slice(1)}`);
-        }
-        if (blockId && blockId !== 'default' && blockId !== 'legacy-default') {
-            context += ` [Block: ${blockId}]`;
-        }
-        if (complexity)
-            context += ` [${complexity.toUpperCase()}]`;
-        if (score)
-            context += ` (Score: ${score})`;
-        if (selectedOption)
-            context += ` (Selected: ${selectedOption})`;
-        const header = `${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
-        const borderLength = Math.max(header.length, Math.min(thought.length, 80)) + 4;
-        const border = '─'.repeat(borderLength);
-        let extraContent = '';
-        if (options && options.length > 0) {
-            extraContent += `\n│ Options:\n` + options.map(o => `│ - ${o}`).join('\n');
-        }
-        // Wrap long thoughts
-        const wrappedThought = thought.length > 76
-            ? thought.match(/.{1,76}/g)?.map(line => `│ ${line.padEnd(borderLength - 2)} │`).join('\n') || thought
-            : `│ ${thought.padEnd(borderLength - 2)} │`;
-        return `
-┌${border}┐
-│ ${header.padEnd(borderLength - 2)} │
-├${border}┤
-${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrappedThought : `│ ${thought.padEnd(borderLength - 2)} │`}${extraContent}
-└${border}┘`;
+        return formatThought(thoughtData);
     }
     // --- Extracted Helper Methods for processThought ---
     /**
@@ -515,102 +444,24 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Detect loops, stalling, and other thinking pattern issues
      */
     detectLoopsAndStalling(input, blockThoughts, recentInBlock, lastThought, complexity) {
-        const warnings = [];
-        let isStallingOrLooping = false;
-        const thinkingTypes = ['analysis', 'planning', 'hypothesis', 'generation', 'critique'];
-        // Rule 1: Stalling Detection (Adaptive)
-        if (complexity !== 'low') {
-            if (recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
-                recentInBlock.every(t => thinkingTypes.includes(t.thoughtType || 'analysis')) &&
-                thinkingTypes.includes(input.thoughtType || 'analysis')) {
-                warnings.push(`⚠️ STALLING DETECTED: You have been thinking for 4 consecutive steps without execution. Consider changing thoughtType to 'execution' and calling a tool to make progress.`);
-                isStallingOrLooping = true;
-            }
-        }
-        // Rule 2: Repeating Action Detection
-        if (input.thoughtType === 'execution') {
-            // Check Immune System Rules
-            const ruleWarnings = this.ruleManager.checkRules(input.thought);
-            ruleWarnings.forEach(w => warnings.push(w));
-            if (recentInBlock.some(t => t.thoughtType === 'execution' && t.thought === input.thought)) {
-                warnings.push(`🛑 LOOP DETECTED: You are attempting to execute the exact same action again. You MUST change your strategy or create a branch with a different approach.`);
-                isStallingOrLooping = true;
-            }
-        }
-        // Rule 3: Missing Observation
-        if (lastThought &&
-            lastThought.thoughtType === 'execution' &&
-            input.thoughtType !== 'observation' &&
-            !input.branchFromThought) {
-            warnings.push(`💡 INTERLEAVED HINT: Your last step was 'execution'. The next step SHOULD be 'observation' to record and analyze the tool result before continuing.`);
-        }
-        // Rule 4: Skipping Planning (Adaptive)
-        if (complexity !== 'low') {
-            const hasPlanning = blockThoughts.some(t => t.thoughtType === 'planning');
-            if (!hasPlanning &&
-                blockThoughts.length >= 2 &&
-                input.thoughtType === 'execution') {
-                warnings.push(`📋 PLANNING HINT: You're about to execute without a planning step. Consider adding a 'planning' thought first to outline your approach.`);
-            }
-        }
-        // Rule 5: Devil's Advocate (Critique Phase)
-        if (complexity === 'high' && input.thoughtType === 'execution') {
-            const hasCritique = blockThoughts.some(t => t.thoughtType === 'critique');
-            if (!hasCritique) {
-                warnings.push(`🛑 CRITIQUE REQUIRED: High complexity task requires a 'critique' step before execution. Analyze risks and flaws in your plan first.`);
-            }
-        }
-        // Rule 6: Ending without Verification
-        if (input.nextThoughtNeeded === false) {
-            const hasVerification = this.thoughtHistory.some(t => t.thought.toLowerCase().includes('test') ||
-                t.thought.toLowerCase().includes('verify') ||
-                t.thought.toLowerCase().includes('check') ||
-                t.thoughtType === 'observation');
-            if (!hasVerification) {
-                warnings.push(`🚨 CRITICAL: You are ending without explicit verification/testing. Consider adding an 'observation' or verification step.`);
-            }
-        }
-        // Rule 7: Same type loop
-        if (complexity !== 'low' && recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
-            recentInBlock.every(t => t.thoughtType === input.thoughtType)) {
-            warnings.push(`⚠️ TYPE LOOP: You've used '${input.thoughtType}' for 4 consecutive steps. Consider using a different thought type to progress.`);
-        }
-        // Rule 8: Struggle Detection
-        const executionCount = blockThoughts.filter(t => t.thoughtType === 'execution').length;
-        if (executionCount >= SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD && input.thoughtType === 'execution') {
-            warnings.push(`🛑 STRUGGLE DETECTED: You have executed ${SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD}+ commands in this block without reaching a solution. If you are fixing a bug and it's not working, STOP. Do not try a 4th time linearly. Use 'branchFromThought' to try a completely different approach.`);
-        }
-        // Rule 9: Premature Solution Detection
-        const hasObservation = blockThoughts.some(t => t.thoughtType === 'observation');
-        if (input.thoughtType === 'solution' && !hasObservation && blockThoughts.length < 4 && complexity !== 'low') {
-            warnings.push(`🤔 PREMATURE SOLUTION: You are concluding this block very quickly without any 'observation'. Are you hallucinating? Please verify with a tool first.`);
-        }
-        return { isStallingOrLooping, warnings };
+        return detectLoopsAndStalling(input, {
+            thoughtHistory: this.thoughtHistory,
+            blockThoughts,
+            recentInBlock,
+            lastThought,
+            complexity
+        }, (thought) => this.ruleManager.checkRules(thought));
     }
     /**
      * Validate solution before accepting
      */
     async validateSolution(input, blockThoughts, complexity, warnings) {
-        const observations = blockThoughts.filter(t => t.thoughtType === 'observation');
-        if (observations.length === 0) {
-            warnings.push(`🚫 UNVERIFIED SOLUTION: You are attempting to solve without ANY observation/tool output in this block.`);
-        }
-        else {
-            const lastObservation = observations[observations.length - 1];
-            const failureKeywords = ['error', 'fail', 'exception', 'undefined', 'not found', 'enoent'];
-            const hasFailure = failureKeywords.some(kw => lastObservation.toolResult?.toLowerCase().includes(kw));
-            if (hasFailure) {
-                warnings.push(`⚠️ FAILURE DETECTED: The last observation contains failure signals ("${lastObservation.toolResult?.substring(0, 50)}..."). Fix the error first.`);
-            }
-            // Smart Search Verification
-            const searchTools = ['web_search', 'google_web_search', 'read_webpage', 'search_file_content', 'google_search'];
-            const isSearch = lastObservation.relatedToolCall && searchTools.some(tool => lastObservation.relatedToolCall.includes(tool));
-            if (isSearch) {
-                warnings.push(`🕵️ DATA INTEGRITY CHECK: You are concluding a search task. Verify: Did you actually find the specific answer?`);
-            }
-            // Double Verification for High Complexity
-            if (complexity === 'high' && observations.length < 2) {
-                warnings.push(`⚖️ DOUBLE VERIFICATION REQUIRED: High complexity tasks require at least 2 distinct observations/verifications before conclusion.`);
+        const validationWarnings = validateSolution(input, blockThoughts, complexity);
+        warnings.push(...validationWarnings);
+        // Handle high complexity double verification penalty
+        if (complexity === 'high') {
+            const observations = blockThoughts.filter(t => t.thoughtType === 'observation');
+            if (observations.length < 2 && validationWarnings.some(w => w.includes('DOUBLE VERIFICATION'))) {
                 this.confidenceScore -= 10;
             }
         }
@@ -628,23 +479,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Update confidence score based on thought type and warnings
      */
     updateConfidenceScore(input, warnings) {
-        if (warnings.length > 0) {
-            this.confidenceScore = Math.max(0, this.confidenceScore - (5 * warnings.length));
-        }
-        if (input.thoughtType === 'reflexion') {
-            this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-        }
-        else if (input.thoughtType === 'observation') {
-            const isError = input.toolResult?.toLowerCase().includes('error');
-            if (isError)
-                this.confidenceScore -= 10;
-            else
-                this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-        }
-        else if (input.thoughtType === 'solution' && warnings.length === 0) {
-            // Bonus for clean solution
-            this.confidenceScore = Math.min(100, this.confidenceScore + 20);
-        }
+        this.confidenceScore = calculateConfidenceScore(this.confidenceScore, input, warnings.length);
     }
     // --- Helper Methods for processThought ---
     /**
@@ -680,27 +515,10 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Check anti-insanity - prevent repeating failed executions
      */
     checkAntiInsanity(input, historyForCheck) {
-        const warnings = [];
-        if (input.thoughtType === 'execution') {
-            const failedExecutions = historyForCheck.filter(t => {
-                if (t.thoughtType !== 'execution')
-                    return false;
-                // Find the observation immediately following this execution
-                const nextThought = this.thoughtHistory.find(h => h.thoughtNumber === t.thoughtNumber + 1);
-                if (nextThought && nextThought.thoughtType === 'observation') {
-                    const result = nextThought.toolResult?.toLowerCase() || "";
-                    // Check for failure signals
-                    return result.includes("error") || result.includes("fail") ||
-                        result.includes("exception") || result.includes("enoent");
-                }
-                return false;
-            });
-            const isRepeatedFailure = failedExecutions.some(t => t.thought.trim() === input.thought.trim());
-            if (isRepeatedFailure) {
-                const failedItem = failedExecutions.find(t => t.thought.trim() === input.thought.trim());
-                warnings.push(`⛔ INSANITY CHECK: You are trying to run a command that ALREADY FAILED in thought #${failedItem?.thoughtNumber}. STOP. Do not repeat mistakes. Try a different parameter or tool.`);
-                this.confidenceScore -= 15;
-            }
+        const warnings = checkAntiInsanity(input, historyForCheck, this.thoughtHistory);
+        // Apply confidence penalty for repeated failures
+        if (warnings.some(w => w.includes('INSANITY CHECK'))) {
+            this.confidenceScore -= 15;
         }
         return warnings;
     }
@@ -708,36 +526,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Check if confidence is critical and return critical stop response if needed
      */
     checkConfidenceCritical(input, historyForCheck) {
-        if (this.confidenceScore >= SequentialThinkingServer.CONFIDENCE_CRITICAL_THRESHOLD ||
-            input.thoughtType === 'reflexion' ||
-            input.thoughtType === 'analysis') {
-            return null;
-        }
-        // Smart Branching: Find the last valid planning point
-        const lastGoodPlan = historyForCheck
-            .slice()
-            .reverse()
-            .find(t => t.thoughtType === 'planning' || t.thoughtType === 'hypothesis');
-        const recoveryAdvice = lastGoodPlan
-            ? `RECOMMENDATION: Branch from thought #${lastGoodPlan.thoughtNumber} to try a new approach.`
-            : `RECOMMENDATION: Use 'reflexion' to analyze why current attempts are failing.`;
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        status: "CRITICAL_STOP",
-                        feedback: [
-                            "🚨 CONFIDENCE CRITICAL (<50). Execution blocked to prevent further damage.",
-                            "🛑 STOP: You are likely in a loop or making repeated errors.",
-                            "👉 REQUIRED ACTION: You must switch thoughtType to 'reflexion' to critique your errors.",
-                            "⚠️ REMEMBER: You MUST provide a 'thought' string explaining your reflection. Do not leave it empty.",
-                            recoveryAdvice
-                        ],
-                        confidenceScore: this.confidenceScore
-                    }, null, 2)
-                }],
-            isError: true
-        };
+        return checkConfidenceCritical(this.confidenceScore, input, historyForCheck);
     }
     // --- 2. The New Brain: Process Thought with Interleaved Logic (Opus 4.5 Style) ---
     async processThought(input) {
@@ -847,38 +636,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
         return 'THINKING';
     }
     generateMermaid() {
-        let diagram = 'graph TD\n';
-        const recentThoughts = this.thoughtHistory.slice(-15); // Last 15 for readability
-        recentThoughts.forEach((t, i) => {
-            const id = `T${t.thoughtNumber}`;
-            const typeIcon = {
-                'analysis': '🔍',
-                'planning': '📋',
-                'critique': '😈',
-                'execution': '⚡',
-                'observation': '👁️',
-                'hypothesis': '💡',
-                'reflexion': '🔄',
-                'solution': '✅',
-                'generation': '💭',
-                'evaluation': '⚖️',
-                'selection': '🎯'
-            }[t.thoughtType || 'analysis'] || '💭';
-            const label = `${typeIcon} ${t.thoughtNumber}`;
-            diagram += `  ${id}("${label}")\n`;
-            if (i > 0) {
-                const prevT = recentThoughts[i - 1];
-                const prevId = `T${prevT.thoughtNumber}`;
-                if (t.branchFromThought) {
-                    diagram += `  T${t.branchFromThought} -->|branch: ${t.branchId}| ${id}\n`;
-                }
-                else {
-                    const edgeLabel = t.thoughtType === 'observation' ? '|result|' : '';
-                    diagram += `  ${prevId} -->${edgeLabel} ${id}\n`;
-                }
-            }
-        });
-        return diagram;
+        return generateMermaid(this.thoughtHistory);
     }
     // Public method to start a new block explicitly
     startNewBlock(blockId, topic) {

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

@@ -73,7 +73,8 @@ export declare abstract class APIProviderBase implements IDataProvider {
     protected rateLimitUntil: Date | null;
     protected lastCall: Date | null;
     protected callCount: number;
-    constructor(type: ProviderType, apiKey: string, baseUrl: string, rateLimit?: number);
+    constructor(type: ProviderType, apiKey: string, baseUrl: string, rateLimit?: number, // calls per minute
+    cache?: CacheService);
     /**
      * Check if provider has valid credentials
      */
@@ -131,7 +132,7 @@ export declare abstract class APIProviderBase implements IDataProvider {
 export declare abstract class ScraperProviderBase implements IDataProvider {
     protected cache: CacheService;
     readonly type: ProviderType;
-    constructor();
+    constructor(cache?: CacheService);
     isAvailable(): boolean;
     getStatus(): ProviderStatus;
     abstract getMatch(matchId: string): Promise<APIResponse<Match>>;

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

@@ -2,7 +2,7 @@
  * SPORTS MODULE BASE CLASSES
  * Abstract base classes and interfaces for data providers
  */
-import { CacheService } from './cache.js';
+import { CacheService, getGlobalCache } from './cache.js';
 import { logger } from '../../../utils.js';
 /**
  * Abstract base class for API-based providers
@@ -16,13 +16,13 @@ export class APIProviderBase {
     rateLimitUntil = null;
     lastCall = null;
     callCount = 0;
-    constructor(type, apiKey, baseUrl, rateLimit = 10 // calls per minute
-    ) {
+    constructor(type, apiKey, baseUrl, rateLimit = 10, // calls per minute
+    cache) {
         this.type = type;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.rateLimit = rateLimit;
-        this.cache = new CacheService();
+        this.cache = cache || getGlobalCache();
     }
     /**
      * Check if provider has valid credentials
@@ -86,7 +86,9 @@ export class APIProviderBase {
                 // Handle rate limiting
                 if (response.status === 429) {
                     const retryAfter = response.headers.get('Retry-After');
-                    this.rateLimitUntil = new Date(Date.now() + (retryAfter ? parseInt(retryAfter) * 1000 : 60000));
+                    const retrySeconds = retryAfter ? parseInt(retryAfter, 10) : NaN;
+                    const delayMs = isNaN(retrySeconds) ? 60000 : retrySeconds * 1000;
+                    this.rateLimitUntil = new Date(Date.now() + delayMs);
                     return {
                         success: false,
                         error: 'Rate limited',
@@ -127,8 +129,8 @@ export class APIProviderBase {
 export class ScraperProviderBase {
     cache;
     type = 'scraper';
-    constructor() {
-        this.cache = new CacheService();
+    constructor(cache) {
+        this.cache = cache || getGlobalCache();
     }
     isAvailable() {
         return true; // Scraping is always "available"
@@ -181,8 +183,8 @@ export class ScraperProviderBase {
 export class FallbackProvider {
     providers;
     cache;
-    type = 'scraper';
-    constructor(providers, cache = new CacheService()) {
+    type = 'api-football'; // Most common API type
+    constructor(providers, cache = getGlobalCache()) {
         this.providers = providers;
         this.cache = cache;
     }
@@ -275,7 +277,7 @@ export class FallbackProvider {
 export class SportsToolBase {
     cache;
     constructor(cache) {
-        this.cache = cache || new CacheService();
+        this.cache = cache || getGlobalCache();
     }
     /**
      * Format error message for user

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

@@ -12,7 +12,12 @@ export declare class CacheService {
     private maxSize;
     private savePending;
     private saveTimer;
+    cleanupInterval: NodeJS.Timeout | null;
     constructor(cachePath?: string, maxAge?: number, maxSize?: number);
+    /**
+     * Initialize cache - must be called after construction
+     */
+    initialize(): Promise<void>;
     /**
      * Generate a cache key from components
      */
@@ -37,6 +42,10 @@ export declare class CacheService {
      * Clear all cache entries
      */
     clear(): void;
+    /**
+     * Stop cleanup interval and clear all resources
+     */
+    dispose(): void;
     /**
      * Get cache statistics
      */

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

@@ -16,11 +16,17 @@ export class CacheService {
     maxSize;
     savePending = false;
     saveTimer = null;
+    cleanupInterval = null;
     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.maxSize = maxSize;
-        this.loadFromFile();
+    }
+    /**
+     * Initialize cache - must be called after construction
+     */
+    async initialize() {
+        await this.loadFromFile();
     }
     /**
      * Generate a cache key from components
@@ -95,6 +101,20 @@ export class CacheService {
         logger.info('Cache cleared');
         this.scheduleSave();
     }
+    /**
+     * Stop cleanup interval and clear all resources
+     */
+    dispose() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        if (this.saveTimer) {
+            clearTimeout(this.saveTimer);
+            this.saveTimer = null;
+        }
+        this.cache.clear();
+    }
     /**
      * Get cache statistics
      */
@@ -288,8 +308,10 @@ let globalCache = null;
 export function getGlobalCache() {
     if (!globalCache) {
         globalCache = new CacheService();
+        // Initialize async (fire and forget - will be ready on next tick)
+        globalCache.initialize().catch(err => logger.error('Cache init failed:', err));
         // Cleanup expired entries every 5 minutes
-        setInterval(() => {
+        globalCache.cleanupInterval = setInterval(() => {
             globalCache?.cleanup();
         }, 5 * 60 * 1000);
     }
@@ -300,7 +322,7 @@ export function getGlobalCache() {
  */
 export function resetGlobalCache() {
     if (globalCache) {
-        globalCache.clear();
+        globalCache.dispose();
     }
     globalCache = null;
 }

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

@@ -138,7 +138,9 @@ export interface TableEntry {
         drawn: number;
         lost: number;
         goalsFor: number;
-        against: number;
+        goalsAgainst: number;
+        /** @deprecated Use goalsAgainst instead */
+        against?: number;
     };
     awayRecord?: {
         played: number;
@@ -146,7 +148,9 @@ export interface TableEntry {
         drawn: number;
         lost: number;
         goalsFor: number;
-        against: number;
+        goalsAgainst: number;
+        /** @deprecated Use goalsAgainst instead */
+        against?: number;
     };
     lastFive?: {
         result: 'W' | 'D' | 'L';

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

@@ -61,6 +61,10 @@ export declare class FootballDataProvider extends APIProviderBase {
 export declare class SportsDBProvider extends APIProviderBase {
     constructor();
     protected getAuthHeaders(): Record<string, string>;
+    /**
+     * Override callAPI to inject API key in URL for TheSportsDB
+     */
+    protected callAPI<T>(endpoint: string, options?: RequestInit): Promise<APIResponse<T>>;
     protected transformResponse<T>(data: any): T;
     getMatch(matchId: string): Promise<APIResponse<Match>>;
     getLiveMatches(): Promise<APIResponse<Match[]>>;