@gotza02/sequential-thinking 10000.1.2 → 10000.1.3

package/dist/tools/sports/core/ml-prediction.js

@@ -1,260 +0,0 @@
-/**
- * ML PREDICTION ENGINE
- */
-import { ML_CONFIG } from './constants.js';
-// Simple logger fallback
-const logger = {
-    info: (...args) => console.error('[INFO]', ...args),
-    warn: (...args) => console.warn('[WARN]', ...args),
-    error: (...args) => console.error('[ERROR]', ...args),
-    debug: (...args) => { }
-};
-export class MLPredictionEngine {
-    weights = ML_CONFIG.FEATURE_WEIGHTS;
-    historicalData = new Map();
-    async predict(input) {
-        const factors = [];
-        const formScore = this.calculateFormScore(input);
-        factors.push({
-            name: 'Recent Form',
-            weight: this.weights.form,
-            impact: formScore > 0 ? 'positive' : formScore < 0 ? 'negative' : 'neutral',
-            description: this.describeFormImpact(input),
-        });
-        const h2hScore = this.calculateH2HScore(input);
-        factors.push({
-            name: 'Head-to-Head',
-            weight: this.weights.h2h,
-            impact: h2hScore > 0 ? 'positive' : h2hScore < 0 ? 'negative' : 'neutral',
-            description: this.describeH2HImpact(input),
-        });
-        const homeAdvantageScore = this.calculateHomeAdvantage(input);
-        factors.push({
-            name: 'Home Advantage',
-            weight: this.weights.home_advantage,
-            impact: homeAdvantageScore > 0 ? 'positive' : 'neutral',
-            description: `Home advantage factor: ${(homeAdvantageScore * 100).toFixed(1)}%`,
-        });
-        const xgScore = this.calculateXgScore(input);
-        factors.push({
-            name: 'Expected Goals (xG)',
-            weight: this.weights.xg,
-            impact: xgScore > 0 ? 'positive' : xgScore < 0 ? 'negative' : 'neutral',
-            description: `xG differential: ${(xgScore * 100).toFixed(1)}%`,
-        });
-        const injuryScore = this.calculateInjuryImpact(input);
-        factors.push({
-            name: 'Injuries',
-            weight: this.weights.injuries,
-            impact: injuryScore > 0 ? 'positive' : injuryScore < 0 ? 'negative' : 'neutral',
-            description: this.describeInjuryImpact(input),
-        });
-        const fatigueScore = this.calculateFatigueImpact(input);
-        factors.push({
-            name: 'Fatigue',
-            weight: this.weights.fatigue,
-            impact: fatigueScore > 0 ? 'positive' : fatigueScore < 0 ? 'negative' : 'neutral',
-            description: `Fatigue differential: ${(fatigueScore * 100).toFixed(1)}%`,
-        });
-        const weatherScore = this.calculateWeatherImpact(input);
-        factors.push({
-            name: 'Weather',
-            weight: this.weights.weather,
-            impact: weatherScore !== 0 ? (weatherScore > 0 ? 'positive' : 'negative') : 'neutral',
-            description: this.describeWeatherImpact(input),
-        });
-        const combinedScore = this.combineScores([
-            { score: formScore, weight: this.weights.form },
-            { score: h2hScore, weight: this.weights.h2h },
-            { score: homeAdvantageScore, weight: this.weights.home_advantage },
-            { score: xgScore, weight: this.weights.xg },
-            { score: injuryScore, weight: this.weights.injuries },
-            { score: fatigueScore, weight: this.weights.fatigue },
-            { score: weatherScore, weight: this.weights.weather },
-        ]);
-        const probabilities = this.scoreToProbabilities(combinedScore);
-        const confidence = this.calculateConfidence(factors, input);
-        const over25Prob = this.predictOver25(input);
-        const bttsProb = this.predictBTTS(input);
-        logger.info(`[MLPrediction] ${input.match.homeTeam.name} vs ${input.match.awayTeam.name}: ` +
-            `H:${(probabilities.home * 100).toFixed(1)}% D:${(probabilities.draw * 100).toFixed(1)}% A:${(probabilities.away * 100).toFixed(1)}%`);
-        return {
-            homeWin: probabilities.home,
-            draw: probabilities.draw,
-            awayWin: probabilities.away,
-            over25: over25Prob,
-            btts: bttsProb,
-            confidence,
-            factors,
-        };
-    }
-    calculateFormScore(input) {
-        const homePoints = this.formToPoints(input.homeForm.last5);
-        const awayPoints = this.formToPoints(input.awayForm.last5);
-        const maxPoints = 15;
-        const homeNormalized = (homePoints / maxPoints) * 2 - 1;
-        const awayNormalized = (awayPoints / maxPoints) * 2 - 1;
-        return homeNormalized - awayNormalized;
-    }
-    formToPoints(form) {
-        return form.reduce((sum, result) => {
-            if (result === 'W')
-                return sum + 3;
-            if (result === 'D')
-                return sum + 1;
-            return sum;
-        }, 0);
-    }
-    calculateH2HScore(input) {
-        const h2h = input.h2h;
-        const total = h2h.totalMatches;
-        if (total === 0)
-            return 0;
-        const homeWinRate = h2h.homeWins / total;
-        const awayWinRate = h2h.awayWins / total;
-        const recentScore = h2h.recentMatches.slice(0, 5).reduce((score, match, index) => {
-            const weight = (5 - index) / 5;
-            if (match.score) {
-                if (match.score.home > match.score.away)
-                    return score + weight;
-                if (match.score.home < match.score.away)
-                    return score - weight;
-            }
-            return score;
-        }, 0);
-        const historicalScore = homeWinRate - awayWinRate;
-        return Math.max(-1, Math.min(1, (historicalScore * 0.4) + (recentScore / 5 * 0.6)));
-    }
-    calculateHomeAdvantage(input) {
-        const homeStats = input.homeStats;
-        const awayStats = input.awayStats;
-        if (!homeStats?.homeStats || !awayStats?.awayStats)
-            return 0.1;
-        const homeWinRate = homeStats.homeStats.wins / (homeStats.homeStats.matchesPlayed || 1);
-        const awayWinRate = awayStats.awayStats.wins / (awayStats.awayStats.matchesPlayed || 1);
-        return Math.max(0, homeWinRate - awayWinRate);
-    }
-    calculateXgScore(input) {
-        const homeXgDiff = input.homeForm.xG - input.homeForm.xGA;
-        const awayXgDiff = input.awayForm.xG - input.awayForm.xGA;
-        return Math.max(-1, Math.min(1, (homeXgDiff - awayXgDiff) / 2));
-    }
-    calculateInjuryImpact(input) {
-        const impact = (input.injuries.away.keyPlayers - input.injuries.home.keyPlayers) * 0.1;
-        return Math.max(-1, Math.min(1, impact));
-    }
-    calculateFatigueImpact(input) {
-        const diff = input.awayStats.matchesPlayed - input.homeStats.matchesPlayed;
-        return Math.max(-1, Math.min(1, diff * 0.02));
-    }
-    calculateWeatherImpact(input) {
-        if (!input.weather)
-            return 0;
-        let impact = 0;
-        if (input.weather.precipitation)
-            impact -= 0.1;
-        if (input.weather.windSpeed > 20)
-            impact -= 0.1;
-        if (input.weather.temperature > 30 || input.weather.temperature < 0)
-            impact -= 0.05;
-        return impact;
-    }
-    combineScores(scores) {
-        const totalWeight = scores.reduce((sum, s) => sum + s.weight, 0);
-        const weightedSum = scores.reduce((sum, s) => sum + (s.score * s.weight), 0);
-        return weightedSum / totalWeight;
-    }
-    scoreToProbabilities(score) {
-        const homeExp = Math.exp(score * 2);
-        const drawExp = Math.exp(0);
-        const awayExp = Math.exp(-score * 2);
-        const total = homeExp + drawExp + awayExp;
-        return { home: homeExp / total, draw: drawExp / total, away: awayExp / total };
-    }
-    calculateConfidence(factors, input) {
-        let confidence = 50;
-        if (input.homeForm.last5.length >= 5)
-            confidence += 10;
-        if (input.awayForm.last5.length >= 5)
-            confidence += 10;
-        if (input.h2h.totalMatches >= 3)
-            confidence += 10;
-        const highImpactFactors = factors.filter(f => Math.abs(f.weight) > 0.15 && f.impact !== 'neutral').length;
-        confidence += highImpactFactors * 5;
-        return Math.min(95, confidence);
-    }
-    predictOver25(input) {
-        const expectedGoals = (input.homeForm.xG / 5 + input.awayForm.xGA / 5 + input.awayForm.xG / 5 + input.homeForm.xGA / 5) / 2;
-        return Math.min(0.9, Math.max(0.1, expectedGoals / 3));
-    }
-    predictBTTS(input) {
-        const homeScoring = input.homeForm.goalsFor / 5;
-        const awayScoring = input.awayForm.goalsFor / 5;
-        const homeLikelyToScore = homeScoring > 1 ? 0.7 : homeScoring > 0.5 ? 0.5 : 0.3;
-        const awayLikelyToScore = awayScoring > 1 ? 0.7 : awayScoring > 0.5 ? 0.5 : 0.3;
-        return homeLikelyToScore * awayLikelyToScore;
-    }
-    describeFormImpact(input) {
-        const homePoints = this.formToPoints(input.homeForm.last5);
-        const awayPoints = this.formToPoints(input.awayForm.last5);
-        if (homePoints > awayPoints + 4)
-            return `${input.match.homeTeam.name} in significantly better form`;
-        if (awayPoints > homePoints + 4)
-            return `${input.match.awayTeam.name} in significantly better form`;
-        if (Math.abs(homePoints - awayPoints) <= 2)
-            return 'Teams in similar form';
-        return 'Form advantage detected';
-    }
-    describeH2HImpact(input) {
-        const h2h = input.h2h;
-        if (h2h.totalMatches === 0)
-            return 'No recent head-to-head data';
-        const homeWinRate = (h2h.homeWins / h2h.totalMatches * 100).toFixed(0);
-        return `${input.match.homeTeam.name} won ${homeWinRate}% of ${h2h.totalMatches} meetings`;
-    }
-    describeInjuryImpact(input) {
-        const homeKey = input.injuries.home.keyPlayers;
-        const awayKey = input.injuries.away.keyPlayers;
-        if (homeKey === 0 && awayKey === 0)
-            return 'No key injuries for either team';
-        if (homeKey > awayKey)
-            return `${input.match.homeTeam.name} has ${homeKey} key player(s) injured`;
-        if (awayKey > homeKey)
-            return `${input.match.awayTeam.name} has ${awayKey} key player(s) injured`;
-        return 'Both teams have similar injury concerns';
-    }
-    describeWeatherImpact(input) {
-        if (!input.weather)
-            return 'Weather data not available';
-        const conditions = [];
-        if (input.weather.precipitation)
-            conditions.push('rain');
-        if (input.weather.windSpeed > 20)
-            conditions.push('high wind');
-        if (input.weather.temperature > 30)
-            conditions.push('hot');
-        if (input.weather.temperature < 5)
-            conditions.push('cold');
-        if (conditions.length === 0)
-            return 'Good weather conditions';
-        return `Adverse conditions: ${conditions.join(', ')}`;
-    }
-    learnFromResult(prediction, actualResult, odds) {
-        const predictedOutcome = prediction.homeWin > prediction.draw && prediction.homeWin > prediction.awayWin
-            ? 'home' : prediction.awayWin > prediction.draw ? 'away' : 'draw';
-        const wasCorrect = predictedOutcome === actualResult;
-        if (wasCorrect) {
-            logger.info(`[MLPrediction] Correct prediction at ${odds}x`);
-        }
-        else {
-            logger.info(`[MLPrediction] Incorrect prediction. Predicted: ${predictedOutcome}, Actual: ${actualResult}`);
-        }
-        this.historicalData.set(`result-${Date.now()}`, { prediction, actualResult, odds, wasCorrect, timestamp: Date.now() });
-    }
-}
-let globalPredictionEngine = null;
-export function getPredictionEngine() {
-    if (!globalPredictionEngine)
-        globalPredictionEngine = new MLPredictionEngine();
-    return globalPredictionEngine;
-}

