@azumag/opencode-rate-limit-fallback 1.50.0 → 1.57.0

package/dist/src/dynamic/DynamicPrioritizer.js

@@ -0,0 +1,225 @@
+/**
+ * Dynamic Prioritizer
+ * Dynamically prioritizes fallback models based on performance metrics
+ */
+import { getModelKey } from '../utils/helpers.js';
+/**
+ * Dynamic Prioritizer class for calculating dynamic model scores
+ */
+export class DynamicPrioritizer {
+    config;
+    healthTracker;
+    logger;
+    metricsManager;
+    modelScores;
+    modelUsageHistory;
+    requestCount;
+    constructor(config, healthTracker, logger, metricsManager) {
+        this.config = config;
+        this.healthTracker = healthTracker;
+        this.logger = logger;
+        this.metricsManager = metricsManager;
+        this.modelScores = new Map();
+        this.modelUsageHistory = new Map();
+        this.requestCount = 0;
+    }
+    /**
+     * Record usage of a model for tracking recent activity
+     */
+    recordUsage(providerID, modelID) {
+        if (!this.config.enabled) {
+            return;
+        }
+        const key = getModelKey(providerID, modelID);
+        const now = Date.now();
+        let history = this.modelUsageHistory.get(key);
+        if (!history) {
+            history = [];
+            this.modelUsageHistory.set(key, history);
+        }
+        history.push(now);
+        // Trim history to max size
+        if (history.length > this.config.maxHistorySize) {
+            history.shift();
+        }
+        this.requestCount++;
+    }
+    /**
+     * Calculate dynamic score for a model
+     * Score is 0-1, higher is better
+     */
+    calculateScore(providerID, modelID) {
+        if (!this.config.enabled) {
+            return 0.5; // Neutral score when disabled
+        }
+        const key = getModelKey(providerID, modelID);
+        const health = this.healthTracker.getModelHealth(providerID, modelID);
+        // Default values if no health data
+        let healthScore = 100;
+        let avgResponseTime = 0;
+        let recentUsageScore = 0;
+        if (health) {
+            healthScore = health.healthScore;
+            avgResponseTime = health.avgResponseTime;
+        }
+        // Normalize health score (0-100 -> 0-1)
+        const normalizedHealthScore = healthScore / 100;
+        // Normalize response time (inverse - faster is better)
+        const normalizedResponseTime = this.normalizeResponseTime(avgResponseTime);
+        // Calculate recent usage score
+        recentUsageScore = this.calculateRecentUsageScore(key);
+        // Calculate weighted score
+        const score = normalizedHealthScore * this.config.successRateWeight +
+            normalizedResponseTime * this.config.responseTimeWeight +
+            recentUsageScore * this.config.recentUsageWeight;
+        this.modelScores.set(key, score);
+        return score;
+    }
+    /**
+     * Get prioritized models based on dynamic scores
+     * Returns models sorted by score (highest first)
+     */
+    getPrioritizedModels(candidates) {
+        if (!this.config.enabled) {
+            return candidates; // Return original order when disabled
+        }
+        // Check if we have enough samples for reliable ordering
+        if (!this.shouldUseDynamicOrdering()) {
+            return candidates;
+        }
+        // Map candidates with their scores
+        const scored = candidates.map(model => ({
+            model,
+            score: this.calculateScore(model.providerID, model.modelID),
+        }));
+        // Sort by score (descending)
+        scored.sort((a, b) => b.score - a.score);
+        // Check if the order actually changed (reorder occurred)
+        const reordered = candidates.map(m => getModelKey(m.providerID, m.modelID));
+        const sorted = scored.map(s => getModelKey(s.model.providerID, s.model.modelID));
+        const isReordered = JSON.stringify(reordered) !== JSON.stringify(sorted);
+        if (isReordered) {
+            // Record reorder event
+            if (this.metricsManager) {
+                this.metricsManager.recordDynamicPrioritizationReorder();
+            }
+        }
+        // Return sorted models
+        return scored.map(item => item.model);
+    }
+    /**
+     * Check if dynamic ordering should be used
+     * Returns true if dynamic prioritization is enabled and we have enough data for reliable ordering
+     */
+    shouldUseDynamicOrdering() {
+        if (!this.config.enabled) {
+            return false;
+        }
+        // Get health data for all tracked models
+        const healthData = this.healthTracker.getAllHealthData();
+        // Check if we have at least one model with enough samples to make dynamic ordering useful
+        const modelsWithEnoughSamples = healthData.filter(h => h.totalRequests >= this.config.minSamples);
+        // Use dynamic ordering if at least minSamples models have sufficient data
+        return modelsWithEnoughSamples.length >= this.config.minSamples;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = newConfig;
+        this.logger.debug('DynamicPrioritizer configuration updated', {
+            enabled: newConfig.enabled,
+            updateInterval: newConfig.updateInterval,
+            weights: {
+                successRate: newConfig.successRateWeight,
+                responseTime: newConfig.responseTimeWeight,
+                recentUsage: newConfig.recentUsageWeight,
+            },
+        });
+        // Update metrics when config changes
+        if (this.metricsManager) {
+            this.metricsManager.updateDynamicPrioritizationMetrics(newConfig.enabled, 0, // Reorders are tracked separately
+            this.modelScores.size);
+        }
+        // Clear scores when config changes
+        if (!newConfig.enabled) {
+            this.modelScores.clear();
+        }
+    }
+    /**
+     * Get current scores for all tracked models
+     */
+    getAllScores() {
+        return new Map(this.modelScores);
+    }
+    /**
+     * Check if dynamic prioritization is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Get number of models with calculated scores
+     */
+    getModelsWithDynamicScores() {
+        return this.modelScores.size;
+    }
+    /**
+     * Update metrics with current dynamic prioritization state
+     */
+    updateMetrics() {
+        if (!this.metricsManager) {
+            return;
+        }
+        this.metricsManager.updateDynamicPrioritizationMetrics(this.config.enabled, 0, // Reorder count is cumulative, tracked separately
+        this.modelScores.size);
+    }
+    /**
+     * Reset all scores and usage history
+     */
+    reset() {
+        this.modelScores.clear();
+        this.modelUsageHistory.clear();
+        this.requestCount = 0;
+    }
+    /**
+     * Normalize response time (inverse - faster is better)
+     * Returns 0-1, higher is better
+     */
+    normalizeResponseTime(avgResponseTime) {
+        // Thresholds for normalization (in milliseconds)
+        const FAST_THRESHOLD = 500; // Below this is considered "fast"
+        const SLOW_THRESHOLD = 5000; // Above this is considered "slow"
+        if (avgResponseTime <= FAST_THRESHOLD) {
+            return 1.0; // Excellent
+        }
+        else if (avgResponseTime >= SLOW_THRESHOLD) {
+            return 0.1; // Poor (but not zero to allow for recovery)
+        }
+        else {
+            // Linear interpolation between thresholds
+            const ratio = (avgResponseTime - FAST_THRESHOLD) / (SLOW_THRESHOLD - FAST_THRESHOLD);
+            return 1.0 - (ratio * 0.9); // Scale from 1.0 to 0.1
+        }
+    }
+    /**
+     * Calculate recent usage score
+     * Returns 0-1, higher for more recent usage
+     */
+    calculateRecentUsageScore(key) {
+        const history = this.modelUsageHistory.get(key);
+        if (!history || history.length === 0) {
+            return 0.0;
+        }
+        const now = Date.now();
+        const lastUsage = history[history.length - 1];
+        // Time since last usage (in hours)
+        const timeSinceLastUsage = (now - lastUsage) / (1000 * 60 * 60);
+        // Decay score over time (24 hour window)
+        const decay = Math.max(0, 1 - (timeSinceLastUsage / 24));
+        // Bonus for frequent usage (more history entries = higher score)
+        const frequencyBonus = Math.min(1, history.length / 10);
+        // Combine decay and frequency (weighted towards recent activity)
+        return (decay * 0.7) + (frequencyBonus * 0.3);
+    }
+}

