lynkr 4.2.1 → 4.3.1

package/README.md

@@ -1,4 +1,5 @@
-# Lynkr - Claude Code Proxy with Multi-Provider Support
+# Lynkr - Run Cursor, Cline, Continue, and Claude Code on any model.
+## One universal LLM proxy for AI coding tools.
 
 [![npm version](https://img.shields.io/npm/v/lynkr.svg)](https://www.npmjs.com/package/lynkr)
 [![Homebrew Tap](https://img.shields.io/badge/homebrew-lynkr-brightgreen.svg)](https://github.com/vishalveerareddy123/homebrew-lynkr)
@@ -10,13 +11,19 @@
 [![Ollama Compatible](https://img.shields.io/badge/Ollama-Compatible-brightgreen)](https://ollama.ai/)
 [![llama.cpp Compatible](https://img.shields.io/badge/llama.cpp-Compatible-blue)](https://github.com/ggerganov/llama.cpp)
 
-> **Production-ready Claude Code proxy supporting 9+ LLM providers with 60-80% cost reduction through token optimization.**
-
+### Use Case
+```
+        Cursor / Cline / Continue / Claude Code
+                        ↓
+                       Lynkr
+                        ↓
+        Local LLMs | OpenRouter | Azure | Databricks
+```
 ---
 
 ## Overview
 
-Lynkr is a **self-hosted proxy server** that unlocks Claude Code CLI and Cursor IDE by enabling:
+Lynkr is a **self-hosted proxy server** that unlocks Claude Code CLI , Cursor IDE and Codex Cli by enabling:
 
 - 🚀 **Any LLM Provider** - Databricks, AWS Bedrock (100+ models), OpenRouter (100+ models), Ollama (local), llama.cpp, Azure OpenAI, Azure Anthropic, OpenAI, LM Studio
 - 💰 **60-80% Cost Reduction** - Built-in token optimization with smart tool selection, prompt caching, and memory deduplication
@@ -64,14 +71,9 @@ nano .env
 npm start
 ```
 
-**Option 3: Homebrew (macOS/Linux)**
-```bash
-brew tap vishalveerareddy123/lynkr
-brew install lynkr
-lynkr start
-```
 
-**Option 4: Docker**
+
+**Option 3: Docker**
 ```bash
 docker-compose up -d
 ```
@@ -136,7 +138,27 @@ Configure Cursor IDE to use Lynkr:
    - @Codebase search: Requires [embeddings setup](documentation/embeddings.md)
 
 📖 **[Full Cursor Setup Guide](documentation/cursor-integration.md)** | **[Embeddings Configuration](documentation/embeddings.md)**
-
+---
+## Codex CLI with Lynkr                                                                                                                                                                                                                    
+Configure Codex Cli to use Lynkr                                                                                                                                                                                                                                                
+  Option 1: **Environment Variable (simplest)**                                                                                                                                                                                                          
+ ``` 
+export OPENAI_BASE_URL=http://localhost:8081/v1                                                                                                                                                                                                    
+export  OPENAI_API_KEY=dummy                                                                                                                                                                                                                        
+  codex 
+  ```
+                                                                                                                                                                                                                                                     
+  Option 2: **Config File (~/.codex/config.toml)**  
+  ```                     
+  model_provider = "lynkr"                                                                                                                                                                                                                           
+                                                                                                                                                                                                                                                     
+  [model_providers.lynkr]                                                                                                                                                                                                                            
+  name = "Lynkr Proxy"                                                                                                                                                                                                                               
+  base_url = "http://localhost:8081/v1"                                                                                                                                                                                                              
+  env_key = "OPENAI_API_KEY"     
+  ```
+                                                          
+## Lynkr also supports  Cline, Continue.dev and other OpenAI compatible tools.
 ---
 
 ## Documentation
@@ -198,7 +220,7 @@ Configure Cursor IDE to use Lynkr:
 
 ```
 ┌─────────────────┐
-│ Claude Code CLI │  or  Cursor IDE
+│    AI Tools     │  
 └────────┬────────┘
          │ Anthropic/OpenAI Format
          ↓
@@ -251,7 +273,7 @@ export MODEL_PROVIDER=openrouter
 export OPENROUTER_API_KEY=sk-or-v1-your-key
 npm start
 ```
-
+** You can setup multiple models like local models
 📖 **[More Examples](documentation/providers.md#quick-start-examples)**
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "4.2.1",
+  "version": "4.3.1",
   "description": "Self-hosted Claude Code & Cursor proxy with Databricks,AWS BedRock,Azure  adapters, openrouter, Ollama,llamacpp,LM Studio, workspace tooling, and MCP integration.",
   "main": "index.js",
   "bin": {

package/src/api/router.js

@@ -4,6 +4,7 @@ const { getSession } = require("../sessions");
 const metrics = require("../metrics");
 const { createRateLimiter } = require("./middleware/rate-limiter");
 const openaiRouter = require("./openai-router");
+const { getRoutingHeaders, getRoutingStats, analyzeComplexity } = require("../routing");
 
 const router = express.Router();
 
@@ -59,6 +60,15 @@ router.get("/health", (req, res) => {
   res.json({ status: "ok" });
 });
 
+// Routing stats endpoint (Phase 3: Metrics)
+router.get("/routing/stats", (req, res) => {
+  const stats = getRoutingStats();
+  res.json({
+    status: "ok",
+    stats: stats || { message: "No routing decisions recorded yet" },
+  });
+});
+
 router.get("/debug/session", (req, res) => {
   if (!req.sessionId) {
     return res.status(400).json({ error: "missing_session_id", message: "Provide x-session-id header" });
@@ -109,6 +119,16 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
     const wantsStream = Boolean(req.query?.stream === 'true' || req.body?.stream);
     const hasTools = Array.isArray(req.body?.tools) && req.body.tools.length > 0;
 
+    // Analyze complexity for routing headers (Phase 3)
+    const complexity = analyzeComplexity(req.body);
+    const routingHeaders = getRoutingHeaders({
+      provider: complexity.recommendation === 'local' ? 'ollama' : 'cloud',
+      score: complexity.score,
+      threshold: complexity.threshold,
+      method: 'complexity',
+      reason: complexity.breakdown?.taskType?.reason || complexity.recommendation,
+    });
+
     // For true streaming: only support non-tool requests for MVP
     // Tool requests require buffering for agent loop
     if (wantsStream && !hasTools) {
@@ -118,6 +138,7 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
         Connection: "keep-alive",
+        ...routingHeaders,  // Include routing headers
       });
       if (typeof res.flushHeaders === "function") {
         res.flushHeaders();
@@ -386,6 +407,13 @@ router.post("/v1/messages", rateLimiter, async (req, res, next) => {
       return;
     }
 
+    // Add routing headers (Phase 3)
+    Object.entries(routingHeaders).forEach(([key, value]) => {
+      if (value !== undefined) {
+        res.setHeader(key, value);
+      }
+    });
+
     if (result.headers) {
       Object.entries(result.headers).forEach(([key, value]) => {
         if (value !== undefined) {

package/src/clients/databricks.js

@@ -911,19 +911,34 @@ async function invokeBedrock(body) {
 }
 
 async function invokeModel(body, options = {}) {
-  const { determineProvider, isFallbackEnabled, getFallbackProvider } = require("./routing");
+  const { determineProvider, isFallbackEnabled, getFallbackProvider, analyzeComplexity } = require("./routing");
   const metricsCollector = getMetricsCollector();
   const registry = getCircuitBreakerRegistry();
 
-  // Determine provider based on routing logic
+  // Analyze complexity and determine provider
+  const complexityAnalysis = analyzeComplexity(body);
   const initialProvider = options.forceProvider ?? determineProvider(body);
   const preferOllama = config.modelProvider?.preferOllama ?? false;
 
+  // Build routing decision object for response headers
+  const routingDecision = {
+    provider: initialProvider,
+    score: complexityAnalysis.score,
+    threshold: complexityAnalysis.threshold,
+    mode: complexityAnalysis.mode,
+    recommendation: complexityAnalysis.recommendation,
+    method: complexityAnalysis.score !== undefined ? 'complexity' : 'static',
+    taskType: complexityAnalysis.breakdown?.taskType?.reason,
+  };
+
   logger.debug({
     initialProvider,
     preferOllama,
     fallbackEnabled: isFallbackEnabled(),
     toolCount: Array.isArray(body?.tools) ? body.tools.length : 0,
+    complexityScore: complexityAnalysis.score,
+    complexityThreshold: complexityAnalysis.threshold,
+    recommendation: complexityAnalysis.recommendation,
   }, "Provider routing decision");
 
   metricsCollector.recordProviderRouting(initialProvider);
@@ -979,10 +994,11 @@ async function invokeModel(body, options = {}) {
       }
     }
 
-    // Return result with provider info for proper response conversion
+    // Return result with provider info and routing decision for headers
     return {
       ...result,
-      actualProvider: initialProvider
+      actualProvider: initialProvider,
+      routingDecision,
     };
 
   } catch (err) {
@@ -1061,10 +1077,16 @@ async function invokeModel(body, options = {}) {
         totalLatency: Date.now() - startTime,
       }, "Fallback to cloud provider succeeded");
 
-      // Return result with actual provider used (fallback provider)
+      // Return result with actual provider used (fallback provider) and routing decision
       return {
         ...fallbackResult,
-        actualProvider: fallbackProvider
+        actualProvider: fallbackProvider,
+        routingDecision: {
+          ...routingDecision,
+          provider: fallbackProvider,
+          method: 'fallback',
+          fallbackReason: reason,
+        },
       };
 
     } catch (fallbackErr) {

package/src/clients/routing.js

@@ -1,136 +1,24 @@
-const config = require("../config");
-const logger = require("../logger");
-const { modelNameSupportsTools } = require("./ollama-utils");
-
 /**
- * Determine provider based on request complexity
+ * Request Routing Module
  *
- * Routing Rules:
- * 1. If PREFER_OLLAMA is false, route based on MODEL_PROVIDER
- * 2. If no tools OR tool count < threshold, route to Ollama
- * 3. If tools present AND model doesn't support tools, route to cloud
- * 4. If tool count >= threshold, route to cloud for better performance
+ * Determines the optimal provider for handling requests based on
+ * complexity analysis and configuration.
  *
- * @param {Object} payload - Request payload with tools array
- * @returns {string} Provider to use ('ollama' or fallback provider)
- */
-function determineProvider(payload) {
-  const preferOllama = config.modelProvider?.preferOllama ?? false;
-
-  // If not in preference mode, use static configuration
-  if (!preferOllama) {
-    return config.modelProvider?.type ?? "databricks";
-  }
-
-  // Count tools in request
-  const toolCount = Array.isArray(payload?.tools) ? payload.tools.length : 0;
-  const maxToolsForOllama = config.modelProvider?.ollamaMaxToolsForRouting ?? 3;
-  const maxToolsForOpenRouter = config.modelProvider?.openRouterMaxToolsForRouting ?? 15;
-
-  // Check if Ollama model supports tools when tools are present
-  if (toolCount > 0) {
-    const ollamaModel = config.ollama?.model;
-    const supportsTools = modelNameSupportsTools(ollamaModel);
-
-    // Only route to fallback if it's enabled AND model doesn't support tools
-    if (!supportsTools && isFallbackEnabled()) {
-      const fallback = config.modelProvider?.fallbackProvider ?? "databricks";
-      logger.debug(
-        { toolCount, ollamaModel, supportsTools: false, decision: fallback },
-        "Routing to cloud (model doesn't support tools)"
-      );
-      return fallback;
-    }
-  }
-
-  // No tools or simple requests → Ollama
-  if (toolCount === 0 || toolCount < maxToolsForOllama) {
-    logger.debug(
-      { toolCount, maxToolsForOllama, decision: "ollama" },
-      "Routing to Ollama (simple request)"
-    );
-    return "ollama";
-  }
-
-  // Moderate tool count → OpenRouter, OpenAI, or Azure OpenAI (if configured and fallback enabled)
-  if (toolCount < maxToolsForOpenRouter && isFallbackEnabled()) {
-    if (config.openrouter?.apiKey) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "openrouter" },
-        "Routing to OpenRouter (moderate tools)"
-      );
-      return "openrouter";
-    } else if (config.openai?.apiKey) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "openai" },
-        "Routing to OpenAI (moderate tools)"
-      );
-      return "openai";
-    } else if (config.azureOpenAI?.apiKey) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "azure-openai" },
-        "Routing to Azure OpenAI (moderate tools)"
-      );
-      return "azure-openai";
-    } else if (config.llamacpp?.endpoint) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "llamacpp" },
-        "Routing to llama.cpp (moderate tools)"
-      );
-      return "llamacpp";
-    } else if (config.lmstudio?.endpoint) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "lmstudio" },
-        "Routing to LM Studio (moderate tools)"
-      );
-      return "lmstudio";
-    } else if (config.bedrock?.apiKey) {
-      logger.debug(
-        { toolCount, maxToolsForOllama, maxToolsForOpenRouter, decision: "bedrock" },
-        "Routing to AWS Bedrock (moderate tools)"
-      );
-      return "bedrock";
-    }
-  }
-
-  // Heavy tool count → cloud (only if fallback is enabled)
-  if (isFallbackEnabled()) {
-    const fallback = config.modelProvider?.fallbackProvider ?? "databricks";
-    logger.debug(
-      { toolCount, maxToolsForOpenRouter, decision: fallback },
-      "Routing to cloud (heavy tools)"
-    );
-    return fallback;
-  }
-
-  // Fallback disabled, route to Ollama regardless of complexity
-  logger.debug(
-    { toolCount, maxToolsForOllama, fallbackEnabled: false, decision: "ollama" },
-    "Routing to Ollama (fallback disabled)"
-  );
-  return "ollama";
-}
-
-/**
- * Check if fallback is enabled for the current configuration
+ * This module re-exports the smart routing system for backward compatibility.
+ * All routing logic is now in src/routing/index.js
  *
- * @returns {boolean} True if fallback is enabled
+ * @module clients/routing
  */
-function isFallbackEnabled() {
-  return config.modelProvider?.fallbackEnabled !== false;
-}
 
-/**
- * Get the fallback provider
- *
- * @returns {string} Fallback provider name (e.g., "databricks", "azure-anthropic")
- */
-function getFallbackProvider() {
-  return config.modelProvider?.fallbackProvider ?? "databricks";
-}
+const smartRouting = require('../routing');
 
+// Re-export all functions from smart routing
 module.exports = {
-  determineProvider,
-  isFallbackEnabled,
-  getFallbackProvider,
+  determineProvider: smartRouting.determineProvider,
+  determineProviderSmart: smartRouting.determineProviderSmart,
+  isFallbackEnabled: smartRouting.isFallbackEnabled,
+  getFallbackProvider: smartRouting.getFallbackProvider,
+  getRoutingHeaders: smartRouting.getRoutingHeaders,
+  getRoutingStats: smartRouting.getRoutingStats,
+  analyzeComplexity: smartRouting.analyzeComplexity,
 };