package/dist/tools/sports/core/realtime-manager.d.ts

@@ -1,51 +0,0 @@
-/**
- * REALTIME DATA MANAGER
- * Polling-based real-time data streaming
- */
-import { EventEmitter } from 'events';
-import type { Match } from './types.js';
-export interface LiveEvent {
-    type: 'goal' | 'card' | 'substitution' | 'var' | 'injury' | 'whistle' | 'odds_change' | 'status_change';
-    matchId: string;
-    timestamp: number;
-    minute?: number;
-    data: any;
-}
-export interface OddsChangeEvent extends LiveEvent {
-    type: 'odds_change';
-    data: {
-        bookmaker: string;
-        market: string;
-        selection: string;
-        oldOdds: number;
-        newOdds: number;
-        change: number;
-        timestamp: number;
-    };
-}
-export declare class RealtimeDataManager extends EventEmitter {
-    private cache;
-    private pollingIntervals;
-    private isRunning;
-    constructor();
-    start(): Promise<void>;
-    stop(): void;
-    subscribeToMatch(matchId: string, callback: (event: LiveEvent) => void): () => void;
-    subscribeToOdds(matchId: string, callback: (event: OddsChangeEvent) => void): () => void;
-    subscribeToAllEvents(callback: (event: LiveEvent) => void): () => void;
-    processEvent(event: LiveEvent): void;
-    getLiveMatches(): Match[];
-    getMatchEvents(matchId: string): LiveEvent[];
-    private unsubscribeFromMatch;
-    private startLiveScoresPolling;
-    private startOddsPolling;
-    private startMatchEventsPolling;
-    private detectScoreChanges;
-    private detectOddsChanges;
-    private updateCache;
-    private fetchLiveScores;
-    private fetchOdds;
-    private fetchMatchEvents;
-}
-export declare function getRealtimeManager(): RealtimeDataManager;
-export declare function resetRealtimeManager(): void;

