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

package/dist/src/errors/PatternStorage.js

@@ -0,0 +1,234 @@
+/**
+ * Pattern Storage for Learned Error Patterns
+ */
+import { readFile, writeFile } from 'fs/promises';
+import { calculateJaccardSimilarity } from '../utils/similarity.js';
+/**
+ * PatternStorage - Manages persistence of learned patterns to config file
+ */
+export class PatternStorage {
+    configPath;
+    logger;
+    constructor(configPath, logger) {
+        this.configPath = configPath;
+        this.logger = logger;
+    }
+    /**
+     * Save a learned pattern to config file
+     */
+    async savePattern(pattern) {
+        try {
+            // Load existing config
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            // Initialize learnedPatterns array if not exists
+            if (!errorPatterns.learnedPatterns) {
+                errorPatterns.learnedPatterns = [];
+            }
+            const learnedPatterns = errorPatterns.learnedPatterns;
+            // Check if pattern with same name already exists
+            const existingIndex = learnedPatterns.findIndex((p) => p.name === pattern.name);
+            if (existingIndex >= 0) {
+                // Update existing pattern
+                learnedPatterns[existingIndex] = pattern;
+                this.logger.debug(`[PatternStorage] Updated learned pattern: ${pattern.name}`);
+            }
+            else {
+                // Add new pattern
+                learnedPatterns.push(pattern);
+                this.logger.info(`[PatternStorage] Saved new learned pattern: ${pattern.name}`);
+            }
+            // Cleanup old patterns if exceeding limit
+            const maxPatterns = config.errorPatterns?.maxLearnedPatterns || 20;
+            if (learnedPatterns.length > maxPatterns) {
+                await this.cleanupOldPatterns(maxPatterns, learnedPatterns);
+            }
+            // Save config
+            await this.saveConfig(config);
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to save pattern', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load all learned patterns from config file
+     */
+    async loadPatterns() {
+        try {
+            const config = await this.loadConfig();
+            const learnedPatterns = config.errorPatterns?.learnedPatterns || [];
+            // Validate patterns
+            const validPatterns = learnedPatterns.filter((p) => this.isValidPattern(p));
+            if (validPatterns.length !== learnedPatterns.length) {
+                this.logger.warn(`[PatternStorage] Filtered out ${learnedPatterns.length - validPatterns.length} invalid patterns`);
+            }
+            return validPatterns;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to load patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return [];
+        }
+    }
+    /**
+     * Delete a pattern by name from config file
+     */
+    async deletePattern(name) {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            const learnedPatterns = errorPatterns.learnedPatterns || [];
+            const index = learnedPatterns.findIndex((p) => p.name === name);
+            if (index >= 0) {
+                learnedPatterns.splice(index, 1);
+                errorPatterns.learnedPatterns = learnedPatterns;
+                config.errorPatterns = errorPatterns;
+                await this.saveConfig(config);
+                this.logger.info(`[PatternStorage] Deleted learned pattern: ${name}`);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to delete pattern', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Merge duplicate patterns with high similarity
+     */
+    async mergeDuplicatePatterns() {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            let learnedPatterns = errorPatterns.learnedPatterns || [];
+            const mergeThreshold = 0.8;
+            let mergedCount = 0;
+            // Find and merge similar patterns
+            const patternsToMerge = [];
+            for (let i = 0; i < learnedPatterns.length; i++) {
+                if (patternsToMerge.includes(i))
+                    continue;
+                for (let j = i + 1; j < learnedPatterns.length; j++) {
+                    if (patternsToMerge.includes(j))
+                        continue;
+                    const pattern1 = learnedPatterns[i];
+                    const pattern2 = learnedPatterns[j];
+                    // Only merge patterns from same provider
+                    if (pattern1.provider !== pattern2.provider)
+                        continue;
+                    // Calculate similarity
+                    const similarity = this.calculatePatternSimilarity(pattern1, pattern2);
+                    if (similarity >= mergeThreshold) {
+                        // Merge pattern2 into pattern1
+                        pattern1.patterns = [...new Set([...pattern1.patterns, ...pattern2.patterns])];
+                        pattern1.sampleCount += pattern2.sampleCount;
+                        pattern1.confidence = Math.max(pattern1.confidence, pattern2.confidence);
+                        patternsToMerge.push(j);
+                        mergedCount++;
+                        this.logger.info(`[PatternStorage] Merged pattern ${pattern2.name} into ${pattern1.name}`);
+                    }
+                }
+            }
+            // Remove merged patterns (in reverse order to preserve indices)
+            patternsToMerge.sort((a, b) => b - a);
+            for (const index of patternsToMerge) {
+                learnedPatterns.splice(index, 1);
+            }
+            if (mergedCount > 0) {
+                errorPatterns.learnedPatterns = learnedPatterns;
+                config.errorPatterns = errorPatterns;
+                await this.saveConfig(config);
+            }
+            return mergedCount;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to merge patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Cleanup old patterns, keeping only the most confident ones
+     */
+    async cleanupOldPatterns(maxCount, patterns) {
+        try {
+            const config = await this.loadConfig();
+            const errorPatterns = config.errorPatterns || {};
+            let learnedPatterns = patterns || errorPatterns.learnedPatterns || [];
+            if (learnedPatterns.length <= maxCount) {
+                return 0;
+            }
+            // Sort by confidence (descending), then by sample count (descending), then by learnedAt (descending)
+            learnedPatterns.sort((a, b) => {
+                if (b.confidence !== a.confidence) {
+                    return b.confidence - a.confidence;
+                }
+                if (b.sampleCount !== a.sampleCount) {
+                    return b.sampleCount - a.sampleCount;
+                }
+                return new Date(b.learnedAt).getTime() - new Date(a.learnedAt).getTime();
+            });
+            const removedCount = learnedPatterns.length - maxCount;
+            learnedPatterns = learnedPatterns.slice(0, maxCount);
+            errorPatterns.learnedPatterns = learnedPatterns;
+            config.errorPatterns = errorPatterns;
+            await this.saveConfig(config);
+            this.logger.info(`[PatternStorage] Cleaned up ${removedCount} old patterns`);
+            return removedCount;
+        }
+        catch (error) {
+            this.logger.error('[PatternStorage] Failed to cleanup patterns', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load config file
+     */
+    async loadConfig() {
+        try {
+            const content = await readFile(this.configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            // If file doesn't exist or is invalid, return empty config
+            return {};
+        }
+    }
+    /**
+     * Save config file
+     */
+    async saveConfig(config) {
+        await writeFile(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * Validate pattern structure
+     */
+    isValidPattern(pattern) {
+        return (pattern &&
+            typeof pattern === 'object' &&
+            typeof pattern.name === 'string' &&
+            Array.isArray(pattern.patterns) &&
+            typeof pattern.confidence === 'number' &&
+            typeof pattern.learnedAt === 'string' &&
+            typeof pattern.sampleCount === 'number' &&
+            typeof pattern.priority === 'number');
+    }
+    /**
+     * Calculate similarity between two patterns
+     */
+    calculatePatternSimilarity(pattern1, pattern2) {
+        const text1 = pattern1.patterns.join(' ').toLowerCase();
+        const text2 = pattern2.patterns.join(' ').toLowerCase();
+        return calculateJaccardSimilarity(text1, text2);
+    }
+}

package/dist/src/fallback/FallbackHandler.d.ts

@@ -25,6 +25,7 @@ export declare class FallbackHandler {
     private retryManager;
     private circuitBreaker?;
     private healthTracker?;
+    private dynamicPrioritizer?;
     constructor(config: PluginConfig, client: OpenCodeClient, logger: Logger, metricsManager: MetricsManager, subagentTracker: SubagentTracker, healthTracker?: HealthTracker);
     /**
      * Check and mark fallback in progress for deduplication
@@ -46,8 +47,8 @@ export declare class FallbackHandler {
      */
     private abortSession;
     /**
-     * Queue the prompt asynchronously (non-blocking), then abort the retry loop.
-     * promptAsync FIRST queues pending work so the server doesn't dispose on idle.
+     * Queue prompt asynchronously (non-blocking), then abort retry loop.
+     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
      * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
      */
     retryWithModel(targetSessionID: string, model: FallbackModel, parts: MessagePart[], hierarchy: SessionHierarchy | null): Promise<void>;

package/dist/src/fallback/FallbackHandler.js

@@ -6,6 +6,8 @@ import { ModelSelector } from './ModelSelector.js';
 import { CircuitBreaker } from '../circuitbreaker/CircuitBreaker.js';
 import { extractMessageParts, convertPartsToSDKFormat, safeShowToast, getStateKey, getModelKey, DEDUP_WINDOW_MS, STATE_TIMEOUT_MS } from '../utils/helpers.js';
 import { RetryManager } from '../retry/RetryManager.js';
+import { DynamicPrioritizer } from '../dynamic/DynamicPrioritizer.js';
+import { DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG } from '../config/defaults.js';
 /**
  * Fallback Handler class for orchestrating the fallback retry flow
  */
@@ -30,6 +32,8 @@ export class FallbackHandler {
     circuitBreaker;
     // Health tracker reference
     healthTracker;
+    // Dynamic prioritizer reference
+    dynamicPrioritizer;
     constructor(config, client, logger, metricsManager, subagentTracker, healthTracker) {
         this.config = config;
         this.client = client;
@@ -41,7 +45,12 @@ export class FallbackHandler {
         if (config.circuitBreaker?.enabled) {
             this.circuitBreaker = new CircuitBreaker(config.circuitBreaker, logger, metricsManager, client);
         }
-        this.modelSelector = new ModelSelector(config, client, this.circuitBreaker, healthTracker);
+        // Initialize dynamic prioritizer if enabled and health tracker is available
+        if (healthTracker && config.dynamicPrioritization?.enabled) {
+            const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...config.dynamicPrioritization };
+            this.dynamicPrioritizer = new DynamicPrioritizer(dynamicConfig, healthTracker, logger, metricsManager);
+        }
+        this.modelSelector = new ModelSelector(config, client, this.circuitBreaker, healthTracker, this.dynamicPrioritizer);
         this.currentSessionModel = new Map();
         this.modelRequestStartTimes = new Map();
         this.retryState = new Map();
@@ -95,18 +104,22 @@ export class FallbackHandler {
         }
     }
     /**
-     * Queue the prompt asynchronously (non-blocking), then abort the retry loop.
-     * promptAsync FIRST queues pending work so the server doesn't dispose on idle.
+     * Queue prompt asynchronously (non-blocking), then abort retry loop.
+     * promptAsync FIRST queues pending work so that server doesn't dispose on idle.
      * abort SECOND cancels the retry loop; the server sees the queued prompt and processes it.
      */
     async retryWithModel(targetSessionID, model, parts, hierarchy) {
-        // Track the new model for this session
+        // Record model usage for dynamic prioritization
+        if (this.dynamicPrioritizer) {
+            this.dynamicPrioritizer.recordUsage(model.providerID, model.modelID);
+        }
+        // Track new model for this session
         this.currentSessionModel.set(targetSessionID, {
             providerID: model.providerID,
             modelID: model.modelID,
             lastUpdated: Date.now(),
         });
-        // If this is a root session with subagents, propagate the model to all subagents
+        // If this is a root session with subagents, propagate model to all subagents
         if (hierarchy) {
             if (hierarchy.rootSessionID === targetSessionID) {
                 hierarchy.sharedFallbackState = "completed";
@@ -464,6 +477,26 @@ export class FallbackHandler {
                 this.modelSelector.setCircuitBreaker(undefined);
             }
         }
+        // Handle dynamic prioritizer configuration changes
+        const oldDynamicPrioritizerEnabled = this.dynamicPrioritizer !== undefined;
+        if (newConfig.dynamicPrioritization?.enabled !== oldDynamicPrioritizerEnabled) {
+            if (newConfig.dynamicPrioritization?.enabled && this.healthTracker) {
+                // Create new dynamic prioritizer
+                const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...newConfig.dynamicPrioritization };
+                this.dynamicPrioritizer = new DynamicPrioritizer(dynamicConfig, this.healthTracker, this.logger, this.metricsManager);
+                this.modelSelector.setDynamicPrioritizer(this.dynamicPrioritizer);
+            }
+            else if (!newConfig.dynamicPrioritization?.enabled) {
+                // Disable dynamic prioritizer
+                this.dynamicPrioritizer = undefined;
+                this.modelSelector.setDynamicPrioritizer(undefined);
+            }
+        }
+        else if (this.dynamicPrioritizer && newConfig.dynamicPrioritization) {
+            // Update existing dynamic prioritizer config
+            const dynamicConfig = { ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, ...newConfig.dynamicPrioritization };
+            this.dynamicPrioritizer.updateConfig(dynamicConfig);
+        }
         this.logger.debug('FallbackHandler configuration updated');
     }
 }

package/dist/src/fallback/ModelSelector.d.ts

@@ -4,6 +4,7 @@
 import type { FallbackModel, PluginConfig, OpenCodeClient } from '../types/index.js';
 import type { CircuitBreaker } from '../circuitbreaker/index.js';
 import type { HealthTracker } from '../health/HealthTracker.js';
+import type { DynamicPrioritizer } from '../dynamic/DynamicPrioritizer.js';
 /**
  * Model Selector class for handling model selection strategies
  */
@@ -13,7 +14,8 @@ export declare class ModelSelector {
     private client;
     private circuitBreaker?;
     private healthTracker?;
-    constructor(config: PluginConfig, client: OpenCodeClient, circuitBreaker?: CircuitBreaker, healthTracker?: HealthTracker);
+    private dynamicPrioritizer?;
+    constructor(config: PluginConfig, client: OpenCodeClient, circuitBreaker?: CircuitBreaker, healthTracker?: HealthTracker, dynamicPrioritizer?: DynamicPrioritizer);
     /**
      * Check if a model is currently rate limited
      */
@@ -50,4 +52,8 @@ export declare class ModelSelector {
      * Set circuit breaker (for hot reload)
      */
     setCircuitBreaker(circuitBreaker: CircuitBreaker | undefined): void;
+    /**
+     * Set dynamic prioritizer (for hot reload)
+     */
+    setDynamicPrioritizer(dynamicPrioritizer: DynamicPrioritizer | undefined): void;
 }

package/dist/src/fallback/ModelSelector.js

@@ -12,11 +12,13 @@ export class ModelSelector {
     client;
     circuitBreaker;
     healthTracker;
-    constructor(config, client, circuitBreaker, healthTracker) {
+    dynamicPrioritizer;
+    constructor(config, client, circuitBreaker, healthTracker, dynamicPrioritizer) {
         this.config = config;
         this.client = client;
         this.circuitBreaker = circuitBreaker;
         this.healthTracker = healthTracker;
+        this.dynamicPrioritizer = dynamicPrioritizer;
         this.rateLimitedModels = new Map();
     }
     /**
@@ -57,6 +59,11 @@ export class ModelSelector {
                 candidates.push(model);
             }
         }
+        // Apply dynamic prioritization if enabled
+        if (this.dynamicPrioritizer && this.dynamicPrioritizer.isEnabled() && this.dynamicPrioritizer.shouldUseDynamicOrdering()) {
+            const prioritizedCandidates = this.dynamicPrioritizer.getPrioritizedModels(candidates);
+            return prioritizedCandidates[0] || null;
+        }
         // Sort by health score if health tracker is enabled
         if (this.healthTracker && this.config.enableHealthBasedSelection) {
             const healthiest = this.healthTracker.getHealthiestModels(candidates);
@@ -172,4 +179,10 @@ export class ModelSelector {
     setCircuitBreaker(circuitBreaker) {
         this.circuitBreaker = circuitBreaker;
     }
+    /**
+     * Set dynamic prioritizer (for hot reload)
+     */
+    setDynamicPrioritizer(dynamicPrioritizer) {
+        this.dynamicPrioritizer = dynamicPrioritizer;
+    }
 }

package/dist/src/metrics/MetricsManager.d.ts

@@ -65,6 +65,14 @@ export declare class MetricsManager {
      * Record a circuit breaker state transition
      */
     recordCircuitBreakerStateTransition(modelKey: string, oldState: CircuitBreakerStateType, newState: CircuitBreakerStateType): void;
+    /**
+     * Update dynamic prioritization metrics
+     */
+    updateDynamicPrioritizationMetrics(enabled: boolean, reorders: number, modelsWithDynamicScores: number): void;
+    /**
+     * Record a model reorder event
+     */
+    recordDynamicPrioritizationReorder(): void;
     /**
      * Helper method to update circuit breaker state counts
      * @private

package/dist/src/metrics/MetricsManager.js

@@ -43,6 +43,11 @@ export class MetricsManager {
                 },
                 byModel: new Map(),
             },
+            dynamicPrioritization: {
+                enabled: false,
+                reorders: 0,
+                modelsWithDynamicScores: 0,
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -95,6 +100,11 @@ export class MetricsManager {
                 },
                 byModel: new Map(),
             },
+            dynamicPrioritization: {
+                enabled: false,
+                reorders: 0,
+                modelsWithDynamicScores: 0,
+            },
             startedAt: Date.now(),
             generatedAt: Date.now(),
         };
@@ -280,6 +290,24 @@ export class MetricsManager {
         this.updateCircuitBreakerStateCounts(modelMetrics, oldState, newState);
         this.metrics.circuitBreaker.byModel.set(modelKey, modelMetrics);
     }
+    /**
+     * Update dynamic prioritization metrics
+     */
+    updateDynamicPrioritizationMetrics(enabled, reorders, modelsWithDynamicScores) {
+        if (!this.config.enabled)
+            return;
+        this.metrics.dynamicPrioritization.enabled = enabled;
+        this.metrics.dynamicPrioritization.reorders = reorders;
+        this.metrics.dynamicPrioritization.modelsWithDynamicScores = modelsWithDynamicScores;
+    }
+    /**
+     * Record a model reorder event
+     */
+    recordDynamicPrioritizationReorder() {
+        if (!this.config.enabled)
+            return;
+        this.metrics.dynamicPrioritization.reorders++;
+    }
     /**
      * Helper method to update circuit breaker state counts
      * @private
@@ -350,6 +378,7 @@ export class MetricsManager {
                 ...metrics.circuitBreaker,
                 byModel: Object.fromEntries(Array.from(metrics.circuitBreaker.byModel.entries()).map(([k, v]) => [k, v])),
             },
+            dynamicPrioritization: metrics.dynamicPrioritization,
             startedAt: metrics.startedAt,
             generatedAt: metrics.generatedAt,
         };
@@ -472,6 +501,13 @@ export class MetricsManager {
                 }
             }
         }
+        lines.push("");
+        // Dynamic Prioritization
+        lines.push("Dynamic Prioritization:");
+        lines.push("-".repeat(40));
+        lines.push(`  Enabled: ${metrics.dynamicPrioritization.enabled ? 'Yes' : 'No'}`);
+        lines.push(`  Reorders: ${metrics.dynamicPrioritization.reorders}`);
+        lines.push(`  Models with dynamic scores: ${metrics.dynamicPrioritization.modelsWithDynamicScores}`);
         return lines.join("\n");
     }
     /**
@@ -579,6 +615,15 @@ export class MetricsManager {
                 successRate,
             ].join(","));
         }
+        lines.push("");
+        // Dynamic Prioritization CSV
+        lines.push("=== DYNAMIC_PRIORITIZATION ===");
+        lines.push("enabled,reorders,models_with_dynamic_scores");
+        lines.push([
+            metrics.dynamicPrioritization.enabled ? 'Yes' : 'No',
+            metrics.dynamicPrioritization.reorders,
+            metrics.dynamicPrioritization.modelsWithDynamicScores,
+        ].join(","));
         return lines.join("\n");
     }
     /**

package/dist/src/types/index.d.ts

@@ -113,6 +113,26 @@ export interface HealthTrackerConfig {
  * Use this for backward compatibility.
  */
 export type HealthPersistenceConfig = HealthTrackerConfig;
+/**
+ * Dynamic prioritization configuration
+ */
+export interface DynamicPrioritizationConfig {
+    enabled: boolean;
+    updateInterval: number;
+    successRateWeight: number;
+    responseTimeWeight: number;
+    recentUsageWeight: number;
+    minSamples: number;
+    maxHistorySize: number;
+}
+/**
+ * Dynamic prioritization metrics
+ */
+export interface DynamicPrioritizationMetrics {
+    enabled: boolean;
+    reorders: number;
+    modelsWithDynamicScores: number;
+}
 /**
  * Health metrics for a model
  */
@@ -139,12 +159,45 @@ export interface ErrorPattern {
     patterns: (string | RegExp)[];
     priority: number;
 }
+/**
+ * Pattern candidate extracted from an error
+ */
+export interface PatternCandidate {
+    provider?: string;
+    patterns: (string | RegExp)[];
+    sourceError: string;
+    extractedAt: number;
+}
+/**
+ * Learned pattern with metadata
+ */
+export interface LearnedPattern extends ErrorPattern {
+    confidence: number;
+    learnedAt: string;
+    sampleCount: number;
+    lastUsed?: number;
+}
+/**
+ * Learning configuration
+ */
+export interface LearningConfig {
+    enabled: boolean;
+    autoApproveThreshold: number;
+    maxLearnedPatterns: number;
+    minErrorFrequency: number;
+    learningWindowMs: number;
+}
 /**
  * Error pattern configuration
  */
 export interface ErrorPatternsConfig {
     custom?: ErrorPattern[];
     enableLearning?: boolean;
+    learnedPatterns?: LearnedPattern[];
+    autoApproveThreshold?: number;
+    maxLearnedPatterns?: number;
+    minErrorFrequency?: number;
+    learningWindowMs?: number;
 }
 /**
  * Configuration hot reload settings
@@ -193,6 +246,7 @@ export interface PluginConfig {
     verbose?: boolean;
     errorPatterns?: ErrorPatternsConfig;
     configReload?: ConfigReloadConfig;
+    dynamicPrioritization?: DynamicPrioritizationConfig;
 }
 /**
  * Fallback state for tracking progress
@@ -357,6 +411,7 @@ export interface MetricsData {
         total: CircuitBreakerMetrics;
         byModel: Map<string, CircuitBreakerMetrics>;
     };
+    dynamicPrioritization: DynamicPrioritizationMetrics;
     startedAt: number;
     generatedAt: number;
 }

package/dist/src/utils/config.js

@@ -4,7 +4,7 @@
 import { existsSync, readFileSync } from "fs";
 import { join, resolve, normalize, relative } from "path";
 import { DEFAULT_FALLBACK_MODELS, VALID_FALLBACK_MODES, VALID_RESET_INTERVALS, DEFAULT_RETRY_POLICY, VALID_RETRY_STRATEGIES, DEFAULT_CIRCUIT_BREAKER_CONFIG, } from '../types/index.js';
-import { DEFAULT_HEALTH_TRACKER_CONFIG, DEFAULT_COOLDOWN_MS, DEFAULT_FALLBACK_MODE, DEFAULT_LOG_CONFIG, DEFAULT_METRICS_CONFIG, DEFAULT_CONFIG_RELOAD_CONFIG, } from '../config/defaults.js';
+import { DEFAULT_HEALTH_TRACKER_CONFIG, DEFAULT_COOLDOWN_MS, DEFAULT_FALLBACK_MODE, DEFAULT_LOG_CONFIG, DEFAULT_METRICS_CONFIG, DEFAULT_CONFIG_RELOAD_CONFIG, DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG, DEFAULT_ERROR_PATTERN_LEARNING_CONFIG, } from '../config/defaults.js';
 /**
  * Default plugin configuration
  */
@@ -19,6 +19,8 @@ export const DEFAULT_CONFIG = {
     log: DEFAULT_LOG_CONFIG,
     metrics: DEFAULT_METRICS_CONFIG,
     configReload: DEFAULT_CONFIG_RELOAD_CONFIG,
+    dynamicPrioritization: DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+    errorPatterns: DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
 };
 /**
  * Validate that a path does not contain directory traversal attempts
@@ -85,6 +87,14 @@ export function validateConfig(config) {
             ...DEFAULT_CONFIG.configReload,
             ...config.configReload,
         } : DEFAULT_CONFIG.configReload,
+        dynamicPrioritization: config.dynamicPrioritization ? {
+            ...DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+            ...config.dynamicPrioritization,
+        } : DEFAULT_DYNAMIC_PRIORITIZATION_CONFIG,
+        errorPatterns: config.errorPatterns ? {
+            ...DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
+            ...config.errorPatterns,
+        } : DEFAULT_ERROR_PATTERN_LEARNING_CONFIG,
     };
 }
 /**

package/dist/src/utils/similarity.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Similarity utility functions
+ */
+/**
+ * Calculate Jaccard similarity between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Similarity score between 0 and 1
+ */
+export declare function calculateJaccardSimilarity(str1: string, str2: string): number;

package/dist/src/utils/similarity.js

@@ -0,0 +1,24 @@
+/**
+ * Similarity utility functions
+ */
+/**
+ * Calculate Jaccard similarity between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Similarity score between 0 and 1
+ */
+export function calculateJaccardSimilarity(str1, str2) {
+    // Tokenize strings
+    const tokens1 = new Set(str1.split(/\s+/).filter(t => t.length > 0));
+    const tokens2 = new Set(str2.split(/\s+/).filter(t => t.length > 0));
+    if (tokens1.size === 0 && tokens2.size === 0) {
+        return 1;
+    }
+    if (tokens1.size === 0 || tokens2.size === 0) {
+        return 0;
+    }
+    // Calculate intersection and union
+    const intersection = new Set([...tokens1].filter(x => tokens2.has(x)));
+    const union = new Set([...tokens1, ...tokens2]);
+    return intersection.size / union.size;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azumag/opencode-rate-limit-fallback",
-  "version": "1.50.0",
+  "version": "1.57.0",
   "description": "OpenCode plugin that automatically switches to fallback models when rate limited",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",