@azumag/opencode-rate-limit-fallback 1.58.0 → 1.63.0

package/dist/src/errors/PatternExtractor.js

@@ -1,157 +1,219 @@
 /**
- * Pattern Extraction from Rate Limit Errors
+ * Pattern Extractor for extracting patterns from error messages
  */
 /**
- * Common rate limit phrases to extract from errors
+ * Pre-defined provider IDs for matching
  */
-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',
+const KNOWN_PROVIDERS = [
+    'anthropic',
+    'google',
+    'openai',
+    'cohere',
+    'mistral',
+    'together',
+    'deepseek',
+    'gemini',
 ];
 /**
- * Known provider identifiers
+ * Pre-defined HTTP status code regex patterns
  */
-const KNOWN_PROVIDERS = ['anthropic', 'google', 'openai', 'azure', 'cohere', 'mistral', 'meta', 'huggingface', 'together'];
+const STATUS_CODE_PATTERNS = [
+    /\b(429|503|502|500)\b/g, // Common rate limit and server error codes
+];
+/**
+ * Pre-defined rate limit phrase patterns
+ */
+const RATE_LIMIT_PHRASE_PATTERNS = [
+    /(?:rate.?limit|quota|exceed|too.?many.?requests|throttl)/gi,
+];
 /**
- * Rate limit status code regex patterns (pre-defined to avoid regex injection)
+ * Pre-defined API error code patterns
  */
