lynkr 7.2.5 → 8.0.1

package/src/api/router.js

@@ -2,10 +2,11 @@ const express = require("express");
 const { processMessage } = require("../orchestrator");
 const { getSession } = require("../sessions");
 const metrics = require("../metrics");
+const logger = require("../logger");
 const { createRateLimiter } = require("./middleware/rate-limiter");
 const openaiRouter = require("./openai-router");
 const providersRouter = require("./providers-handler");
-const { getRoutingHeaders, getRoutingStats, analyzeComplexity } = require("../routing");
+const { getRoutingHeaders, getRoutingStats, analyzeComplexity, getModelTierSelector } = require("../routing");
 const { validateCwd } = require("../workspace");
 
 const router = express.Router();
@@ -71,6 +72,99 @@ router.get("/routing/stats", (req, res) => {
   });
 });
 
+// Model registry info (from LiteLLM + models.dev APIs)
+router.get("/routing/models", async (req, res) => {
+  try {
+    const { getModelRegistry } = require("../routing/model-registry");
+    const registry = await getModelRegistry();
+    res.json({
+      status: "ok",
+      ...registry.getStats(),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Get specific model info
+router.get("/routing/models/:model", async (req, res) => {
+  try {
+    const { getModelRegistry } = require("../routing/model-registry");
+    const registry = await getModelRegistry();
+    const model = registry.getModel(req.params.model);
+    if (!model || model.source === "default") {
+      return res.status(404).json({ error: "Model not found", model: req.params.model });
+    }
+    res.json({ status: "ok", model: req.params.model, ...model });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Routing tier information
+router.get("/routing/tiers", (req, res) => {
+  try {
+    const { getModelTierSelector } = require("../routing/model-tiers");
+    const selector = getModelTierSelector();
+    res.json({
+      status: "ok",
+      ...selector.getTierStats(),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Cost optimization stats
+router.get("/metrics/cost-optimization", (req, res) => {
+  try {
+    const { getCostOptimizer } = require("../routing/cost-optimizer");
+    const optimizer = getCostOptimizer();
+    res.json({
+      status: "ok",
+      ...optimizer.getStats(),
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Request analysis test endpoint
+router.post("/routing/analyze", async (req, res) => {
+  try {
+    const { getAgenticDetector } = require("../routing/agentic-detector");
+    const { getModelTierSelector } = require("../routing/model-tiers");
+    const { getModelRegistry } = require("../routing/model-registry");
+
+    const analysis = analyzeComplexity(req.body, { weighted: req.query.weighted === "true" });
+    const agentic = getAgenticDetector().detect(req.body);
+    const selector = getModelTierSelector();
+    const tier = selector.getTier(analysis.score);
+
+    // Get recommended model for tier
+    const provider = req.query.provider || "openai";
+    const modelSelection = selector.selectModel(tier, provider);
+
+    // Get model cost info
+    let modelInfo = null;
+    if (modelSelection.model) {
+      const registry = await getModelRegistry();
+      modelInfo = registry.getCost(modelSelection.model);
+    }
+
+    res.json({
+      status: "ok",
+      analysis,
+      agentic,
+      tier,
+      modelSelection,
+      modelInfo,
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
 router.get("/debug/session", (req, res) => {
   if (!req.sessionId) {
     return res.status(400).json({ error: "missing_session_id", message: "Provide x-session-id header" });
@@ -123,8 +217,19 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
 
     // Analyze complexity for routing headers (Phase 3)
     const complexity = analyzeComplexity(req.body);
+    let preRouteProvider = 'cloud';
+    if (complexity.recommendation === 'local') {
+      // Use tier config to determine actual provider instead of hardcoding 'ollama'
+      try {
+        const selector = getModelTierSelector();
+        const tierResult = selector.selectModel('SIMPLE', null);
+        preRouteProvider = tierResult.provider;
+      } catch (_) {
+        preRouteProvider = 'ollama';
+      }
+    }
     const routingHeaders = getRoutingHeaders({
-      provider: complexity.recommendation === 'local' ? 'ollama' : 'cloud',
+      provider: preRouteProvider,
       score: complexity.score,
       threshold: complexity.threshold,
       method: 'complexity',

package/src/budget/index.js

@@ -11,13 +11,14 @@ const logger = require('../logger');
 class BudgetManager {
   constructor(options = {}) {
     this.enabled = options.enabled !== false;
+    let dbPath = null;
     if (!this.enabled || !Database) {
       this.enabled = false;
       return;
     }
 
     try {
-      const dbPath = path.join(process.cwd(), 'data', 'budgets.db');
+      dbPath = path.join(process.cwd(), 'data', 'budgets.db');
       const dbDir = path.dirname(dbPath);
 
       if (!fs.existsSync(dbDir)) {
@@ -25,14 +26,14 @@ class BudgetManager {
       }
 
       this.db = new Database(dbPath);
+      this.dbPath = dbPath;
       this.initDatabase();
+      logger.info({ dbPath }, 'Budget manager initialized');
     } catch (err) {
       logger.warn({ err: err.message }, "BudgetManager: better-sqlite3 not available");
       this.enabled = false;
       return;
     }
-
-    logger.info({ dbPath }, 'Budget manager initialized');
   }
 
   initDatabase() {