lynkr 7.2.5 → 8.0.1

package/test/hybrid-routing-integration.test.js

@@ -1,254 +0,0 @@
-const assert = require("assert");
-const { describe, it, beforeEach, afterEach } = require("node:test");
-
-describe("Hybrid Routing Integration Tests", () => {
-  let config;
-  let databricks;
-  let metrics;
-  let originalConfig;
-
-  beforeEach(() => {
-    // Clear module cache
-    delete require.cache[require.resolve("../src/config")];
-    delete require.cache[require.resolve("../src/clients/databricks")];
-    delete require.cache[require.resolve("../src/observability/metrics")];
-    delete require.cache[require.resolve("../src/clients/routing")];
-
-    // Store original config
-    originalConfig = { ...process.env };
-
-    // Set up test environment
-    process.env.DATABRICKS_API_KEY = "test-key";
-    process.env.DATABRICKS_API_BASE = "http://test.databricks.com";
-    process.env.MODEL_PROVIDER = "databricks";
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = originalConfig;
-  });
-
-  describe("Configuration Validation", () => {
-    it("should use default OLLAMA_ENDPOINT when not specified", () => {
-      process.env.PREFER_OLLAMA = "true";
-      delete process.env.OLLAMA_ENDPOINT;
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      // Should use default localhost:11434
-      assert.strictEqual(config.ollama.endpoint, "http://localhost:11434");
-    });
-
-    it("should reject invalid FALLBACK_PROVIDER", () => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "invalid-provider";
-
-      assert.throws(() => {
-        require("../src/config");
-      }, /Unsupported FALLBACK_PROVIDER.*Valid options are/);
-    });
-
-    it("should reject circular fallback (ollama -> ollama)", () => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "ollama";
-
-      assert.throws(() => {
-        require("../src/config");
-      }, /FALLBACK_PROVIDER cannot be 'ollama'/);
-    });
-
-    it("should reject PREFER_OLLAMA with databricks fallback but no databricks credentials", () => {
-      process.env.MODEL_PROVIDER = "ollama";  // Set to ollama for hybrid routing scenario
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "databricks";
-      // Set to empty strings instead of deleting (dotenv.config() in config module would reload from .env)
-      process.env.DATABRICKS_API_KEY = "";
-      process.env.DATABRICKS_API_BASE = "";
-
-      // Should throw error about missing databricks credentials
-      // (Either from standard validation or hybrid routing validation)
-      assert.throws(() => {
-        require("../src/config");
-      }, /DATABRICKS_API_BASE and DATABRICKS_API_KEY/);
-    });
-
-    it("should accept valid hybrid routing configuration", () => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "databricks";
-      process.env.OLLAMA_MAX_TOOLS_FOR_ROUTING = "3"; // Override .env which sets it to 2
-      process.env.DATABRICKS_API_KEY = "test-key";
-      process.env.DATABRICKS_API_BASE = "http://test.com";
-
-      const config = require("../src/config");
-
-      assert.strictEqual(config.modelProvider.preferOllama, true);
-      assert.strictEqual(config.modelProvider.fallbackEnabled, true);
-      assert.strictEqual(config.modelProvider.ollamaMaxToolsForRouting, 3);
-      assert.strictEqual(config.modelProvider.fallbackProvider, "databricks");
-    });
-  });
-
-  describe("Metrics Recording", () => {
-    beforeEach(() => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_FALLBACK_PROVIDER = "databricks";
-
-      config = require("../src/config");
-      const metricsModule = require("../src/observability/metrics");
-      metrics = metricsModule.getMetricsCollector();
-    });
-
-    it("should record provider routing", () => {
-      metrics.recordProviderRouting("ollama");
-      metrics.recordProviderRouting("ollama");
-      metrics.recordProviderRouting("databricks");
-
-      const snapshot = metrics.getMetrics();
-
-      assert.deepStrictEqual(snapshot.routing.by_provider, {
-        ollama: 2,
-        databricks: 1,
-      });
-    });
-
-    it("should record provider success with latency", () => {
-      metrics.recordProviderSuccess("ollama", 450);
-      metrics.recordProviderSuccess("ollama", 600);
-      metrics.recordProviderSuccess("databricks", 1500);
-
-      const snapshot = metrics.getMetrics();
-
-      assert.strictEqual(snapshot.routing.successes_by_provider.ollama, 2);
-      assert.strictEqual(snapshot.routing.successes_by_provider.databricks, 1);
-      assert.strictEqual(snapshot.cost_savings.ollama_latency_ms.mean, 525);
-    });
-
-    it("should record fallback attempts with reasons", () => {
-      metrics.recordFallbackAttempt("ollama", "databricks", "circuit_breaker");
-      metrics.recordFallbackAttempt("ollama", "databricks", "timeout");
-      metrics.recordFallbackAttempt("ollama", "databricks", "timeout");
-
-      const snapshot = metrics.getMetrics();
-
-      assert.strictEqual(snapshot.fallback.attempts_total, 3);
-      assert.deepStrictEqual(snapshot.fallback.reasons, {
-        circuit_breaker: 1,
-        timeout: 2,
-      });
-    });
-
-    it("should calculate fallback success rate", () => {
-      metrics.recordFallbackAttempt("ollama", "databricks", "timeout");
-      metrics.recordFallbackSuccess(1200);
-      metrics.recordFallbackAttempt("ollama", "databricks", "timeout");
-      metrics.recordFallbackSuccess(1100);
-      metrics.recordFallbackAttempt("ollama", "databricks", "circuit_breaker");
-      metrics.recordFallbackFailure();
-
-      const snapshot = metrics.getMetrics();
-
-      assert.strictEqual(snapshot.fallback.attempts_total, 3);
-      assert.strictEqual(snapshot.fallback.successes_total, 2);
-      assert.strictEqual(snapshot.fallback.failures_total, 1);
-      assert.strictEqual(snapshot.fallback.success_rate, "66.67%");
-    });
-
-    it("should record cost savings", () => {
-      // Simulate 100 tokens input, 50 tokens output
-      // Input: 100/1M * $3 = $0.0003
-      // Output: 50/1M * $15 = $0.00075
-      // Total: $0.00105
-      metrics.recordCostSavings(0.00105);
-      metrics.recordCostSavings(0.00105);
-      metrics.recordCostSavings(0.00105);
-
-      const snapshot = metrics.getMetrics();
-
-      assert.strictEqual(snapshot.cost_savings.ollama_savings_usd, "0.0032");
-    });
-
-    it("should reset all routing metrics", () => {
-      metrics.recordProviderRouting("ollama");
-      metrics.recordProviderSuccess("ollama", 450);
-      metrics.recordFallbackAttempt("ollama", "databricks", "timeout");
-      metrics.recordFallbackSuccess(1200);
-      metrics.recordCostSavings(1.5);
-
-      metrics.reset();
-
-      const snapshot = metrics.getMetrics();
-
-      assert.deepStrictEqual(snapshot.routing.by_provider, {});
-      assert.deepStrictEqual(snapshot.routing.successes_by_provider, {});
-      assert.strictEqual(snapshot.fallback.attempts_total, 0);
-      assert.strictEqual(snapshot.fallback.successes_total, 0);
-      assert.strictEqual(snapshot.cost_savings.ollama_savings_usd, "0.0000");
-    });
-  });
-
-  describe("Helper Functions", () => {
-    it("should categorize circuit breaker errors", () => {
-      // This would need to be tested by importing the function if exported
-      // For now, we test via the integrated behavior
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-
-      config = require("../src/config");
-      const metricsModule = require("../src/observability/metrics");
-      metrics = metricsModule.getMetricsCollector();
-
-      // Simulate categorization
-      const circuitBreakerError = new Error("Circuit breaker open");
-      circuitBreakerError.name = "CircuitBreakerError";
-
-      const timeoutError = new Error("Request timeout");
-      timeoutError.code = "ETIMEDOUT";
-
-      const unavailableError = new Error("Service not available");
-      unavailableError.code = "ECONNREFUSED";
-
-      // These would be categorized in the actual invokeModel function
-      // Here we just verify the structure exists
-      assert.ok(metrics.recordFallbackAttempt);
-    });
-
-    it("should estimate cost savings correctly", () => {
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_ENDPOINT = "http://localhost:11434";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-
-      config = require("../src/config");
-      const metricsModule = require("../src/observability/metrics");
-      metrics = metricsModule.getMetricsCollector();
-
-      // Test: 1000 input tokens, 500 output tokens
-      // Input cost: 1000/1M * $3 = $0.003
-      // Output cost: 500/1M * $15 = $0.0075
-      // Total: $0.0105
-      const inputTokens = 1000;
-      const outputTokens = 500;
-      const expectedSavings =
-        (inputTokens / 1_000_000) * 3.0 + (outputTokens / 1_000_000) * 15.0;
-
-      assert.strictEqual(expectedSavings.toFixed(4), "0.0105");
-    });
-  });
-});