package/dist/tools/sports/core/realtime-manager.js

@@ -1,222 +0,0 @@
-/**
- * REALTIME DATA MANAGER
- * Polling-based real-time data streaming
- */
-import { EventEmitter } from 'events';
-import { CacheService } from './cache.js';
-import { REALTIME_CONFIG, CACHE_CONFIG } from './constants.js';
-// Simple logger fallback
-const logger = {
-    info: (...args) => console.error('[INFO]', ...args),
-    warn: (...args) => console.warn('[WARN]', ...args),
-    error: (...args) => console.error('[ERROR]', ...args),
-    debug: (...args) => { }
-};
-export class RealtimeDataManager extends EventEmitter {
-    cache;
-    pollingIntervals = new Map();
-    isRunning = false;
-    constructor() {
-        super();
-        this.cache = new CacheService();
-        this.setMaxListeners(100);
-    }
-    async start() {
-        if (this.isRunning)
-            return;
-        this.isRunning = true;
-        logger.info('[RealtimeManager] Started');
-        this.startLiveScoresPolling();
-        this.startOddsPolling();
-    }
-    stop() {
-        this.isRunning = false;
-        for (const [key, interval] of this.pollingIntervals.entries()) {
-            clearInterval(interval);
-        }
-        this.pollingIntervals.clear();
-        logger.info('[RealtimeManager] Stopped');
-    }
-    subscribeToMatch(matchId, callback) {
-        const eventName = `match:${matchId}`;
-        this.on(eventName, callback);
-        this.startMatchEventsPolling(matchId);
-        return () => {
-            this.off(eventName, callback);
-            this.unsubscribeFromMatch(matchId);
-        };
-    }
-    subscribeToOdds(matchId, callback) {
-        const eventName = `odds:${matchId}`;
-        this.on(eventName, callback);
-        return () => this.off(eventName, callback);
-    }
-    subscribeToAllEvents(callback) {
-        this.on('event', callback);
-        return () => this.off('event', callback);
-    }
-    processEvent(event) {
-        this.updateCache(event);
-        this.emit(`match:${event.matchId}`, event);
-        if (event.type === 'odds_change') {
-            this.emit(`odds:${event.matchId}`, event);
-        }
-        this.emit('event', event);
-    }
-    getLiveMatches() {
-        const cached = this.cache.get('live:all');
-        return cached || [];
-    }
-    getMatchEvents(matchId) {
-        const cached = this.cache.get(`events:${matchId}`);
-        return cached || [];
-    }
-    unsubscribeFromMatch(matchId) {
-        const listenerCount = this.listenerCount(`match:${matchId}`);
-        if (listenerCount === 0) {
-            const interval = this.pollingIntervals.get(`events:${matchId}`);
-            if (interval) {
-                clearInterval(interval);
-                this.pollingIntervals.delete(`events:${matchId}`);
-            }
-        }
-    }
-    startLiveScoresPolling() {
-        const interval = setInterval(async () => {
-            if (!this.isRunning)
-                return;
-            try {
-                const liveScores = await this.fetchLiveScores();
-                this.cache.set('live:all', liveScores, CACHE_CONFIG.TTL.LIVE_SCORES);
-                this.emit('live_scores', liveScores);
-                this.detectScoreChanges(liveScores);
-            }
-            catch (error) {
-                logger.error('[Realtime] Failed to fetch live scores:', error);
-            }
-        }, REALTIME_CONFIG.POLLING_INTERVALS.LIVE_SCORES);
-        this.pollingIntervals.set('live_scores', interval);
-    }
-    startOddsPolling() {
-        const interval = setInterval(async () => {
-            if (!this.isRunning)
-                return;
-            try {
-                const liveMatches = this.getLiveMatches();
-                for (const match of liveMatches) {
-                    const odds = await this.fetchOdds(match.id);
-                    if (odds) {
-                        const cachedOdds = this.cache.get(`odds:${match.id}`);
-                        if (cachedOdds) {
-                            this.detectOddsChanges(match.id, cachedOdds, odds);
-                        }
-                        this.cache.set(`odds:${match.id}`, odds, CACHE_CONFIG.TTL.ODDS);
-                    }
-                }
-            }
-            catch (error) {
-                logger.error('[Realtime] Failed to fetch odds:', error);
-            }
-        }, REALTIME_CONFIG.POLLING_INTERVALS.ODDS);
-        this.pollingIntervals.set('odds', interval);
-    }
-    startMatchEventsPolling(matchId) {
-        if (this.pollingIntervals.has(`events:${matchId}`))
-            return;
-        const interval = setInterval(async () => {
-            if (!this.isRunning)
-                return;
-            try {
-                const events = await this.fetchMatchEvents(matchId);
-                const cachedEvents = this.getMatchEvents(matchId);
-                const newEvents = events.filter(e => !cachedEvents.some(ce => ce.timestamp === e.timestamp && ce.type === e.type));
-                for (const event of newEvents) {
-                    this.processEvent(event);
-                }
-            }
-            catch (error) {
-                logger.error(`[Realtime] Failed to fetch events for match ${matchId}:`, error);
-            }
-        }, REALTIME_CONFIG.POLLING_INTERVALS.MATCH_EVENTS);
-        this.pollingIntervals.set(`events:${matchId}`, interval);
-    }
-    detectScoreChanges(matches) {
-        for (const match of matches) {
-            const cachedMatch = this.cache.get(`match:${match.id}`);
-            if (cachedMatch && cachedMatch.score && match.score) {
-                if (match.score.home > cachedMatch.score.home) {
-                    this.processEvent({
-                        type: 'goal',
-                        matchId: match.id,
-                        timestamp: Date.now(),
-                        minute: match.minute,
-                        data: { team: 'home', score: match.score, previousScore: cachedMatch.score },
-                    });
-                }
-                if (match.score.away > cachedMatch.score.away) {
-                    this.processEvent({
-                        type: 'goal',
-                        matchId: match.id,
-                        timestamp: Date.now(),
-                        minute: match.minute,
-                        data: { team: 'away', score: match.score, previousScore: cachedMatch.score },
-                    });
-                }
-            }
-            this.cache.set(`match:${match.id}`, match, CACHE_CONFIG.TTL.MATCH_DETAILS);
-        }
-    }
-    detectOddsChanges(matchId, oldOdds, newOdds) {
-        const markets = [
-            { key: 'homeWin', name: 'Home Win' },
-            { key: 'draw', name: 'Draw' },
-            { key: 'awayWin', name: 'Away Win' },
-        ];
-        for (const market of markets) {
-            const oldValue = oldOdds[market.key];
-            const newValue = newOdds[market.key];
-            if (oldValue && newValue && oldValue !== newValue) {
-                const change = ((newValue - oldValue) / oldValue) * 100;
-                if (Math.abs(change) > 5) {
-                    this.processEvent({
-                        type: 'odds_change',
-                        matchId,
-                        timestamp: Date.now(),
-                        data: {
-                            bookmaker: newOdds.provider,
-                            market: market.name,
-                            selection: market.key,
-                            oldOdds: oldValue,
-                            newOdds: newValue,
-                            change,
-                            timestamp: Date.now(),
-                        },
-                    });
-                }
-            }
-        }
-    }
-    updateCache(event) {
-        this.cache.invalidatePattern(`match:${event.matchId}*`);
-        const eventsKey = `events:${event.matchId}`;
-        const existingEvents = this.cache.get(eventsKey) || [];
-        existingEvents.push(event);
-        if (existingEvents.length > 100)
-            existingEvents.shift();
-        this.cache.set(eventsKey, existingEvents, CACHE_CONFIG.TTL.LIVE_EVENTS);
-    }
-    async fetchLiveScores() { return []; }
-    async fetchOdds(matchId) { return null; }
-    async fetchMatchEvents(matchId) { return []; }
-}
-let globalRealtimeManager = null;
-export function getRealtimeManager() {
-    if (!globalRealtimeManager)
-        globalRealtimeManager = new RealtimeDataManager();
-    return globalRealtimeManager;
-}
-export function resetRealtimeManager() {
-    if (globalRealtimeManager)
-        globalRealtimeManager.stop();
-    globalRealtimeManager = null;
-}

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

