@azumag/opencode-rate-limit-fallback 1.59.0 → 1.64.0

package/dist/index.js

@@ -163,6 +163,18 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
     if (config.errorPatterns?.custom) {
         errorPatternRegistry.registerMany(config.errorPatterns.custom);
     }
+    // Initialize pattern learning if enabled
+    if (config.errorPatterns?.enableLearning && configSource) {
+        const patternLearningConfig = {
+            enabled: config.errorPatterns.enableLearning,
+            autoApproveThreshold: config.errorPatterns.autoApproveThreshold ?? 0.8,
+            maxLearnedPatterns: config.errorPatterns.maxLearnedPatterns ?? 20,
+            minErrorFrequency: config.errorPatterns.minErrorFrequency ?? 3,
+            learningWindowMs: config.errorPatterns.learningWindowMs ?? 86400000,
+        };
+        errorPatternRegistry.initializePatternLearning(patternLearningConfig, configSource);
+        logger.info('Pattern learning enabled');
+    }
     // Initialize health tracker
     let healthTracker;
     if (config.enableHealthBasedSelection) {
@@ -186,6 +198,7 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
         const componentRefs = {
             fallbackHandler,
             metricsManager,
+            errorPatternRegistry,
         };
         const configReloader = new ConfigReloader(config, configSource, logger, validator, client, componentRefs, directory, worktree, config.configReload?.notifyOnReload ?? true);
         configWatcher = new ConfigWatcher(configSource || '', logger, async () => { await configReloader.reloadConfig(); }, {
@@ -214,6 +227,13 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
             if (isSessionErrorEvent(event)) {
                 const { sessionID, error } = event.properties;
                 if (sessionID && error && errorPatternRegistry.isRateLimitError(error)) {
+                    // Learn from this error if pattern learning is enabled
+                    const patternLearner = errorPatternRegistry.getPatternLearner();
+                    if (patternLearner) {
+                        patternLearner.processError(error).catch((err) => {
+                            logger.debug('Pattern learning failed', { error: err });
+                        });
+                    }
                     await fallbackHandler.handleRateLimitFallback(sessionID, "", "");
                 }
             }
@@ -221,6 +241,13 @@ export const RateLimitFallback = async ({ client, directory, worktree }) => {
             if (isMessageUpdatedEvent(event)) {
                 const info = event.properties.info;
                 if (info?.error && errorPatternRegistry.isRateLimitError(info.error)) {
+                    // Learn from this error if pattern learning is enabled
+                    const patternLearner = errorPatternRegistry.getPatternLearner();
+                    if (patternLearner) {
+                        patternLearner.processError(info.error).catch((err) => {
+                            logger.debug('Pattern learning failed', { error: err });
+                        });
+                    }
                     await fallbackHandler.handleRateLimitFallback(info.sessionID, info.providerID || "", info.modelID || "");
                 }
                 else if (info?.status === "completed" && !info?.error && info?.id) {

package/dist/src/config/Validator.js

@@ -456,14 +456,6 @@ export class ConfigValidator {
                         value: config.errorPatterns.custom,
                     });
                 }
-                if (config.errorPatterns.enableLearning !== undefined && typeof config.errorPatterns.enableLearning !== 'boolean') {
-                    errors.push({
-                        path: 'errorPatterns.enableLearning',
-                        message: 'enableLearning must be a boolean',
-                        severity: 'error',
-                        value: config.errorPatterns.enableLearning,
-                    });
-                }
             }
         }
         // Validate dynamicPrioritization

package/dist/src/config/defaults.d.ts

@@ -91,12 +91,23 @@ export declare const DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG: {
     readonly maxHistorySize: 100;
 };
 /**
- * Default error pattern learning configuration
+ * Default pattern learning configuration
  */
-export declare const DEFAULT_ERROR_PATTERN_LEARNING_CONFIG: {
+export declare const DEFAULT_PATTERN_LEARNING_CONFIG: {
+    readonly enabled: false;
+    readonly autoApproveThreshold: 0.8;
+    readonly maxLearnedPatterns: 20;
+    readonly minErrorFrequency: 3;
+    readonly learningWindowMs: 86400000;
+};
+/**
+ * Default error pattern configuration
+ */
+export declare const DEFAULT_ERROR_PATTERNS_CONFIG: {
+    readonly custom: undefined;
     readonly enableLearning: false;
     readonly autoApproveThreshold: 0.8;
     readonly maxLearnedPatterns: 20;
     readonly minErrorFrequency: 3;
-    readonly learningWindowMs: number;
+    readonly learningWindowMs: 86400000;
 };

package/dist/src/config/defaults.js

@@ -117,15 +117,26 @@ export const DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG = {
     maxHistorySize: 100,
 };
 // ============================================================================
-// Error Pattern Learning Defaults
+// Error Pattern Configuration Defaults
 // ============================================================================
 /**
- * Default error pattern learning configuration
+ * Default pattern learning configuration
  */
-export const DEFAULT_ERROR_PATTERN_LEARNING_CONFIG = {
+export const DEFAULT_PATTERN_LEARNING_CONFIG = {
+    enabled: false,
+    autoApproveThreshold: 0.8,
+    maxLearnedPatterns: 20,
+    minErrorFrequency: 3,
+    learningWindowMs: 86400000, // 24 hours
+};
+/**
+ * Default error pattern configuration
+ */
+export const DEFAULT_ERROR_PATTERNS_CONFIG = {
+    custom: undefined,
     enableLearning: false,
     autoApproveThreshold: 0.8,
     maxLearnedPatterns: 20,
     minErrorFrequency: 3,
-    learningWindowMs: 24 * 60 * 60 * 1000, // 24 hours
+    learningWindowMs: 86400000,
 };

package/dist/src/diagnostics/Reporter.d.ts

@@ -3,7 +3,7 @@
  * Generates and reports diagnostic information about the plugin
  */
 import { Logger } from '../../logger.js';
-import type { PluginConfig, ModelHealth } from '../types/index.js';
+import type { PluginConfig, ModelHealth, LearnedPattern } from '../types/index.js';
 import type { HealthTracker } from '../health/HealthTracker.js';
 import type { CircuitBreaker } from '../circuitbreaker/index.js';
 import { ErrorPatternRegistry } from '../errors/PatternRegistry.js';
@@ -55,9 +55,12 @@ export interface DiagnosticReport {
     errorPatterns: {
         stats: {
             total: number;
+            default: number;
+            learned: number;
             byProvider: Record<string, number>;
             byPriority: Record<string, number>;
         };
+        learnedPatterns: LearnedPattern[];
     };
     circuitBreaker: {
         enabled: boolean;

package/dist/src/diagnostics/Reporter.js

@@ -76,6 +76,7 @@ export class DiagnosticReporter {
     generateErrorPatternsReport() {
         return {
             stats: this.errorPatternRegistry.getStats(),
+            learnedPatterns: this.errorPatternRegistry.getLearnedPatterns(),
         };
     }
     /**
@@ -208,6 +209,8 @@ export class DiagnosticReporter {
         lines.push('-'.repeat(70));
         const patternStats = report.errorPatterns.stats;
         lines.push(`Total Patterns: ${patternStats.total}`);
+        lines.push(`Default Patterns: ${patternStats.default || 0}`);
+        lines.push(`Learned Patterns: ${patternStats.learned || 0}`);
         lines.push('');
         if (Object.keys(patternStats.byProvider).length > 0) {
             lines.push('By Provider:');
@@ -223,6 +226,19 @@ export class DiagnosticReporter {
             }
             lines.push('');
         }
+        // Display learned patterns details
+        if (report.errorPatterns.learnedPatterns.length > 0) {
+            lines.push('LEARNED PATTERNS:');
+            for (const pattern of report.errorPatterns.learnedPatterns.sort((a, b) => b.confidence - a.confidence)) {
+                lines.push(`  Name: ${pattern.name}`);
+                lines.push(`    Provider: ${pattern.provider || 'generic'}`);
+                lines.push(`    Confidence: ${(pattern.confidence * 100).toFixed(1)}%`);
+                lines.push(`    Sample Count: ${pattern.sampleCount}`);
+                lines.push(`    Learned At: ${pattern.learnedAt}`);
+                lines.push(`    Patterns: ${pattern.patterns.map(p => typeof p === 'string' ? `"${p}"` : p.toString()).join(', ')}`);
+                lines.push('');
+            }
+        }
         // Circuit breaker section
         lines.push('-'.repeat(70));
         lines.push('CIRCUIT BREAKER');

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

@@ -1,45 +1,55 @@
 /**
- * Confidence Scoring for Learned Patterns
+ * Confidence Scorer for calculating confidence scores for learned patterns
  */
-import type { PatternCandidate, ErrorPattern, LearningConfig } from '../types/index.js';
+import type { ErrorPattern, LearnedPattern, PatternLearningConfig } from '../types/index.js';
 /**
- * ConfidenceScorer - Calculates confidence scores for learned patterns
+ * Confidence Scorer class
+ * 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
+     * Constructor
      */
-    calculateScore(pattern: PatternCandidate, sampleCount: number, learnedAt?: number): number;
+    constructor(config: PatternLearningConfig);
     /**
-     * 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
+     * Update configuration
      */
-    calculateFrequencyScore(count: number, minFrequency: number): number;
+    updateConfig(config: PatternLearningConfig): void;
     /**
-     * Calculate similarity score based on how well pattern matches known patterns
-     * @param pattern - Pattern candidate to evaluate
-     * @returns Score between 0 and 1
+     * Calculate frequency score (50% weight)
      */
-    calculateSimilarityScore(pattern: PatternCandidate): number;
+    private calculateFrequencyScore;
     /**
-     * Calculate recency score based on when pattern was first learned
-     * @param learnedAt - Timestamp when pattern was learned
-     * @returns Score between 0 and 1
+     * Calculate similarity score (30% weight)
      */
-    calculateRecencyScore(learnedAt: number): number;
+    private calculateSimilarityScore;
     /**
-     * Check if pattern meets auto-approve threshold
-     * @param confidence - Confidence score
-     * @returns True if pattern should be auto-approved
+     * Calculate recency score (20% weight)
+     */
+    private calculateRecencyScore;
+    /**
+     * Calculate overall confidence score
+     */
+    calculateConfidence(pattern: ErrorPattern, frequency: number, firstSeen: number, existingPatterns?: ErrorPattern[]): number;
+    /**
+     * Check if a pattern should be auto-approved
      */
     shouldAutoApprove(confidence: number): boolean;
+    /**
+     * Get confidence level category
+     */
+    getConfidenceLevel(confidence: number): 'high' | 'medium' | 'low';
+    /**
+     * Calculate pattern statistics
+     */
+    calculatePatternStats(patterns: LearnedPattern[]): {
+        totalPatterns: number;
+        avgConfidence: number;
+        confidenceDistribution: {
+            high: number;
+            medium: number;
+            low: number;
+        };
+    };
 }

package/dist/src/errors/ConfidenceScorer.js

@@ -1,120 +1,110 @@
 /**
- * Confidence Scoring for Learned Patterns
+ * Confidence Scorer for calculating confidence scores 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
+ * Confidence Scorer class
+ * Calculates confidence scores for learned patterns
  */
 export class ConfidenceScorer {
     config;
-    knownPatterns;
-    constructor(config, knownPatterns) {
+    /**
+     * Constructor
+     */
+    constructor(config) {
         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
+     * Update configuration
      */
-    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));
+    updateConfig(config) {
+        this.config = config;
     }
     /**
-     * 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
+     * Calculate frequency score (50% weight)
      */
-    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));
+    calculateFrequencyScore(frequency) {
+        return Math.min(1, frequency / this.config.minErrorFrequency);
     }
     /**
-     * Calculate similarity score based on how well pattern matches known patterns
-     * @param pattern - Pattern candidate to evaluate
-     * @returns Score between 0 and 1
+     * Calculate similarity score (30% weight)
      */
-    calculateSimilarityScore(pattern) {
-        if (pattern.patterns.length === 0) {
-            return 0;
+    calculateSimilarityScore(pattern, existingPatterns) {
+        if (existingPatterns.length === 0) {
+            return 1; // No existing patterns, so new pattern is novel
         }
-        // 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);
-                }
+        // Find the maximum similarity to any existing pattern
+        let maxSimilarity = 0;
+        for (const existing of existingPatterns) {
+            // Compare patterns
+            const patternStr = pattern.patterns.map(p => String(p)).join(' ');
+            const existingStr = existing.patterns.map(p => String(p)).join(' ');
+            const similarity = calculateJaccardSimilarity(patternStr, existingStr);
+            if (similarity > maxSimilarity) {
+                maxSimilarity = similarity;
             }
         }
-        // Combine scores
-        return Math.max(0, Math.min(1, (keywordScore * 0.5) + (knownPatternBonus * 0.5)));
+        // Return 1 - maxSimilarity (lower similarity to existing patterns = higher score)
+        return 1 - maxSimilarity;
     }
     /**
-     * Calculate recency score based on when pattern was first learned
-     * @param learnedAt - Timestamp when pattern was learned
-     * @returns Score between 0 and 1
+     * Calculate recency score (20% weight)
      */
-    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);
+    calculateRecencyScore(firstSeen) {
+        const timeSinceFirst = Date.now() - firstSeen;
+        return 1 - Math.min(1, timeSinceFirst / this.config.learningWindowMs);
+    }
+    /**
+     * Calculate overall confidence score
+     */
+    calculateConfidence(pattern, frequency, firstSeen, existingPatterns = []) {
+        const frequencyScore = this.calculateFrequencyScore(frequency);
+        const similarityScore = this.calculateSimilarityScore(pattern, existingPatterns);
+        const recencyScore = this.calculateRecencyScore(firstSeen);
+        // Weighted combination
+        const confidence = frequencyScore * 0.5 +
+            similarityScore * 0.3 +
+            recencyScore * 0.2;
+        return Math.round(confidence * 100) / 100; // Round to 2 decimal places
     }
     /**
-     * Check if pattern meets auto-approve threshold
-     * @param confidence - Confidence score
-     * @returns True if pattern should be auto-approved
+     * Check if a pattern should be auto-approved
      */
     shouldAutoApprove(confidence) {
         return confidence >= this.config.autoApproveThreshold;
     }
+    /**
+     * Get confidence level category
+     */
+    getConfidenceLevel(confidence) {
+        if (confidence >= 0.8)
+            return 'high';
+        if (confidence >= 0.5)
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Calculate pattern statistics
+     */
+    calculatePatternStats(patterns) {
+        if (patterns.length === 0) {
+            return {
+                totalPatterns: 0,
+                avgConfidence: 0,
+                confidenceDistribution: { high: 0, medium: 0, low: 0 },
+            };
+        }
+        let totalConfidence = 0;
+        const distribution = { high: 0, medium: 0, low: 0 };
+        for (const pattern of patterns) {
+            totalConfidence += pattern.confidence;
+            const level = this.getConfidenceLevel(pattern.confidence);
+            distribution[level]++;
+        }
+        return {
+            totalPatterns: patterns.length,
+            avgConfidence: Math.round((totalConfidence / patterns.length) * 100) / 100,
+            confidenceDistribution: distribution,
+        };
+    }
 }

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

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