-const RATE_LIMIT_STATUS_REGEX = {
-    429: /\b429\b/gi,
-    503: /\b503\b/gi,
-};
+const ERROR_CODE_PATTERNS = [
+    /\b(?:insufficient_quota|resource_exhausted|rate_limit_error|quota_exceeded|over_quota)\b/gi,
+];
 /**
- * PatternExtractor - Extracts pattern candidates from error messages
+ * Minimum length for pattern strings
+ */
+const MIN_PATTERN_LENGTH = 3;
+/**
+ * Pattern Extractor class
+ * Extracts pattern candidates from error messages
  */
 export class PatternExtractor {
     /**
-     * Extract candidate patterns from an error
+     * Check if an object is a valid error object
+     */
+    isValidErrorObject(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Extract error text from various error fields
      */
-    extractPatterns(error) {
+    extractErrorText(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]);
+        const textSources = [];
+        // Extract from response body
+        if (err.data && typeof err.data === 'object') {
+            const data = err.data;
+            if (typeof data.responseBody === 'string') {
+                textSources.push(data.responseBody);
+            }
+            if (typeof data.message === 'string') {
+                textSources.push(data.message);
+            }
+            if (typeof data.statusCode === 'number') {
+                textSources.push(String(data.statusCode));
             }
-            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());
+        // Extract from error properties
+        if (typeof err.message === 'string') {
+            textSources.push(err.message);
         }
-        // Filter out empty patterns
-        const validPatterns = patterns.filter(p => p && p !== '');
-        if (validPatterns.length === 0) {
-            return [];
+        if (typeof err.name === 'string') {
+            textSources.push(err.name);
         }
-        return [{
-                provider: provider || undefined,
-                patterns: validPatterns,
-                sourceError: originalText,
-                extractedAt: Date.now(),
-            }];
+        return textSources;
     }
     /**
-     * Extract provider ID from error
+     * Extract provider ID from error text
      */
-    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;
+    extractProvider(textSources) {
+        for (const text of textSources) {
+            const lowerText = text.toLowerCase();
+            for (const provider of KNOWN_PROVIDERS) {
+                if (lowerText.includes(provider)) {
+                    return provider;
+                }
             }
         }
         return null;
     }
     /**
-     * Extract HTTP status code from error
+     * Extract HTTP status codes from error text
      */
-    extractStatusCode(error) {
-        if (!this.isValidErrorObject(error)) {
-            return null;
-        }
-        const err = error;
-        const statusCode = err.data?.statusCode;
-        if (statusCode && typeof statusCode === 'number') {
-            return statusCode;
+    extractStatusCodes(textSources) {
+        const statusCodes = new Set();
+        for (const text of textSources) {
+            for (const pattern of STATUS_CODE_PATTERNS) {
+                pattern.lastIndex = 0; // Reset regex state
+                const matches = text.matchAll(pattern);
+                for (const match of matches) {
+                    if (match[1]) {
+                        statusCodes.add(match[1]);
+                    }
+                }
+            }
         }
-        return null;
+        return Array.from(statusCodes);
     }
     /**
-     * Extract common rate limit phrases from error
+     * Extract rate limit phrases from error text
      */
-    extractPhrases(error) {
-        if (!this.isValidErrorObject(error)) {
-            return [];
+    extractPhrases(textSources) {
+        const phrases = new Set();
+        const lowerTextSources = textSources.map(t => t.toLowerCase());
+        // Common rate limit phrases to look for
+        const commonPhrases = [
+            'rate limit',
+            'rate_limit',
+            'ratelimit',
+            'too many requests',
+            'quota exceeded',
+            'rate limit exceeded',
+            'quota limit',
+            'insufficient quota',
+            'rate limited',
+            'rate-limited',
+            'throttled',
+            'resource exhausted',
+            'daily limit',
+            'request limit',
+        ];
+        for (const text of lowerTextSources) {
+            // Extract common phrases
+            for (const phrase of commonPhrases) {
+                if (text.includes(phrase)) {
+                    phrases.add(phrase);
+                }
+            }
+            // Extract phrases using pre-defined patterns (for variations)
+            for (const pattern of RATE_LIMIT_PHRASE_PATTERNS) {
+                pattern.lastIndex = 0;
+                const matches = text.matchAll(pattern);
+                for (const match of matches) {
+                    const phrase = match[0].toLowerCase().replace(/\s+/g, ' ').trim();
+                    if (phrase.length >= MIN_PATTERN_LENGTH) {
+                        phrases.add(phrase);
+                    }
+                }
+            }
         }
-        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);
+        // Extract error codes (these go in errorCodes, not phrases)
+        // But we also add them to phrases for now
+        for (const text of lowerTextSources) {
+            for (const pattern of ERROR_CODE_PATTERNS) {
+                pattern.lastIndex = 0;
+                const matches = text.matchAll(pattern);
+                for (const match of matches) {
+                    const errorCode = match[0].toLowerCase();
+                    if (errorCode.length >= MIN_PATTERN_LENGTH) {
+                        phrases.add(errorCode);
+                    }
+                }
             }
         }
-        return foundPhrases;
+        return Array.from(phrases);
     }
     /**
-     * Validate if error is a valid object type
-     * @param error - The error to validate
-     * @returns True if error is a valid object
+     * Extract API error codes from error text
      */
-    isValidErrorObject(error) {
-        return error !== null && typeof error === 'object';
+    extractErrorCodes(textSources) {
+        const errorCodes = new Set();
+        for (const text of textSources) {
+            for (const pattern of ERROR_CODE_PATTERNS) {
+                pattern.lastIndex = 0;
+                const matches = text.matchAll(pattern);
+                for (const match of matches) {
+                    const code = match[0].toLowerCase();
+                    errorCodes.add(code);
+                }
+            }
+        }
+        return Array.from(errorCodes);
+    }
+    /**
+     * Extract pattern candidates from an error
+     */
+    extractPattern(error) {
+        if (!this.isValidErrorObject(error)) {
+            return null;
+        }
+        const textSources = this.extractErrorText(error);
+        if (textSources.length === 0) {
+            return null;
+        }
+        const provider = this.extractProvider(textSources);
+        const statusCodes = this.extractStatusCodes(textSources);
+        const phrases = this.extractPhrases(textSources);
+        const errorCodes = this.extractErrorCodes(textSources);
+        const rawText = textSources.join(' ').toLowerCase();
+        // If no patterns were extracted, return null
+        if (phrases.length === 0 && errorCodes.length === 0 && statusCodes.length === 0) {
+            return null;
+        }
+        return {
+            provider,
+            statusCode: statusCodes[0] || null,
+            phrases,
+            errorCodes,
+            rawText,
+        };
     }
 }

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

@@ -1,13 +1,11 @@
 /**
- * Pattern Learning from Rate Limit Errors
+ * Pattern Learner for orchestrating error pattern learning
  */
-import type { PatternCandidate, LearnedPattern, LearningConfig } from '../types/index.js';
+import type { LearnedPattern, PatternLearningConfig } 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
+ * Pattern Learner class
+ * Orchestrates the learning process
  */
 export declare class PatternLearner {
     private extractor;
@@ -15,83 +13,54 @@ export declare class PatternLearner {
     private storage;
     private config;
     private logger;
-    private patternTracker;
-    private learnedPatterns;
-    constructor(extractor: PatternExtractor, scorer: ConfidenceScorer, storage: PatternStorage, config: LearningConfig, logger: Logger);
+    private patternTracking;
+    private stats;
     /**
-     * Learn from a rate limit error
+     * Constructor
      */
-    learnFromError(error: unknown): void;
+    constructor(config: PatternLearningConfig, logger?: Logger);
     /**
-     * Track a pattern candidate for learning
+     * Update configuration
      */
-    private trackPattern;
+    updateConfig(config: PatternLearningConfig): void;
     /**
-     * Process tracked patterns and save those meeting criteria
+     * Set the config file path for storage
      */
-    private processPatterns;
+    setConfigFilePath(path: string): void;
     /**
-     * Merge similar patterns
+     * Process an error and learn from it
      */
-    mergePatterns(patterns: PatternCandidate[]): PatternCandidate | null;
+    processError(error: unknown): Promise<LearnedPattern | null>;
     /**
      * Load learned patterns from storage
      */
-    loadLearnedPatterns(): Promise<void>;
+    loadLearnedPatterns(): Promise<LearnedPattern[]>;
     /**
-     * Get all learned patterns
+     * Save learned patterns
      */
-    getLearnedPatterns(): LearnedPattern[];
+    saveLearnedPatterns(patterns: LearnedPattern[]): Promise<void>;
     /**
-     * Get learned patterns for a specific provider
+     * Get statistics
      */
-    getLearnedPatternsForProvider(provider: string): LearnedPattern[];
+    getStats(): typeof PatternLearner.prototype.stats;
     /**
-     * Add a learned pattern manually
+     * Reset statistics
      */
-    addLearnedPattern(pattern: LearnedPattern): Promise<void>;
+    resetStats(): void;
     /**
-     * Remove a learned pattern
+     * Clear all pattern tracking
      */
-    removeLearnedPattern(name: string): Promise<boolean>;
+    clearTracking(): void;
     /**
-     * Get a learned pattern by name
+     * Create a pattern key for tracking
      */
-    getLearnedPatternByName(name: string): LearnedPattern | undefined;
+    private createPatternKey;
     /**
-     * Generate a unique key for a pattern candidate
+     * Get or create pattern tracking
      */
-    private generatePatternKey;
+    private getOrCreateTracking;
     /**
-     * Generate a unique key for a learned pattern
+     * Save a single 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;
-    };
+    private saveLearnedPattern;
 }