lynkr 7.2.5 → 8.0.0

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

@@ -56,15 +56,20 @@ function testRoutingDecisionPerformance() {
   delete require.cache[require.resolve('../src/config')];
   delete require.cache[require.resolve('../src/clients/routing')];
 
-  process.env.PREFER_OLLAMA = 'true';
+  process.env.MODEL_PROVIDER = 'ollama';
   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';
+  // Set TIER_* to empty = tier routing disabled, determineProviderSync returns static provider
+  process.env.TIER_SIMPLE = "";
+  process.env.TIER_MEDIUM = "";
+  process.env.TIER_COMPLEX = "";
+  process.env.TIER_REASONING = "";
 
   const routing = require('../src/clients/routing');
 
-  log('\n📊 Benchmarking routing decisions...', 'cyan');
+  log('\n Benchmarking routing decisions...', 'cyan');
 
   // Test 1: Simple request (0 tools)
   const simplePayload = {
@@ -75,10 +80,10 @@ function testRoutingDecisionPerformance() {
   const { duration: simpleTime, throughput: simpleThroughput } = benchmark(
     'Simple request routing',
     100000,
-    () => routing.determineProvider(simplePayload)
+    () => routing.determineProviderSync(simplePayload)
   );
 
-  log(`⏱️  Simple request: ${simpleTime.toFixed(2)}ms for 100k decisions`, 'cyan');
+  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');
 
@@ -94,10 +99,10 @@ function testRoutingDecisionPerformance() {
   const { duration: complexTime, throughput: complexThroughput } = benchmark(
     'Complex request routing',
     100000,
-    () => routing.determineProvider(complexPayload)
+    () => routing.determineProviderSync(complexPayload)
   );
 
-  log(`⏱️  Complex request: ${complexTime.toFixed(2)}ms for 100k decisions`, 'cyan');
+  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');
 
@@ -110,18 +115,18 @@ function testRoutingDecisionPerformance() {
   const { duration: toolCheckTime, throughput: toolCheckThroughput } = benchmark(
     'Tool capability check',
     100000,
-    () => routing.determineProvider(toolCapabilityPayload)
+    () => routing.determineProviderSync(toolCapabilityPayload)
   );
 
-  log(`⏱️  Tool capability check: ${toolCheckTime.toFixed(2)}ms for 100k decisions`, 'cyan');
+  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('\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');
+  log(`   Routing is extremely fast and won't impact request latency`, 'green');
 
   return {
     simpleTime,
@@ -141,7 +146,7 @@ function testMetricsOverhead() {
   const { getMetricsCollector } = require('../src/observability/metrics');
   const metrics = getMetricsCollector();
 
-  log('\n📊 Benchmarking metrics operations...', 'cyan');
+  log('\n Benchmarking metrics operations...', 'cyan');
 
   // Test recording provider routing
   const { duration: routingTime, throughput: routingThroughput } = benchmark(
@@ -150,7 +155,7 @@ function testMetricsOverhead() {
     () => metrics.recordProviderRouting('ollama')
   );
 
-  log(`⏱️  Provider routing: ${routingTime.toFixed(2)}ms for 100k recordings`, 'cyan');
+  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');
 
@@ -161,7 +166,7 @@ function testMetricsOverhead() {
     () => metrics.recordProviderSuccess('ollama', 450)
   );
 
-  log(`⏱️  Provider success: ${successTime.toFixed(2)}ms for 100k recordings`, 'cyan');
+  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');
 
@@ -172,7 +177,7 @@ function testMetricsOverhead() {
     () => metrics.recordFallbackAttempt('ollama', 'databricks', 'timeout')
   );
 
-  log(`⏱️  Fallback attempts: ${fallbackTime.toFixed(2)}ms for 100k recordings`, 'cyan');
+  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');
 
@@ -183,15 +188,15 @@ function testMetricsOverhead() {
     () => metrics.recordCostSavings(0.001)
   );
 
-  log(`⏱️  Cost savings: ${costTime.toFixed(2)}ms for 100k recordings`, 'cyan');
+  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('\n Analysis:', 'yellow');
   log(`   Average metrics overhead: ${avgMetricsTime.toFixed(6)}ms per operation`, 'green');
-  log(`   ✅ Metrics collection is extremely lightweight`, 'green');
+  log(`   Metrics collection is extremely lightweight`, 'green');
 
   return {
     routingTime,
@@ -212,14 +217,19 @@ function testCombinedStack() {
   delete require.cache[require.resolve('../src/clients/routing')];
   delete require.cache[require.resolve('../src/observability/metrics')];
 
-  process.env.PREFER_OLLAMA = 'true';
+  process.env.MODEL_PROVIDER = 'ollama';
   process.env.OLLAMA_ENDPOINT = 'http://localhost:11434';
   process.env.OLLAMA_MODEL = 'qwen2.5-coder:latest';
+  // Set TIER_* to empty = static routing via determineProviderSync
+  process.env.TIER_SIMPLE = "";
+  process.env.TIER_MEDIUM = "";
+  process.env.TIER_COMPLEX = "";
+  process.env.TIER_REASONING = "";
 
   const routing = require('../src/clients/routing');
   const { getMetricsCollector } = require('../src/observability/metrics');
 
-  log('\n📊 Benchmarking complete routing + metrics stack...', 'cyan');
+  log('\n Benchmarking complete routing + metrics stack...', 'cyan');
 
   // Simulate full routing decision + metrics recording
   const payload = {
@@ -232,21 +242,21 @@ function testCombinedStack() {
     50000,
     () => {
       const metrics = getMetricsCollector();
-      const provider = routing.determineProvider(payload);
+      const provider = routing.determineProviderSync(payload);
       metrics.recordProviderRouting(provider);
       metrics.recordProviderSuccess(provider, 450);
     }
   );
 
-  log(`⏱️  Full stack: ${fullTime.toFixed(2)}ms for 50k operations`, 'cyan');
+  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');
+  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');
+  log(`   Negligible impact on request latency (<0.02ms)`, 'green');
 
   return {
     fullTime,
@@ -263,7 +273,7 @@ function testHelperFunctions() {
 
   delete require.cache[require.resolve('../src/clients/databricks')];
 
-  log('\n📊 Benchmarking helper functions...', 'cyan');
+  log('\n Benchmarking helper functions...', 'cyan');
 
   // Test categorizeFailure (we'll simulate it)
   const categorizeFailure = (error) => {
@@ -296,7 +306,7 @@ function testHelperFunctions() {
     }
   );
 
-  log(`⏱️  Categorize failure: ${categorizeTime.toFixed(2)}ms for 400k operations`, 'cyan');
+  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');
 
@@ -315,13 +325,13 @@ function testHelperFunctions() {
     () => estimateCostSavings(1000, 500)
   );
 
-  log(`⏱️  Cost estimation: ${costCalcTime.toFixed(2)}ms for 100k calculations`, 'cyan');
+  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('\n Analysis:', 'yellow');
   log(`   Helper functions add negligible overhead (<0.001ms)`, 'green');
-  log(`   ✅ No performance impact from utility functions`, 'green');
+  log(`   No performance impact from utility functions`, 'green');
 
   return {
     categorizeTime,
@@ -333,54 +343,54 @@ function testHelperFunctions() {
 // FINAL REPORT
 // =============================================================================
 function printFinalReport(results) {
-  section('📊 HYBRID ROUTING PERFORMANCE SUMMARY');
+  section('HYBRID ROUTING PERFORMANCE SUMMARY');
 
   console.log('\n');
-  console.log('┌────────────────────────────────────────────────────────────┐');
-  console.log('│              HYBRID ROUTING PERFORMANCE                    │');
-  console.log('├────────────────────────────────────────────────────────────┤');
+  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}                           │`);
+  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('├────────────────────────────────────────────────────────────┤');
+  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}                           │`);
+  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('├────────────────────────────────────────────────────────────┤');
+  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}                            │`);
+  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('├────────────────────────────────────────────────────────────┤');
+  console.log('+---------------------------------------------------------+');
 
-  log(`│ 4. Helper Functions                                        │`, 'bright');
-  log(`│    Overhead: ${colors.green}Negligible (<0.001ms)${colors.reset}                          │`);
+  log(`| 4. Helper Functions                                     |`, 'bright');
+  log(`|    Overhead: ${colors.green}Negligible (<0.001ms)${colors.reset}                    |`);
 
-  console.log('└────────────────────────────────────────────────────────────┘');
+  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');
+  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('Conclusion: Hybrid routing adds negligible overhead while', 'bright');
   log('   providing significant latency and cost improvements!', 'bright');
   console.log('\n');
 }
@@ -389,7 +399,7 @@ function printFinalReport(results) {
 // RUN ALL TESTS
 // =============================================================================
 async function runAllTests() {
-  log('\n🚀 Starting Hybrid Routing Performance Test Suite\n', 'bright');
+  log('\n Starting Hybrid Routing Performance Test Suite\n', 'bright');
 
   try {
     const results = {
@@ -401,10 +411,10 @@ async function runAllTests() {
 
     printFinalReport(results);
 
-    log('\n✅ All performance tests completed successfully!\n', 'green');
+    log('\n All performance tests completed successfully!\n', 'green');
     process.exit(0);
   } catch (error) {
-    log(`\n❌ Performance test suite failed: ${error.message}\n`, 'red');
+    log(`\n Performance test suite failed: ${error.message}\n`, 'red');
     console.error(error);
     process.exit(1);
   }

package/test/llamacpp-integration.test.js

@@ -11,6 +11,12 @@ describe("llama.cpp Integration", () => {
     delete require.cache[require.resolve("../src/config")];
     delete require.cache[require.resolve("../src/clients/routing")];
     delete require.cache[require.resolve("../src/clients/openrouter-utils")];
+
+    // Prevent .env TIER_* values from being picked up by dotenv
+    process.env.TIER_SIMPLE = "";
+    process.env.TIER_MEDIUM = "";
+    process.env.TIER_COMPLEX = "";
+    process.env.TIER_REASONING = "";
   });
 
   afterEach(() => {
@@ -104,33 +110,46 @@ describe("llama.cpp Integration", () => {
   });
 
   describe("Routing", () => {
-    it("should route to llamacpp when MODEL_PROVIDER is llamacpp", () => {
+    it("should route to llamacpp when MODEL_PROVIDER is llamacpp", async () => {
       process.env.MODEL_PROVIDER = "llamacpp";
       process.env.LLAMACPP_ENDPOINT = "http://localhost:8080";
-      process.env.PREFER_OLLAMA = "false";
 
       const config = require("../src/config");
       const routing = require("../src/clients/routing");
 
       const payload = { messages: [{ role: "user", content: "test" }] };
-      const provider = routing.determineProvider(payload);
+      const result = await routing.determineProviderSmart(payload);
 
-      assert.strictEqual(provider, "llamacpp");
+      assert.strictEqual(result.provider, "llamacpp");
+      assert.strictEqual(result.method, "static");
     });
 
-    it("should route to llamacpp for moderate tool count when other providers not configured", () => {
-      // This test is skipped because llamacpp is checked AFTER openrouter/openai/azure in routing
-      // and those providers may be present in the test environment
-      // llama.cpp will be used when it's the PRIMARY provider or when it's the only option
+    it("should return static routing from determineProviderSmart when tiers disabled", async () => {
+      process.env.MODEL_PROVIDER = "llamacpp";
+      process.env.LLAMACPP_ENDPOINT = "http://localhost:8080";
+
+      const config = require("../src/config");
+      const routing = require("../src/clients/routing");
+
+      const payload = { messages: [{ role: "user", content: "test" }] };
+      const result = await routing.determineProviderSmart(payload);
+
+      assert.strictEqual(result.provider, "llamacpp");
+      assert.strictEqual(result.method, "static");
+      assert.strictEqual(result.reason, "tier_routing_disabled");
     });
 
     it("should throw error when llamacpp is set as FALLBACK_PROVIDER", () => {
       process.env.MODEL_PROVIDER = "ollama";
-      process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
       process.env.FALLBACK_PROVIDER = "llamacpp";
       process.env.LLAMACPP_ENDPOINT = "http://localhost:8080";
       process.env.FALLBACK_ENABLED = "true";
+      // Enable tier routing so fallback validation runs
+      process.env.TIER_SIMPLE = "ollama:llama3.2";
+      process.env.TIER_MEDIUM = "ollama:llama3.2";
+      process.env.TIER_COMPLEX = "ollama:llama3.2";
+      process.env.TIER_REASONING = "ollama:llama3.2";
 
       assert.throws(
         () => require("../src/config"),

package/test/lmstudio-integration.test.js

@@ -11,6 +11,12 @@ describe("LM Studio Integration", () => {
     delete require.cache[require.resolve("../src/config")];
     delete require.cache[require.resolve("../src/clients/routing")];
     delete require.cache[require.resolve("../src/clients/openrouter-utils")];
+
+    // Prevent .env TIER_* values from being picked up by dotenv
+    process.env.TIER_SIMPLE = "";
+    process.env.TIER_MEDIUM = "";
+    process.env.TIER_COMPLEX = "";
+    process.env.TIER_REASONING = "";
   });
 
   afterEach(() => {
@@ -105,26 +111,33 @@ describe("LM Studio Integration", () => {
     it("should route to lmstudio when MODEL_PROVIDER is lmstudio", () => {
       process.env.MODEL_PROVIDER = "lmstudio";
       process.env.LMSTUDIO_ENDPOINT = "http://localhost:1234";
-      process.env.PREFER_OLLAMA = "false";
 
       const config = require("../src/config");
       const routing = require("../src/clients/routing");
 
       const payload = { messages: [{ role: "user", content: "test" }] };
-      const provider = routing.determineProvider(payload);
+      const provider = routing.determineProviderSync(payload);
 
       assert.strictEqual(provider, "lmstudio");
     });
 
-    it("should route to lmstudio for moderate tool count when other providers not configured", () => {
-      // This test is skipped because lmstudio is the LAST option in routing
-      // and other providers (openrouter, openai, azure, llamacpp) take precedence
-      // LM Studio will be used when it's the PRIMARY provider, not in routing fallback
+    it("should return static routing from determineProviderSmart when tiers disabled", async () => {
+      process.env.MODEL_PROVIDER = "lmstudio";
+      process.env.LMSTUDIO_ENDPOINT = "http://localhost:1234";
+
+      const config = require("../src/config");
+      const routing = require("../src/clients/routing");
+
+      const payload = { messages: [{ role: "user", content: "test" }] };
+      const result = await routing.determineProviderSmart(payload);
+
+      assert.strictEqual(result.provider, "lmstudio");
+      assert.strictEqual(result.method, "static");
+      assert.strictEqual(result.reason, "tier_routing_disabled");
     });
 
     it("should throw error when lmstudio is set as FALLBACK_PROVIDER", () => {
       process.env.MODEL_PROVIDER = "ollama";
-      process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
       process.env.FALLBACK_PROVIDER = "lmstudio";
       process.env.LMSTUDIO_ENDPOINT = "http://localhost:1234";
@@ -312,7 +325,6 @@ describe("LM Studio Integration", () => {
   describe("Fallback Prevention", () => {
     it("should prevent lmstudio from being used as fallback provider", () => {
       process.env.MODEL_PROVIDER = "ollama";
-      process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
       process.env.FALLBACK_PROVIDER = "lmstudio";
       process.env.LMSTUDIO_ENDPOINT = "http://localhost:1234";

package/test/openai-integration.test.js

@@ -11,6 +11,12 @@ describe("OpenAI Integration", () => {
     delete require.cache[require.resolve("../src/config")];
     delete require.cache[require.resolve("../src/clients/routing")];
     delete require.cache[require.resolve("../src/clients/openrouter-utils")];
+
+    // Prevent .env TIER_* values from being picked up by dotenv
+    process.env.TIER_SIMPLE = "";
+    process.env.TIER_MEDIUM = "";
+    process.env.TIER_COMPLEX = "";
+    process.env.TIER_REASONING = "";
   });
 
   afterEach(() => {
@@ -92,50 +98,41 @@ describe("OpenAI Integration", () => {
   });
 
   describe("Routing", () => {
-    it("should route to openai when MODEL_PROVIDER is openai", () => {
+    it("should route to openai when MODEL_PROVIDER is openai", async () => {
       process.env.MODEL_PROVIDER = "openai";
       process.env.OPENAI_API_KEY = "sk-test-key";
-      process.env.PREFER_OLLAMA = "false";
 
       const config = require("../src/config");
       const routing = require("../src/clients/routing");
 
       const payload = { messages: [{ role: "user", content: "test" }] };
-      const provider = routing.determineProvider(payload);
+      const result = await routing.determineProviderSmart(payload);
 
-      assert.strictEqual(provider, "openai");
+      assert.strictEqual(result.provider, "openai");
+      assert.strictEqual(result.method, "static");
     });
 
-    it("should route to openai as fallback when heavy tool count", () => {
-      // Clear any existing OpenRouter key to ensure fallback to OpenAI
-      delete process.env.OPENROUTER_API_KEY;
-
-      process.env.MODEL_PROVIDER = "ollama";
-      process.env.PREFER_OLLAMA = "true";
-      process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
-      process.env.OLLAMA_MAX_TOOLS_FOR_ROUTING = "2";
-      process.env.OPENROUTER_MAX_TOOLS_FOR_ROUTING = "5";
+    it("should return static routing from determineProviderSmart when tiers disabled", async () => {
+      process.env.MODEL_PROVIDER = "openai";
       process.env.OPENAI_API_KEY = "sk-test-key";
-      process.env.FALLBACK_ENABLED = "true";
-      process.env.FALLBACK_PROVIDER = "openai";
 
       const config = require("../src/config");
       const routing = require("../src/clients/routing");
 
-      // 10 tools - above both Ollama and OpenRouter thresholds, should go to fallback
       const payload = {
         messages: [{ role: "user", content: "test" }],
         tools: Array.from({ length: 10 }, (_, i) => ({ name: `tool${i}`, description: "test" })),
       };
 
-      const provider = routing.determineProvider(payload);
-      // Should route to openai as the configured fallback provider
-      assert.strictEqual(provider, "openai");
+      const result = await routing.determineProviderSmart(payload);
+      // No TIER_* vars = static routing
+      assert.strictEqual(result.provider, "openai");
+      assert.strictEqual(result.method, "static");
+      assert.strictEqual(result.reason, "tier_routing_disabled");
     });
 
     it("should use openai as fallback provider when configured", () => {
       process.env.MODEL_PROVIDER = "ollama";
-      process.env.PREFER_OLLAMA = "true";
       process.env.OLLAMA_MODEL = "qwen2.5-coder:latest";
       process.env.FALLBACK_PROVIDER = "openai";
       process.env.OPENAI_API_KEY = "sk-test-key";

package/test/performance-tests.js

@@ -66,7 +66,7 @@ async function testDatabaseIndexes() {
   if (!fs.existsSync(dbPath)) {
     log('⚠️  Database not found. Creating test database...', 'yellow');
     // Initialize database
-    require('./src/db/index.js');
+    require('../src/db/index.js');
   }
 
   const db = new Database(dbPath);