package/dist/src/errors/ConfidenceScorer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Confidence Scoring for Learned Patterns
+ */
+import type { PatternCandidate, ErrorPattern, LearningConfig } from '../types/index.js';
+/**
+ * ConfidenceScorer - Calculates confidence scores for learned patterns
+ */
+export declare class ConfidenceScorer {
+    private config;
+    private knownPatterns;
+    constructor(config: LearningConfig, knownPatterns: ErrorPattern[]);
+    /**
+     * Calculate overall confidence score for a pattern
+     * @param pattern - The pattern candidate to score
+     * @param sampleCount - Number of times this pattern was seen
+     * @param learnedAt - Timestamp when pattern was first learned
+     * @returns Confidence score between 0 and 1
+     */
+    calculateScore(pattern: PatternCandidate, sampleCount: number, learnedAt?: number): number;
+    /**
+     * Calculate frequency score based on how often the pattern occurs
+     * @param count - Number of times pattern was seen
+     * @param window - Learning window size
+     * @returns Score between 0 and 1
+     */
+    calculateFrequencyScore(count: number, minFrequency: number): number;
+    /**
+     * Calculate similarity score based on how well pattern matches known patterns
+     * @param pattern - Pattern candidate to evaluate
+     * @returns Score between 0 and 1
+     */
+    calculateSimilarityScore(pattern: PatternCandidate): number;
+    /**
+     * Calculate recency score based on when pattern was first learned
+     * @param learnedAt - Timestamp when pattern was learned
+     * @returns Score between 0 and 1
+     */
+    calculateRecencyScore(learnedAt: number): number;
+    /**
+     * Check if pattern meets auto-approve threshold
+     * @param confidence - Confidence score
+     * @returns True if pattern should be auto-approved
+     */
+    shouldAutoApprove(confidence: number): boolean;
+}

