adaptive-memory-multi-model-router 2.14.49 → 2.14.51

package/test-council/1-structure-tests.test.ts

@@ -0,0 +1,353 @@
+/**
+ * Structure Tests - Code Structure & Export Coverage
+ * 
+ * Tests that verify all exported functions, classes, and types work correctly.
+ * This file provides comprehensive coverage of the public API surface.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Import all exports from the main module
+const {
+  // Routing engine
+  routeQuery,
+  routeBatch,
+  recommendForTask,
+  extractQueryFeatures,
+  MODEL_PROFILES,
+  updateModelProfile,
+  getProviderHealth,
+  
+  // Retry handling
+  ProviderRetryHandler,
+  createRetryHandler,
+  getDefaultRetryHandler,
+  DEFAULT_RETRY_CONFIG,
+  DEFAULT_PROVIDER_CONFIG,
+  PROVIDER_CONTEXT_LIMITS,
+  
+  // Providers
+  DEFAULT_PROVIDERS,
+  getAvailableProviders,
+  registerProvider,
+  deregisterProvider,
+  updateProvider,
+  healthCheck,
+  checkAllProviders,
+  findCheapestAvailableProvider,
+  findFastestAvailableProvider,
+  loadConfig,
+  saveConfig,
+  
+  // Cost tracking
+  CostTracker,
+  BudgetEnforcer,
+  BudgetExceededError,
+  createBudgetEnforcer,
+  
+  // Memory
+  MemoryTree,
+  
+  // Utilities
+  countTokens,
+  estimateTokens,
+  
+  // Cache
+  SemanticCache,
+  
+  // Security
+  GuardrailEngine,
+  
+  // Analytics
+  CostAnalytics,
+  
+  // Observability
+  Tracer,
+  getTracer,
+  createTracer,
+  MetricsCollector,
+  getMetrics,
+  createMetricsCollector,
+  observabilityMiddleware,
+  observabilityPlugin,
+  budgetAlertMiddleware,
+  
+  // Ensemble
+  EnsembleOrchestrator,
+  
+  // Factory
+  createA3MRouter,
+} = require('../dist/index.js');
+
+// ============================================================
+// STRUCTURE TESTS
+// ============================================================
+
+describe('1. Structure - Routing Engine Exports', () => {
+  
+  describe('routeQuery', () => {
+    it('is a function', () => {
+      expect(typeof routeQuery).toBe('function');
+    });
+    
+    it('returns object with primary_model', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('primary_model');
+    });
+    
+    it('returns object with fallback_models array', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('fallback_models');
+      expect(Array.isArray(result.fallback_models)).toBe(true);
+    });
+    
+    it('returns object with estimated_cost number', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('estimated_cost');
+      expect(typeof result.estimated_cost).toBe('number');
+    });
+    
+    it('returns object with confidence number', () => {
+      const result = routeQuery('test query');
+      expect(result).toHaveProperty('confidence');
+      expect(typeof result.confidence).toBe('number');
+    });
+  });
+  
+  describe('routeBatch', () => {
+    it('is a function', () => {
+      expect(typeof routeBatch).toBe('function');
+    });
+    
+    it('returns array of same length as input', () => {
+      const queries = ['a', 'b', 'c'];
+      const results = routeBatch(queries);
+      expect(results.length).toBe(queries.length);
+    });
+  });
+  
+  describe('recommendForTask', () => {
+    it('is a function', () => {
+      expect(typeof recommendForTask).toBe('function');
+    });
+    
+    it('returns object with primary field', () => {
+      const result = recommendForTask('coding');
+      expect(result).toHaveProperty('primary');
+    });
+  });
+  
+  describe('extractQueryFeatures', () => {
+    it('is a function', () => {
+      expect(typeof extractQueryFeatures).toBe('function');
+    });
+    
+    it('returns object', () => {
+      const features = extractQueryFeatures('test');
+      expect(typeof features).toBe('object');
+    });
+  });
+  
+  describe('MODEL_PROFILES', () => {
+    it('is an object', () => {
+      expect(typeof MODEL_PROFILES).toBe('object');
+    });
+    
+    it('has at least one model', () => {
+      expect(Object.keys(MODEL_PROFILES).length).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe('2. Structure - Provider Configuration Exports', () => {
+  
+  describe('DEFAULT_PROVIDERS', () => {
+    it('is an object', () => {
+      expect(typeof DEFAULT_PROVIDERS).toBe('object');
+    });
+  });
+  
+  describe('getAvailableProviders', () => {
+    it('is a function', () => {
+      expect(typeof getAvailableProviders).toBe('function');
+    });
+    
+    it('returns an object', () => {
+      const providers = getAvailableProviders();
+      expect(typeof providers).toBe('object');
+    });
+  });
+  
+  describe('registerProvider', () => {
+    it('is a function', () => {
+      expect(typeof registerProvider).toBe('function');
+    });
+  });
+  
+  describe('deregisterProvider', () => {
+    it('is a function', () => {
+      expect(typeof deregisterProvider).toBe('function');
+    });
+  });
+  
+  describe('updateProvider', () => {
+    it('is a function', () => {
+      expect(typeof updateProvider).toBe('function');
+    });
+  });
+  
+  describe('healthCheck', () => {
+    it('is a function', () => {
+      expect(typeof healthCheck).toBe('function');
+    });
+  });
+});
+
+describe('3. Structure - Retry Handler Exports', () => {
+  
+  describe('ProviderRetryHandler', () => {
+    it('is a class', () => {
+      expect(typeof ProviderRetryHandler).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const handler = new ProviderRetryHandler();
+      expect(handler).toBeInstanceOf(ProviderRetryHandler);
+    });
+    
+    it('has getConfig method', () => {
+      const handler = new ProviderRetryHandler();
+      expect(typeof handler.getConfig).toBe('function');
+    });
+    
+    it('has isRetryableError method', () => {
+      const handler = new ProviderRetryHandler();
+      expect(typeof handler.isRetryableError).toBe('function');
+    });
+  });
+  
+  describe('createRetryHandler', () => {
+    it('is a function', () => {
+      expect(typeof createRetryHandler).toBe('function');
+    });
+  });
+  
+  describe('DEFAULT_RETRY_CONFIG', () => {
+    it('is an object', () => {
+      expect(typeof DEFAULT_RETRY_CONFIG).toBe('object');
+    });
+  });
+  
+  describe('PROVIDER_CONTEXT_LIMITS', () => {
+    it('is an object', () => {
+      expect(typeof PROVIDER_CONTEXT_LIMITS).toBe('object');
+    });
+  });
+});
+
+describe('4. Structure - Cost Tracking Exports', () => {
+  
+  describe('CostTracker', () => {
+    it('is a class', () => {
+      expect(typeof CostTracker).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const tracker = new CostTracker();
+      expect(tracker).toBeTruthy();
+    });
+  });
+  
+  describe('BudgetEnforcer', () => {
+    it('is a class', () => {
+      expect(typeof BudgetEnforcer).toBe('function');
+    });
+  });
+  
+  describe('BudgetExceededError', () => {
+    it('is an Error class', () => {
+      expect(typeof BudgetExceededError).toBe('function');
+      const error = new BudgetExceededError('test');
+      expect(error).toBeInstanceOf(Error);
+    });
+  });
+});
+
+describe('5. Structure - Memory Exports', () => {
+  
+  describe('MemoryTree', () => {
+    it('is a class', () => {
+      expect(typeof MemoryTree).toBe('function');
+    });
+    
+    it('can be instantiated', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(memory).toBeTruthy();
+    });
+    
+    it('has add method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.add).toBe('function');
+    });
+    
+    it('has search method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.search).toBe('function');
+    });
+    
+    it('has getStats method', () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      expect(typeof memory.getStats).toBe('function');
+    });
+  });
+});
+
+describe('6. Structure - Utility Exports', () => {
+  
+  describe('countTokens', () => {
+    it('is a function', () => {
+      expect(typeof countTokens).toBe('function');
+    });
+    
+    it('returns positive number for non-empty string', () => {
+      const tokens = countTokens('hello world');
+      expect(typeof tokens).toBe('number');
+      expect(tokens).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('estimateTokens', () => {
+    it('is a function', () => {
+      expect(typeof estimateTokens).toBe('function');
+    });
+  });
+});
+
+describe('7. Structure - Factory Exports', () => {
+  
+  describe('createA3MRouter', () => {
+    it('is a function', () => {
+      expect(typeof createA3MRouter).toBe('function');
+    });
+    
+    it('returns an object', () => {
+      const router = createA3MRouter({});
+      expect(typeof router).toBe('object');
+    });
+    
+    it('returns object with route function', () => {
+      const router = createA3MRouter({});
+      expect(typeof router.route).toBe('function');
+    });
+    
+    it('returns object with costTracker', () => {
+      const router = createA3MRouter({});
+      expect(router.costTracker).toBeTruthy();
+    });
+    
+    it('returns object with memoryTree', () => {
+      const router = createA3MRouter({});
+      expect(router.memoryTree).toBeTruthy();
+    });
+  });
+});

package/test-council/2-edge-case-tests.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Edge Case Tests - Failure Modes, Boundaries, and Error Paths
+ * 
+ * Comprehensive tests for edge cases, error conditions, and boundary values.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Import modules
+const {
+  routeQuery,
+  routeBatch,
+  extractQueryFeatures,
+  countTokens,
+  MemoryTree,
+  ProviderRetryHandler,
+  CostTracker,
+  createA3MRouter,
+} = require('../dist/index.js');
+
+// ============================================================
+// EDGE CASE TESTS - EMPTY AND NULL INPUTS
+// ============================================================
+
+describe('1. Edge Cases - Empty and Null Inputs', () => {
+  
+  describe('routeQuery with empty/null inputs', () => {
+    it('handles empty string', () => {
+      const result = routeQuery('');
+      expect(result.primary_model).toBeTruthy();
+    });
+    
+    it('handles whitespace-only string', () => {
+      const result = routeQuery('   \n\t  ');
+      expect(result.primary_model).toBeTruthy();
+    });
+  });
+  
+  describe('routeBatch with empty inputs', () => {
+    it('handles empty array', () => {
+      const results = routeBatch([]);
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(0);
+    });
+    
+    it('handles array with empty strings', () => {
+      const results = routeBatch(['', '', '']);
+      expect(results.length).toBe(3);
+    });
+  });
+  
+  describe('countTokens with empty inputs', () => {
+    it('handles empty string', () => {
+      const tokens = countTokens('');
+      expect(typeof tokens).toBe('number');
+      expect(tokens).toBeGreaterThanOrEqual(0);
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - BOUNDARY VALUES
+// ============================================================
+
+describe('2. Edge Cases - Boundary Values', () => {
+  
+  describe('routeQuery with extreme lengths', () => {
+    it('handles single character', () => {
+      const result = routeQuery('x');
+      expect(result.primary_model).toBeTruthy();
+    });
+    
+    it('handles very long query', () => {
+      const longQuery = 'a'.repeat(10000);
+      const result = routeQuery(longQuery);
+      expect(result.primary_model).toBeTruthy();
+    });
+  });
+  
+  describe('MemoryTree with boundary sizes', () => {
+    it('handles maxSize of 0', () => {
+      const memory = new MemoryTree({ maxSize: 0 });
+      memory.add('test', { tags: [] });
+      expect(memory.getStats()).toBeTruthy();
+    });
+    
+    it('handles maxSize of 1', () => {
+      const memory = new MemoryTree({ maxSize: 1 });
+      memory.add('test1', { tags: [] });
+      memory.add('test2', { tags: [] });
+      expect(memory.getStats()).toBeTruthy();
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - ERROR HANDLING
+// ============================================================
+
+describe('3. Edge Cases - Error Handling', () => {
+  
+  describe('ProviderRetryHandler errors', () => {
+    let handler: ProviderRetryHandler;
+    
+    beforeEach(() => {
+      handler = new ProviderRetryHandler();
+    });
+    
+    it('isRetryableError returns false for null', () => {
+      expect(handler.isRetryableError(null)).toBe(false);
+    });
+    
+    it('isRetryableError returns false for undefined', () => {
+      expect(handler.isRetryableError(undefined)).toBe(false);
+    });
+    
+    it('isRetryableError returns false for 400 error', () => {
+      expect(handler.isRetryableError({ status: 400 })).toBe(false);
+    });
+    
+    it('isRetryableError returns true for 429 rate limit', () => {
+      expect(handler.isRetryableError({ status: 429 })).toBe(true);
+    });
+    
+    it('isRetryableError returns true for 500 server error', () => {
+      expect(handler.isRetryableError({ status: 500 })).toBe(true);
+    });
+    
+    it('isRetryableError returns true for ECONNRESET', () => {
+      expect(handler.isRetryableError({ code: 'ECONNRESET' })).toBe(true);
+    });
+    
+    it('isRetryableError returns true for ETIMEDOUT', () => {
+      expect(handler.isRetryableError({ code: 'ETIMEDOUT' })).toBe(true);
+    });
+    
+    it('isRateLimitError detects 429 in status', () => {
+      expect(handler.isRateLimitError({ status: 429 })).toBe(true);
+    });
+    
+    it('isRateLimitError returns false for 200', () => {
+      expect(handler.isRateLimitError({ status: 200 })).toBe(false);
+    });
+  });
+  
+  describe('Retry backoff calculations', () => {
+    let handler: ProviderRetryHandler;
+    
+    beforeEach(() => {
+      handler = new ProviderRetryHandler();
+    });
+    
+    it('calculateBackoffDelay returns positive number', () => {
+      const config = {
+        maxRetries: 3,
+        initialDelayMs: 1000,
+        maxDelayMs: 30000,
+        backoffMultiplier: 2,
+        retryableErrors: ['ECONNRESET'],
+      };
+      const delay = handler.calculateBackoffDelay(0, config);
+      expect(delay).toBeGreaterThan(0);
+    });
+    
+    it('calculateBackoffDelay caps at maxDelayMs', () => {
+      const config = {
+        maxRetries: 10,
+        initialDelayMs: 1000,
+        maxDelayMs: 5000,
+        backoffMultiplier: 2,
+        retryableErrors: ['ECONNRESET'],
+      };
+      const delay = handler.calculateBackoffDelay(100, config);
+      expect(delay).toBeLessThanOrEqual(5000);
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - TIMEOUT AND CONCURRENCY
+// ============================================================
+
+describe('4. Edge Cases - Timeout and Concurrency', () => {
+  
+  describe('executeWithRetry timeout behavior', () => {
+    let handler: ProviderRetryHandler;
+    
+    beforeEach(() => {
+      handler = new ProviderRetryHandler();
+    });
+    
+    it('succeeds on first attempt', async () => {
+      const fn = vi.fn().mockResolvedValue('success');
+      const result = await handler.executeWithRetry('groq', fn);
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+    
+    it('retries on transient errors', async () => {
+      const fn = vi.fn()
+        .mockRejectedValueOnce({ code: 'ECONNRESET' })
+        .mockResolvedValue('success');
+      
+      const result = await handler.executeWithRetry('groq', fn);
+      expect(result).toBe('success');
+      expect(fn).toHaveBeenCalledTimes(2);
+    });
+    
+    it('fails after exhausting retries', async () => {
+      const fn = vi.fn().mockRejectedValue({ code: 'ECONNRESET' });
+      
+      await expect(
+        handler.executeWithRetry('groq', fn)
+      ).rejects.toThrow();
+    });
+    
+    it('does not retry non-retryable errors', async () => {
+      const fn = vi.fn().mockRejectedValue({ status: 401 });
+      
+      await expect(
+        handler.executeWithRetry('groq', fn)
+      ).rejects.toThrow();
+      expect(fn).toHaveBeenCalledTimes(1);
+    });
+  });
+  
+  describe('MemoryTree concurrent access', () => {
+    it('handles concurrent add operations', async () => {
+      const memory = new MemoryTree({ maxSize: 1000 });
+      
+      await Promise.all(
+        Array(50).fill(null).map((_, i) => 
+          memory.add(`entry ${i}`)
+        )
+      );
+      
+      const results = memory.search('entry');
+      expect(Array.isArray(results)).toBe(true);
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - SPECIAL INPUTS
+// ============================================================
+
+describe('5. Edge Cases - Special Input Types', () => {
+  
+  describe('Unicode handling', () => {
+    it('handles Japanese text', () => {
+      const result = routeQuery('こんにちは世界');
+      expect(result.primary_model).toBeTruthy();
+    });
+    
+    it('handles Chinese text', () => {
+      const result = routeQuery('你好世界');
+      expect(result.primary_model).toBeTruthy();
+    });
+    
+    it('handles emoji', () => {
+      const result = routeQuery('Hello 👋🌍🎉');
+      expect(result.primary_model).toBeTruthy();
+    });
+  });
+  
+  describe('Code snippet handling', () => {
+    it('handles JavaScript code', () => {
+      const result = routeQuery('function test() { return 42; }');
+      expect(result.primary_model).toBeTruthy();
+    });
+    
+    it('handles SQL code', () => {
+      const result = routeQuery('SELECT * FROM users WHERE id = 1');
+      expect(result.primary_model).toBeTruthy();
+    });
+  });
+  
+  describe('Translation detection', () => {
+    it('detects translation queries', () => {
+      const features = extractQueryFeatures('Translate hello to French');
+      expect(features.is_translation).toBe(true);
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - STATE MANAGEMENT
+// ============================================================
+
+describe('6. Edge Cases - State Management', () => {
+  
+  describe('MemoryTree state', () => {
+    it('persists state across operations', async () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      
+      await memory.add('stateful entry');
+      const results1 = memory.search('stateful');
+      expect(Array.isArray(results1)).toBe(true);
+      
+      const results2 = memory.search('stateful');
+      expect(results2.length).toBe(results1.length);
+    });
+    
+    it('getStats returns accurate stats', async () => {
+      const memory = new MemoryTree({ maxSize: 100 });
+      
+      await memory.add('entry 1');
+      await memory.add('entry 2');
+      
+      const stats = memory.getStats();
+      expect(stats.totalChunks).toBeGreaterThan(0);
+    });
+  });
+  
+  describe('Retry handler state', () => {
+    let handler: ProviderRetryHandler;
+    
+    beforeEach(() => {
+      handler = new ProviderRetryHandler();
+    });
+    
+    it('getStats starts at zero', () => {
+      const stats = handler.getStats('groq');
+      expect(stats.totalRequests).toBe(0);
+    });
+    
+    it('resetStats clears stats', () => {
+      handler.resetStats();
+      const allStats = handler.getAllStats();
+      for (const stats of Object.values(allStats)) {
+        expect(stats.totalRequests).toBe(0);
+      }
+    });
+  });
+});
+
+// ============================================================
+// EDGE CASE TESTS - LARGE BATCH PROCESSING
+// ============================================================
+
+describe('7. Edge Cases - Memory and Resource Limits', () => {
+  
+  describe('Large batch processing', () => {
+    it('handles 1000-item batch', () => {
+      const queries = Array(1000).fill('test query');
+      const results = routeBatch(queries);
+      expect(results.length).toBe(1000);
+    });
+  });
+  
+  describe('Rapid successive calls', () => {
+    it('handles 100 rapid calls', async () => {
+      const promises = Array(100).fill(null).map(() => 
+        Promise.resolve(routeQuery('test'))
+      );
+      
+      const results = await Promise.all(promises);
+      expect(results.length).toBe(100);
+    });
+  });
+});