@@ -1,29 +0,0 @@
-/**
- * RETRY MECHANISM
- * Exponential backoff with jitter for resilient API calls
- */
-export interface RetryConfig {
-    maxAttempts: number;
-    initialDelay: number;
-    maxDelay: number;
-    backoffMultiplier: number;
-    retryableErrors?: string[];
-    onRetry?: (attempt: number, error: Error, delay: number) => void;
-}
-export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
-export declare const AGGRESSIVE_RETRY_CONFIG: RetryConfig;
-export declare const LIVE_DATA_RETRY_CONFIG: RetryConfig;
-/**
- * Execute a function with retry logic
- */
-export declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>, context?: string): Promise<T>;
-/**
- * Retry with circuit breaker combination
- */
-export declare function withRetryAndCircuitBreaker<T>(fn: () => Promise<T>, circuitBreaker: {
-    execute: <U>(fn: () => Promise<U>) => Promise<U>;
-}, config?: Partial<RetryConfig>, context?: string): Promise<T>;
-/**
- * Create a retryable wrapper for a function
- */
-export declare function createRetryable<T extends (...args: any[]) => Promise<any>>(fn: T, config?: Partial<RetryConfig>, context?: string): T;

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

@@ -1,77 +0,0 @@
-/**
- * RETRY MECHANISM
- * Exponential backoff with jitter for resilient API calls
- */
-import { logger } from '../../../utils.js';
-export const DEFAULT_RETRY_CONFIG = {
-    maxAttempts: 3,
-    initialDelay: 1000,
-    maxDelay: 30000,
-    backoffMultiplier: 2,
-    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', '503', '502', '504', '429'],
-};
-export const AGGRESSIVE_RETRY_CONFIG = {
-    maxAttempts: 5,
-    initialDelay: 500,
-    maxDelay: 60000,
-    backoffMultiplier: 2,
-    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', '503', '502', '504', '429', '500'],
-};
-export const LIVE_DATA_RETRY_CONFIG = {
-    maxAttempts: 3,
-    initialDelay: 200,
-    maxDelay: 5000,
-    backoffMultiplier: 1.5,
-    retryableErrors: ['ECONNRESET', 'ETIMEDOUT', '503', '504'],
-};
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-/**
- * Execute a function with retry logic
- */
-export async function withRetry(fn, config = {}, context) {
-    const fullConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
-    let lastError = null;
-    for (let attempt = 1; attempt <= fullConfig.maxAttempts; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            // Check if error is retryable
-            if (fullConfig.retryableErrors && !fullConfig.retryableErrors.some(e => lastError.message.includes(e) ||
-                lastError.code?.includes(e))) {
-                throw lastError;
-            }
-            if (attempt === fullConfig.maxAttempts) {
-                break;
-            }
-            // Calculate delay with exponential backoff and jitter
-            const delay = Math.min(fullConfig.initialDelay * Math.pow(fullConfig.backoffMultiplier, attempt - 1), fullConfig.maxDelay);
-            const jitteredDelay = delay * (0.8 + Math.random() * 0.4); // ±20% jitter
-            const contextStr = context ? `[${context}]` : '';
-            logger.warn(`[Retry${contextStr}] Attempt ${attempt}/${fullConfig.maxAttempts} failed: ${lastError.message}. Retrying in ${Math.round(jitteredDelay)}ms...`);
-            if (fullConfig.onRetry) {
-                fullConfig.onRetry(attempt, lastError, jitteredDelay);
-            }
-            await sleep(jitteredDelay);
-        }
-    }
-    const contextStr = context ? `[${context}]` : '';
-    throw new Error(`[Retry${contextStr}] All ${fullConfig.maxAttempts} attempts failed. Last error: ${lastError?.message}`);
-}
-/**
- * Retry with circuit breaker combination
- */
-export async function withRetryAndCircuitBreaker(fn, circuitBreaker, config, context) {
-    return circuitBreaker.execute(() => withRetry(fn, config, context));
-}
-/**
- * Create a retryable wrapper for a function
- */
-export function createRetryable(fn, config, context) {
-    return (async (...args) => {
-        return withRetry(() => fn(...args), config, context);
-    });
-}