package/dist/src/errors/ConfidenceScorer.js

@@ -0,0 +1,120 @@
+/**
+ * Confidence Scoring for Learned Patterns
+ */
+import { calculateJaccardSimilarity } from '../utils/similarity.js';
+/**
+ * Weight for each confidence component
+ */
+const FREQUENCY_WEIGHT = 0.5;
+const SIMILARITY_WEIGHT = 0.3;
+const RECENCY_WEIGHT = 0.2;
+/**
+ * Common rate limit words for similarity calculation
+ */
+const RATE_LIMIT_KEYWORDS = [
+    'rate', 'limit', 'quota', 'exceeded', 'too', 'many', 'requests',
+    '429', '429', 'exhausted', 'resource', 'daily', 'monthly', 'maximum',
+    'insufficient', 'per', 'minute', 'second', 'request',
+];
+/**
+ * ConfidenceScorer - Calculates confidence scores for learned patterns
+ */
+export class ConfidenceScorer {
+    config;
+    knownPatterns;
+    constructor(config, knownPatterns) {
+        this.config = config;
+        this.knownPatterns = knownPatterns;
+    }
+    /**
+     * Calculate overall confidence score for a pattern
+     * @param pattern - The pattern candidate to score
+     * @param sampleCount - Number of times this pattern was seen
+     * @param learnedAt - Timestamp when pattern was first learned
+     * @returns Confidence score between 0 and 1
+     */
+    calculateScore(pattern, sampleCount, learnedAt) {
+        const frequencyScore = this.calculateFrequencyScore(sampleCount, this.config.minErrorFrequency);
+        const similarityScore = this.calculateSimilarityScore(pattern);
+        const recencyScore = learnedAt ? this.calculateRecencyScore(learnedAt) : 0.5;
+        // Weighted average
+        const confidence = (frequencyScore * FREQUENCY_WEIGHT) +
+            (similarityScore * SIMILARITY_WEIGHT) +
+            (recencyScore * RECENCY_WEIGHT);
+        // Clamp to [0, 1]
+        return Math.max(0, Math.min(1, confidence));
+    }
+    /**
+     * Calculate frequency score based on how often the pattern occurs
+     * @param count - Number of times pattern was seen
+     * @param window - Learning window size
+     * @returns Score between 0 and 1
+     */
+    calculateFrequencyScore(count, minFrequency) {
+        if (count <= 0) {
+            return 0;
+        }
+        // Normalize against minimum frequency threshold
+        // Patterns seen at least minFrequency times get baseline score
+        // More frequent patterns get higher scores
+        const normalized = Math.min(count / (minFrequency * 2), 1);
+        // Boost score for patterns seen at least minFrequency times
+        const baseline = count >= minFrequency ? 0.5 : 0;
+        return Math.max(0, Math.min(1, baseline + normalized * 0.5));
+    }
+    /**
+     * Calculate similarity score based on how well pattern matches known patterns
+     * @param pattern - Pattern candidate to evaluate
+     * @returns Score between 0 and 1
+     */
+    calculateSimilarityScore(pattern) {
+        if (pattern.patterns.length === 0) {
+            return 0;
+        }
+        // Calculate keyword overlap with known rate limit patterns
+        const patternText = pattern.patterns.join(' ').toLowerCase();
+        const keywordsFound = RATE_LIMIT_KEYWORDS.filter(keyword => patternText.includes(keyword));
+        // Base score from keyword matching
+        const keywordScore = keywordsFound.length / RATE_LIMIT_KEYWORDS.length;
+        // Bonus for patterns that match known patterns
+        let knownPatternBonus = 0;
+        if (this.knownPatterns.length > 0) {
+            for (const known of this.knownPatterns) {
+                for (const knownPatternStr of known.patterns) {
+                    const knownText = typeof knownPatternStr === 'string' ? knownPatternStr : knownPatternStr.source;
+                    const similarity = calculateJaccardSimilarity(patternText, knownText.toLowerCase());
+                    knownPatternBonus = Math.max(knownPatternBonus, similarity);
+                }
+            }
+        }
+        // Combine scores
+        return Math.max(0, Math.min(1, (keywordScore * 0.5) + (knownPatternBonus * 0.5)));
+    }
+    /**
+     * Calculate recency score based on when pattern was first learned
+     * @param learnedAt - Timestamp when pattern was learned
+     * @returns Score between 0 and 1
+     */
+    calculateRecencyScore(learnedAt) {
+        const now = Date.now();
+        const age = now - learnedAt;
+        // Learning window in milliseconds
+        const window = this.config.learningWindowMs;
+        // Recent patterns (within window) get higher scores
+        if (age <= window) {
+            return 1;
+        }
+        // Older patterns get decaying score
+        // Score decays over time, but never goes to 0
+        const decayFactor = Math.exp(-age / (window * 10));
+        return Math.max(0.3, decayFactor);
+    }
+    /**
+     * Check if pattern meets auto-approve threshold
+     * @param confidence - Confidence score
+     * @returns True if pattern should be auto-approved
+     */
+    shouldAutoApprove(confidence) {
+        return confidence >= this.config.autoApproveThreshold;
+    }
+}