package/test/hybrid-routing-performance.test.js

@@ -1,418 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Hybrid Routing Performance Tests
- *
- * Measures the performance impact of the hybrid routing system:
- * - Routing decision overhead
- * - Provider determination speed
- * - Metrics collection overhead
- * - Fallback logic performance
- */
-
-const { performance } = require('perf_hooks');
-const assert = require('assert');
-
-// Color utilities
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  red: '\x1b[31m',
-  cyan: '\x1b[36m',
-};
-
-function log(message, color = 'reset') {
-  console.log(`${colors[color]}${message}${colors.reset}`);
-}
-
-function section(title) {
-  console.log('\n' + '='.repeat(70));
-  log(title, 'bright');
-  console.log('='.repeat(70));
-}
-
-function benchmark(name, iterations, fn) {
-  const start = performance.now();
-  for (let i = 0; i < iterations; i++) {
-    fn();
-  }
-  const duration = performance.now() - start;
-  const avgTime = duration / iterations;
-  const throughput = (iterations / duration) * 1000;
-
-  return { duration, avgTime, throughput };
-}
-
-// =============================================================================
-// TEST 1: Routing Decision Performance
-// =============================================================================
-function testRoutingDecisionPerformance() {
-  section('TEST 1: Routing Decision Performance');
-
-  // Clear module cache and set up environment
-  delete require.cache[require.resolve('../src/config')];
-  delete require.cache[require.resolve('../src/clients/routing')];
-
-  process.env.PREFER_OLLAMA = 'true';
-  process.env.OLLAMA_ENDPOINT = 'http://localhost:11434';
-  process.env.OLLAMA_MODEL = 'qwen2.5-coder:latest';
-  process.env.DATABRICKS_API_KEY = 'test-key';
-  process.env.DATABRICKS_API_BASE = 'http://test.com';
-
-  const routing = require('../src/clients/routing');
-
-  log('\n📊 Benchmarking routing decisions...', 'cyan');
-
-  // Test 1: Simple request (0 tools)
-  const simplePayload = {
-    messages: [{ role: 'user', content: 'test' }],
-    tools: []
-  };
-
-  const { duration: simpleTime, throughput: simpleThroughput } = benchmark(
-    'Simple request routing',
-    100000,
-    () => routing.determineProvider(simplePayload)
-  );
-
-  log(`⏱️  Simple request: ${simpleTime.toFixed(2)}ms for 100k decisions`, 'cyan');
-  log(`   Average: ${(simpleTime / 100000).toFixed(6)}ms per decision`, 'blue');
-  log(`   Throughput: ${simpleThroughput.toLocaleString()} decisions/sec`, 'green');
-
-  // Test 2: Complex request (5 tools)
-  const complexPayload = {
-    messages: [{ role: 'user', content: 'test' }],
-    tools: [
-      { name: 'tool1' }, { name: 'tool2' }, { name: 'tool3' },
-      { name: 'tool4' }, { name: 'tool5' }
-    ]
-  };
-
-  const { duration: complexTime, throughput: complexThroughput } = benchmark(
-    'Complex request routing',
-    100000,
-    () => routing.determineProvider(complexPayload)
-  );
-
-  log(`⏱️  Complex request: ${complexTime.toFixed(2)}ms for 100k decisions`, 'cyan');
-  log(`   Average: ${(complexTime / 100000).toFixed(6)}ms per decision`, 'blue');
-  log(`   Throughput: ${complexThroughput.toLocaleString()} decisions/sec`, 'green');
-
-  // Test 3: Tool capability check
-  const toolCapabilityPayload = {
-    messages: [{ role: 'user', content: 'test' }],
-    tools: [{ name: 'tool1' }]
-  };
-
-  const { duration: toolCheckTime, throughput: toolCheckThroughput } = benchmark(
-    'Tool capability check',
-    100000,
-    () => routing.determineProvider(toolCapabilityPayload)
-  );
-
-  log(`⏱️  Tool capability check: ${toolCheckTime.toFixed(2)}ms for 100k decisions`, 'cyan');
-  log(`   Average: ${(toolCheckTime / 100000).toFixed(6)}ms per decision`, 'blue');
-  log(`   Throughput: ${toolCheckThroughput.toLocaleString()} decisions/sec`, 'green');
-
-  // Analysis
-  log('\n📈 Analysis:', 'yellow');
-  log(`   Routing adds <0.01ms per request (negligible overhead)`, 'green');
-  log(`   Throughput: ${simpleThroughput.toLocaleString()} decisions/sec`, 'green');
-  log(`   ✅ Routing is extremely fast and won't impact request latency`, 'green');
-
-  return {
-    simpleTime,
-    complexTime,
-    toolCheckTime,
-    avgDecisionTime: (simpleTime + complexTime + toolCheckTime) / 3 / 100000
-  };
-}
-
-// =============================================================================
-// TEST 2: Metrics Collection Overhead
-// =============================================================================
-function testMetricsOverhead() {
-  section('TEST 2: Metrics Collection Overhead');
-
-  delete require.cache[require.resolve('../src/observability/metrics')];
-  const { getMetricsCollector } = require('../src/observability/metrics');
-  const metrics = getMetricsCollector();
-
-  log('\n📊 Benchmarking metrics operations...', 'cyan');
-
-  // Test recording provider routing
-  const { duration: routingTime, throughput: routingThroughput } = benchmark(
-    'Record provider routing',
-    100000,
-    () => metrics.recordProviderRouting('ollama')
-  );
-
-  log(`⏱️  Provider routing: ${routingTime.toFixed(2)}ms for 100k recordings`, 'cyan');
-  log(`   Average: ${(routingTime / 100000).toFixed(6)}ms per record`, 'blue');
-  log(`   Throughput: ${routingThroughput.toLocaleString()} ops/sec`, 'green');
-
-  // Test recording provider success
-  const { duration: successTime, throughput: successThroughput } = benchmark(
-    'Record provider success',
-    100000,
-    () => metrics.recordProviderSuccess('ollama', 450)
-  );
-
-  log(`⏱️  Provider success: ${successTime.toFixed(2)}ms for 100k recordings`, 'cyan');
-  log(`   Average: ${(successTime / 100000).toFixed(6)}ms per record`, 'blue');
-  log(`   Throughput: ${successThroughput.toLocaleString()} ops/sec`, 'green');
-
-  // Test recording fallback attempts
-  const { duration: fallbackTime, throughput: fallbackThroughput } = benchmark(
-    'Record fallback attempt',
-    100000,
-    () => metrics.recordFallbackAttempt('ollama', 'databricks', 'timeout')
-  );
-
-  log(`⏱️  Fallback attempts: ${fallbackTime.toFixed(2)}ms for 100k recordings`, 'cyan');
-  log(`   Average: ${(fallbackTime / 100000).toFixed(6)}ms per record`, 'blue');
-  log(`   Throughput: ${fallbackThroughput.toLocaleString()} ops/sec`, 'green');
-
-  // Test cost savings recording
-  const { duration: costTime, throughput: costThroughput } = benchmark(
-    'Record cost savings',
-    100000,
-    () => metrics.recordCostSavings(0.001)
-  );
-
-  log(`⏱️  Cost savings: ${costTime.toFixed(2)}ms for 100k recordings`, 'cyan');
-  log(`   Average: ${(costTime / 100000).toFixed(6)}ms per record`, 'blue');
-  log(`   Throughput: ${costThroughput.toLocaleString()} ops/sec`, 'green');
-
-  // Analysis
-  const avgMetricsTime = (routingTime + successTime + fallbackTime + costTime) / 4 / 100000;
-  log('\n📈 Analysis:', 'yellow');
-  log(`   Average metrics overhead: ${avgMetricsTime.toFixed(6)}ms per operation`, 'green');
-  log(`   ✅ Metrics collection is extremely lightweight`, 'green');
-
-  return {
-    routingTime,
-    successTime,
-    fallbackTime,
-    costTime,
-    avgMetricsTime
-  };
-}
-
-// =============================================================================
-// TEST 3: Combined Hybrid Routing Stack
-// =============================================================================
-function testCombinedStack() {
-  section('TEST 3: Combined Hybrid Routing Stack Performance');
-
-  delete require.cache[require.resolve('../src/config')];
-  delete require.cache[require.resolve('../src/clients/routing')];
-  delete require.cache[require.resolve('../src/observability/metrics')];
-
-  process.env.PREFER_OLLAMA = 'true';
-  process.env.OLLAMA_ENDPOINT = 'http://localhost:11434';
-  process.env.OLLAMA_MODEL = 'qwen2.5-coder:latest';
-
-  const routing = require('../src/clients/routing');
-  const { getMetricsCollector } = require('../src/observability/metrics');
-
-  log('\n📊 Benchmarking complete routing + metrics stack...', 'cyan');
-
-  // Simulate full routing decision + metrics recording
-  const payload = {
-    messages: [{ role: 'user', content: 'test' }],
-    tools: []
-  };
-
-  const { duration: fullTime, throughput: fullThroughput } = benchmark(
-    'Full routing stack',
-    50000,
-    () => {
-      const metrics = getMetricsCollector();
-      const provider = routing.determineProvider(payload);
-      metrics.recordProviderRouting(provider);
-      metrics.recordProviderSuccess(provider, 450);
-    }
-  );
-
-  log(`⏱️  Full stack: ${fullTime.toFixed(2)}ms for 50k operations`, 'cyan');
-  log(`   Average: ${(fullTime / 50000).toFixed(6)}ms per request`, 'blue');
-  log(`   Throughput: ${fullThroughput.toLocaleString()} ops/sec`, 'green');
-
-  // Analysis
-  log('\n📈 Analysis:', 'yellow');
-  const overhead = (fullTime / 50000);
-  log(`   Total routing + metrics overhead: ${overhead.toFixed(6)}ms`, 'green');
-  log(`   ✅ Negligible impact on request latency (<0.02ms)`, 'green');
-
-  return {
-    fullTime,
-    fullThroughput,
-    overhead
-  };
-}
-
-// =============================================================================
-// TEST 4: Helper Function Performance
-// =============================================================================
-function testHelperFunctions() {
-  section('TEST 4: Helper Function Performance');
-
-  delete require.cache[require.resolve('../src/clients/databricks')];
-
-  log('\n📊 Benchmarking helper functions...', 'cyan');
-
-  // Test categorizeFailure (we'll simulate it)
-  const categorizeFailure = (error) => {
-    if (error.name === 'CircuitBreakerError' || error.code === 'circuit_breaker_open') {
-      return 'circuit_breaker';
-    }
-    if (error.name === 'AbortError' || error.code === 'ETIMEDOUT') {
-      return 'timeout';
-    }
-    if (error.message?.includes('not configured') ||
-        error.message?.includes('not available') ||
-        error.code === 'ECONNREFUSED') {
-      return 'service_unavailable';
-    }
-    return 'error';
-  };
-
-  const testErrors = [
-    { name: 'CircuitBreakerError', message: 'Circuit breaker open' },
-    { name: 'AbortError', message: 'Timeout' },
-    { code: 'ECONNREFUSED', message: 'Connection refused' },
-    { message: 'Generic error' }
-  ];
-
-  const { duration: categorizeTime, throughput: categorizeThroughput } = benchmark(
-    'Categorize failure',
-    100000,
-    () => {
-      testErrors.forEach(err => categorizeFailure(err));
-    }
-  );
-
-  log(`⏱️  Categorize failure: ${categorizeTime.toFixed(2)}ms for 400k operations`, 'cyan');
-  log(`   Average: ${(categorizeTime / 400000).toFixed(6)}ms per categorization`, 'blue');
-  log(`   Throughput: ${(categorizeThroughput * 4).toLocaleString()} ops/sec`, 'green');
-
-  // Test estimateCostSavings
-  const estimateCostSavings = (inputTokens, outputTokens) => {
-    const INPUT_COST_PER_1M = 3.00;
-    const OUTPUT_COST_PER_1M = 15.00;
-    const inputCost = (inputTokens / 1_000_000) * INPUT_COST_PER_1M;
-    const outputCost = (outputTokens / 1_000_000) * OUTPUT_COST_PER_1M;
-    return inputCost + outputCost;
-  };
-
-  const { duration: costCalcTime, throughput: costCalcThroughput } = benchmark(
-    'Estimate cost savings',
-    100000,
-    () => estimateCostSavings(1000, 500)
-  );
-
-  log(`⏱️  Cost estimation: ${costCalcTime.toFixed(2)}ms for 100k calculations`, 'cyan');
-  log(`   Average: ${(costCalcTime / 100000).toFixed(6)}ms per calculation`, 'blue');
-  log(`   Throughput: ${costCalcThroughput.toLocaleString()} ops/sec`, 'green');
-
-  log('\n📈 Analysis:', 'yellow');
-  log(`   Helper functions add negligible overhead (<0.001ms)`, 'green');
-  log(`   ✅ No performance impact from utility functions`, 'green');
-
-  return {
-    categorizeTime,
-    costCalcTime
-  };
-}
-
-// =============================================================================
-// FINAL REPORT
-// =============================================================================
-function printFinalReport(results) {
-  section('📊 HYBRID ROUTING PERFORMANCE SUMMARY');
-
-  console.log('\n');
-  console.log('┌────────────────────────────────────────────────────────────┐');
-  console.log('│              HYBRID ROUTING PERFORMANCE                    │');
-  console.log('├────────────────────────────────────────────────────────────┤');
-
-  log(`│ 1. Routing Decisions                                       │`, 'bright');
-  log(`│    Average: ${results.routing.avgDecisionTime.toFixed(6)}ms per decision           │`, 'cyan');
-  log(`│    Overhead: ${colors.green}Negligible (<0.01ms)${colors.reset}                           │`);
-
-  console.log('├────────────────────────────────────────────────────────────┤');
-
-  log(`│ 2. Metrics Collection                                      │`, 'bright');
-  log(`│    Average: ${results.metrics.avgMetricsTime.toFixed(6)}ms per operation          │`, 'cyan');
-  log(`│    Overhead: ${colors.green}Negligible (<0.01ms)${colors.reset}                           │`);
-
-  console.log('├────────────────────────────────────────────────────────────┤');
-
-  log(`│ 3. Full Routing Stack                                      │`, 'bright');
-  log(`│    Average: ${results.combined.overhead.toFixed(6)}ms per request              │`, 'cyan');
-  log(`│    Throughput: ${results.combined.fullThroughput.toLocaleString()} ops/sec                │`, 'cyan');
-  log(`│    Impact: ${colors.green}Negligible (<0.02ms)${colors.reset}                            │`);
-
-  console.log('├────────────────────────────────────────────────────────────┤');
-
-  log(`│ 4. Helper Functions                                        │`, 'bright');
-  log(`│    Overhead: ${colors.green}Negligible (<0.001ms)${colors.reset}                          │`);
-
-  console.log('└────────────────────────────────────────────────────────────┘');
-
-  // Overall assessment
-  console.log('\n');
-  log('🏆 Overall Performance Assessment:', 'bright');
-  log('   ✅ Routing overhead: <0.01ms per request', 'green');
-  log('   ✅ Metrics overhead: <0.01ms per request', 'green');
-  log('   ✅ Combined overhead: <0.02ms per request', 'green');
-  log('   ✅ No measurable impact on API latency', 'green');
-
-  console.log('\n📈 Expected Real-World Performance:');
-  log('   • Ollama (local): ~500-1000ms per request', 'cyan');
-  log('   • Cloud (Databricks): ~1500-2000ms per request', 'cyan');
-  log('   • Routing overhead: ~0.02ms (0.001-0.002% of total)', 'cyan');
-  log('   • Latency savings with Ollama: 40-60% faster', 'green');
-  log('   • Cost savings with Ollama: 100% (free)', 'green');
-
-  console.log('\n');
-  log('🚀 Conclusion: Hybrid routing adds negligible overhead while', 'bright');
-  log('   providing significant latency and cost improvements!', 'bright');
-  console.log('\n');
-}
-
-// =============================================================================
-// RUN ALL TESTS
-// =============================================================================
-async function runAllTests() {
-  log('\n🚀 Starting Hybrid Routing Performance Test Suite\n', 'bright');
-
-  try {
-    const results = {
-      routing: testRoutingDecisionPerformance(),
-      metrics: testMetricsOverhead(),
-      combined: testCombinedStack(),
-      helpers: testHelperFunctions()
-    };
-
-    printFinalReport(results);
-
-    log('\n✅ All performance tests completed successfully!\n', 'green');
-    process.exit(0);
-  } catch (error) {
-    log(`\n❌ Performance test suite failed: ${error.message}\n`, 'red');
-    console.error(error);
-    process.exit(1);
-  }
-}
-
-// Run tests
-if (require.main === module) {
-  runAllTests();
-}
-
-module.exports = { runAllTests };