package/dist/src/errors/PatternExtractor.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pattern Extraction from Rate Limit Errors
+ */
+import type { PatternCandidate } from '../types/index.js';
+/**
+ * PatternExtractor - Extracts pattern candidates from error messages
+ */
+export declare class PatternExtractor {
+    /**
+     * Extract candidate patterns from an error
+     */
+    extractPatterns(error: unknown): PatternCandidate[];
+    /**
+     * Extract provider ID from error
+     */
+    extractProvider(error: unknown): string | null;
+    /**
+     * Extract HTTP status code from error
+     */
+    extractStatusCode(error: unknown): number | null;
+    /**
+     * Extract common rate limit phrases from error
+     */
+    extractPhrases(error: unknown): string[];
+    /**
+     * Validate if error is a valid object type
+     * @param error - The error to validate
+     * @returns True if error is a valid object
+     */
+    private isValidErrorObject;
+}

package/dist/src/errors/PatternExtractor.js

@@ -0,0 +1,157 @@
+/**
+ * Pattern Extraction from Rate Limit Errors
+ */
+/**
+ * Common rate limit phrases to extract from errors
+ */
+const RATE_LIMIT_PHRASES = [
+    'rate limit',
+    'rate_limit',
+    'ratelimit',
+    'too many requests',
+    'quota exceeded',
+    'quota_exceeded',
+    'insufficient_quota',
+    'resource exhausted',
+    'resource_exhausted',
+    'daily limit exceeded',
+    'monthly limit exceeded',
+    'maximum requests',
+    'requests per minute',
+    'requests per second',
+    'request limit',
+    'request_limit',
+    'limit exceeded',
+    'limit_exceeded',
+];
+/**
+ * Known provider identifiers
+ */
+const KNOWN_PROVIDERS = ['anthropic', 'google', 'openai', 'azure', 'cohere', 'mistral', 'meta', 'huggingface', 'together'];
+/**
+ * Rate limit status code regex patterns (pre-defined to avoid regex injection)
+ */
+const RATE_LIMIT_STATUS_REGEX = {
+    429: /\b429\b/gi,
+    503: /\b503\b/gi,
+};
+/**
+ * PatternExtractor - Extracts pattern candidates from error messages
+ */
+export class PatternExtractor {
+    /**
+     * Extract candidate patterns from an error
+     */
+    extractPatterns(error) {
+        if (!this.isValidErrorObject(error)) {
+            return [];
+        }
+        const err = error;
+        // Extract error text
+        const responseBody = String(err.data?.responseBody || '');
+        const message = String(err.data?.message || err.message || '');
+        const name = String(err.name || '');
+        const statusCode = err.data?.statusCode?.toString() || '';
+        const errorCode = err.data?.code?.toString() || err.data?.type?.toString() || '';
+        // Combine all text sources for original text
+        const originalText = [responseBody, message, name, statusCode, errorCode].join(' ');
+        // Extract patterns
+        const patterns = [];
+        // Extract HTTP status code
+        const extractedStatusCode = this.extractStatusCode(error);
+        if (extractedStatusCode) {
+            // Use pre-defined regex pattern instead of constructing one
+            if (extractedStatusCode in RATE_LIMIT_STATUS_REGEX) {
+                patterns.push(RATE_LIMIT_STATUS_REGEX[extractedStatusCode]);
+            }
+            patterns.push(String(extractedStatusCode));
+        }
+        // Extract provider
+        const provider = this.extractProvider(error);
+        // Extract common phrases
+        const extractedPhrases = this.extractPhrases(error);
+        patterns.push(...extractedPhrases);
+        // Extract error codes
+        if (errorCode) {
+            patterns.push(errorCode.toLowerCase());
+        }
+        // Filter out empty patterns
+        const validPatterns = patterns.filter(p => p && p !== '');
+        if (validPatterns.length === 0) {
+            return [];
+        }
+        return [{
+                provider: provider || undefined,
+                patterns: validPatterns,
+                sourceError: originalText,
+                extractedAt: Date.now(),
+            }];
+    }
+    /**
+     * Extract provider ID from error
+     */
+    extractProvider(error) {
+        if (!this.isValidErrorObject(error)) {
+            return null;
+        }
+        const err = error;
+        const allText = [
+            String(err.name || ''),
+            String(err.message || ''),
+            String(err.data?.message || ''),
+            String(err.data?.responseBody || ''),
+        ].join(' ').toLowerCase();
+        // Check for known provider names
+        for (const provider of KNOWN_PROVIDERS) {
+            if (allText.includes(provider)) {
+                return provider;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract HTTP status code from error
+     */
+    extractStatusCode(error) {
+        if (!this.isValidErrorObject(error)) {
+            return null;
+        }
+        const err = error;
+        const statusCode = err.data?.statusCode;
+        if (statusCode && typeof statusCode === 'number') {
+            return statusCode;
+        }
+        return null;
+    }
+    /**
+     * Extract common rate limit phrases from error
+     */
+    extractPhrases(error) {
+        if (!this.isValidErrorObject(error)) {
+            return [];
+        }
+        const err = error;
+        const allText = [
+            String(err.name || ''),
+            String(err.message || ''),
+            String(err.data?.message || ''),
+            String(err.data?.responseBody || ''),
+        ].join(' ').toLowerCase();
+        // Find matching phrases
+        const foundPhrases = [];
+        for (const phrase of RATE_LIMIT_PHRASES) {
+            if (allText.includes(phrase)) {
+                foundPhrases.push(phrase);
+            }
+        }
+        return foundPhrases;
+    }
+    /**
+     * Validate if error is a valid object type
+     * @param error - The error to validate
+     * @returns True if error is a valid object
+     */
+    isValidErrorObject(error) {
+        return error !== null && typeof error === 'object';
+    }
+}

package/dist/src/errors/PatternLearner.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Pattern Learning from Rate Limit Errors
+ */
+import type { PatternCandidate, LearnedPattern, LearningConfig } from '../types/index.js';
+import type { Logger } from '../../logger.js';
+import { PatternExtractor } from './PatternExtractor.js';
+import { ConfidenceScorer } from './ConfidenceScorer.js';
+import { PatternStorage } from './PatternStorage.js';
+/**
+ * PatternLearner - Orchestrates the learning process from errors
+ */
+export declare class PatternLearner {
+    private extractor;
+    private scorer;
+    private storage;
+    private config;
+    private logger;
+    private patternTracker;
+    private learnedPatterns;
+    constructor(extractor: PatternExtractor, scorer: ConfidenceScorer, storage: PatternStorage, config: LearningConfig, logger: Logger);
+    /**
+     * Learn from a rate limit error
+     */
+    learnFromError(error: unknown): void;
+    /**
+     * Track a pattern candidate for learning
+     */
+    private trackPattern;
+    /**
+     * Process tracked patterns and save those meeting criteria
+     */
+    private processPatterns;
+    /**
+     * Merge similar patterns
+     */
+    mergePatterns(patterns: PatternCandidate[]): PatternCandidate | null;
+    /**
+     * Load learned patterns from storage
+     */
+    loadLearnedPatterns(): Promise<void>;
+    /**
+     * Get all learned patterns
+     */
+    getLearnedPatterns(): LearnedPattern[];
+    /**
+     * Get learned patterns for a specific provider
+     */
+    getLearnedPatternsForProvider(provider: string): LearnedPattern[];
+    /**
+     * Add a learned pattern manually
+     */
+    addLearnedPattern(pattern: LearnedPattern): Promise<void>;
+    /**
+     * Remove a learned pattern
+     */
+    removeLearnedPattern(name: string): Promise<boolean>;
+    /**
+     * Get a learned pattern by name
+     */
+    getLearnedPatternByName(name: string): LearnedPattern | undefined;
+    /**
+     * Generate a unique key for a pattern candidate
+     */
+    private generatePatternKey;
+    /**
+     * Generate a unique key for a learned pattern
+     */
+    private generatePatternKeyFromLearned;
+    /**
+     * Generate a name for a pattern
+     */
+    private generatePatternName;
+    /**
+     * Calculate priority for a learned pattern
+     */
+    private calculatePriority;
+    /**
+     * Merge duplicate patterns in storage
+     */
+    mergeDuplicatePatterns(): Promise<number>;
+    /**
+     * Cleanup old patterns
+     */
+    cleanupOldPatterns(): Promise<number>;
+    /**
+     * Clear all tracked patterns
+     */
+    clearTrackedPatterns(): void;
+    /**
+     * Get statistics about learning
+     */
+    getStats(): {
+        trackedPatterns: number;
+        learnedPatterns: number;
+        pendingPatterns: number;
+    };
+}