lynkr 9.11.0 → 9.13.0

package/src/orchestrator/sse-transformer.js

@@ -20,16 +20,23 @@
  */
 const logger = require("../logger");
 
-// Upstreams whose streaming wire format is OpenAI Chat Completions SSE.
-// ollama is excluded (own format + buffering quirks), moonshot/zai are
-// excluded (their invoke fns convert buffered responses to Anthropic).
+// Upstreams whose streaming streaming wire format is OpenAI Chat Completions SSE.
+// ollama is excluded (own format + buffering quirks); zai is excluded (its
+// invoke fn converts buffered responses to Anthropic, and its Anthropic-format
+// endpoint has the native passthrough path instead). moonshot joined the list
+// once invokeMoonshot learned to return the raw stream (its old forced
+// stream:false predated this transformer). Caveat: reasoning_content deltas
+// (kimi thinking) are not reshaped — thinking text is dropped from streamed
+// responses; the buffered path still lifts it into thinking blocks.
 const DEFAULT_OPENAI_SSE_PROVIDERS = [
   "openai",
+  "atlas",
   "azure-openai",
   "openrouter",
   "databricks",
   "lmstudio",
   "llamacpp",
+  "moonshot",
 ];
 
 function _transformProviders() {

package/src/routing/complexity-analyzer.js

@@ -16,6 +16,7 @@ const logger = require('../logger');
 const config = require('../config');
 const codeGraph = require('../tools/code-graph');
 const clientProfiles = require('./client-profiles');
+const { compressMessages, shouldCompress } = require('./context-compressor');
 
 /**
  * Return the tools the user actually added beyond the client harness's
@@ -769,13 +770,31 @@ function getThreshold() {
  * @returns {Object} Complexity analysis result
  */
 async function analyzeComplexity(payload, options = {}) {
-  const content = extractContent(payload);
-  const messageCount = payload?.messages?.length ?? 0;
+  // Phase 0: Context Compression (TencentDB-inspired)
+  // Compress conversation before scoring to account for token reduction
+  let workingPayload = payload;
+  let compressionStats = null;
+
+  const useCompression = options.compression ?? config.routing?.compression ?? true;
+  if (useCompression && shouldCompress(payload)) {
+    const { compressed, stats } = compressMessages(payload.messages);
+    compressionStats = stats;
+    workingPayload = { ...payload, messages: compressed };
+
+    logger.debug({
+      reduction: stats.reduction,
+      originalTokens: stats.original,
+      compressedTokens: stats.compressed,
+    }, '[complexity] Context compressed');
+  }
+
+  const content = extractContent(workingPayload);
+  const messageCount = workingPayload?.messages?.length ?? 0;
   const useWeighted = options.weighted ?? config.routing?.weightedScoring ?? false;
 
   // Use weighted scoring if enabled
   if (useWeighted) {
-    const weighted = calculateWeightedScore(payload, content);
+    const weighted = calculateWeightedScore(workingPayload, content);
     const threshold = getThreshold();
     const mode = config.smartToolSelection?.mode ?? 'heuristic';
 
@@ -807,6 +826,7 @@ async function analyzeComplexity(payload, options = {}) {
       forceReason: taskTypeResult.reason?.startsWith('force_') ? taskTypeResult.reason : null,
       content: content.slice(0, 100) + (content.length > 100 ? '...' : ''),
       graphSignals: null,
+      compression: compressionStats, // Add compression stats
     };
 
     // Phase 5: Structural Analysis (code-review-graph, optional)
@@ -841,9 +861,9 @@ async function analyzeComplexity(payload, options = {}) {
     return result;
   }
 
-  // Standard scoring (original logic)
-  const tokenScore = scoreTokens(payload);
-  const toolScore = scoreTools(payload);
+  // Standard scoring (original logic) - use compressed payload
+  const tokenScore = scoreTokens(workingPayload);
+  const toolScore = scoreTools(workingPayload);
   const taskTypeResult = scoreTaskType(content);
   const codeComplexityResult = scoreCodeComplexity(content);
   const reasoningResult = scoreReasoning(content);
@@ -881,8 +901,8 @@ async function analyzeComplexity(payload, options = {}) {
     mode,
     recommendation,
     breakdown: {
-      tokens: { score: tokenScore, estimated: estimateTokens(payload) },
-      tools: { score: toolScore, count: _effectiveTools(payload).length },
+      tokens: { score: tokenScore, estimated: estimateTokens(workingPayload) },
+      tools: { score: toolScore, count: _effectiveTools(workingPayload).length },
       taskType: taskTypeResult,
       codeComplexity: codeComplexityResult,
       reasoning: reasoningResult,
@@ -890,11 +910,12 @@ async function analyzeComplexity(payload, options = {}) {
     },
     content: content.slice(0, 100) + (content.length > 100 ? '...' : ''),
     graphSignals: null,
+    compression: compressionStats, // Add compression stats
   };
 
   // Phase 5: Structural Analysis (code-review-graph, optional)
   try {
-    const filePaths = extractFilePaths(payload);
+    const filePaths = extractFilePaths(workingPayload);
     const graphOpts = { filePaths, workspace: options?.workspace };
     const graphAvailable = await codeGraph.isAvailable(graphOpts);
     if (graphAvailable && filePaths.length > 0) {

package/src/routing/index.js

@@ -84,6 +84,7 @@ function _enabledProviders() {
   if (config.openrouter?.apiKey) out.push('openrouter');
   if (config.edenai?.apiKey) out.push('edenai');
   if (config.openai?.apiKey) out.push('openai');
+  if (config.atlas?.apiKey) out.push('atlas');
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) out.push('azure-openai');
   if (config.ollama?.endpoint) out.push('ollama');
   if (config.llamacpp?.endpoint) out.push('llamacpp');
@@ -126,6 +127,7 @@ function getBestCloudProvider() {
   if (config.openrouter?.apiKey) return 'openrouter';
   if (config.edenai?.apiKey) return 'edenai';
   if (config.openai?.apiKey) return 'openai';
+  if (config.atlas?.apiKey) return 'atlas';
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) return 'azure-openai';
 
   return getFallbackProvider();

package/src/routing/intent-score.js

@@ -366,6 +366,14 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
   return { score: anchorScore, reconciled: 'up_gated' };
 }
 
+// Memoize the final reconciled score per cleaned text. The classifier leg is
+// live and can time out under load, sending identical text down different
+// fallback paths — which made the same turn score differently between the
+// router and the pin-drift checker (observed: 63 vs 77 for one prompt under
+// suite-wide Ollama contention). First resolution wins for the process life.
+const _scoreMemo = new Map();
+const _SCORE_MEMO_MAX = 500;
+
 async function scoreIntent(payload, opts = {}) {
   const mode = opts.mode ?? intentScoreMode();
   if (mode === 'legacy') return null;
@@ -373,6 +381,21 @@ async function scoreIntent(payload, opts = {}) {
   const text = extractCleanUserText(payload);
   if (!text) return null;
 
+  // Only memoize plain calls — opts that alter scoring (custom centroids,
+  // embedFn, risk/context inputs) must not share cache entries.
+  const memoizable = !opts.centroids && !opts.embedFn && !opts.forceMatched
+    && !opts.riskLevel && !opts.skipClassifier && !opts.priorTurns;
+  if (memoizable && _scoreMemo.has(text)) return _scoreMemo.get(text);
+  const _memoSet = (result) => {
+    if (memoizable && result) {
+      if (_scoreMemo.size >= _SCORE_MEMO_MAX) {
+        _scoreMemo.delete(_scoreMemo.keys().next().value);
+      }
+      _scoreMemo.set(text, result);
+    }
+    return result;
+  };
+
   try {
     const centroids = opts.centroids !== undefined ? opts.centroids : await getDefaultCentroids();
     if (centroids) {
@@ -421,7 +444,7 @@ async function scoreIntent(payload, opts = {}) {
             finalScore: score,
           }, '[IntentScore] classifier reconciled anchor score');
         }
-        return {
+        return _memoSet({
           score,
           mode: reconciled ? 'anchor+classifier' : 'anchor',
           class: cls,
@@ -431,13 +454,15 @@ async function scoreIntent(payload, opts = {}) {
           classifierTier: classifierResult?.tier ?? null,
           classifierConfidence: classifierResult?.confidence ?? null,
           reconciled,
-        };
+        });
       }
     }
   } catch (err) {
     logger.debug({ err: err.message }, '[IntentScore] anchor scoring failed — lexical fallback');
   }
 
+  // Lexical fallback is NOT memoized: it usually means the embedding service
+  // was unavailable; pinning it would lock in degraded scores after recovery.
   return { score: _lexicalCleanScore(text), mode: 'lexical', text };
 }
 

package/src/routing/model-tiers.js

@@ -333,6 +333,8 @@ class ModelTierSelector {
         return config.azureOpenAI?.deployment || null;
       case 'openai':
         return config.openai?.model || null;
+      case 'atlas':
+        return config.atlas?.model || null;
       case 'ollama':
         return config.ollama?.model || null;
       case 'openrouter':
@@ -349,6 +351,8 @@ class ModelTierSelector {
         return config.zai?.model || null;
       case 'moonshot':
         return config.moonshot?.model || null;
+      case 'baidu':
+        return config.baidu?.model || null;
       case 'codex':
         return config.codex?.model || null;
       case 'vertex':

package/src/routing/telemetry.js

@@ -170,6 +170,11 @@ function init() {
       // projectedSwitchCostUsd, projectedStaySavingsUsd,
       // expectedRemainingTurns} as JSON.
       ["cache_decision", "TEXT"],
+      // Lens dashboard — per-request cache counters from the provider's
+      // usage payload. NULL on rows recorded before capture began (or by
+      // providers that report none) — "not measured" is distinct from 0.
+      ["cache_read_tokens", "INTEGER"],
+      ["cache_creation_tokens", "INTEGER"],
     ];
     for (const [col, type] of additiveCols) {
       if (!existingCols.has(col)) {
@@ -232,7 +237,7 @@ function record(data) {
           retry_count, circuit_breaker_state, quality_score, tokens_per_second,
           cost_efficiency, request_text, response_text,
           base_tier, escalation_source, propensity, candidates, pinned, switch_reason,
-          cache_decision
+          cache_decision, cache_read_tokens, cache_creation_tokens
         ) VALUES (
           @request_id, @session_id, @timestamp, @complexity_score, @tier,
           @agentic_type, @tool_count, @input_tokens, @message_count, @request_type,
@@ -241,7 +246,7 @@ function record(data) {
           @retry_count, @circuit_breaker_state, @quality_score, @tokens_per_second,
           @cost_efficiency, @request_text, @response_text,
           @base_tier, @escalation_source, @propensity, @candidates, @pinned, @switch_reason,
-          @cache_decision
+          @cache_decision, @cache_read_tokens, @cache_creation_tokens
         )`
       );
       if (!insert) return;
@@ -292,6 +297,8 @@ function record(data) {
           : (typeof data.cache_decision === "string"
             ? data.cache_decision
             : JSON.stringify(data.cache_decision)),
+        cache_read_tokens: data.cache_read_tokens ?? null,
+        cache_creation_tokens: data.cache_creation_tokens ?? null,
       });
     } catch (err) {
       logger.debug({ err: err.message }, "Telemetry record failed");
@@ -926,6 +933,200 @@ function getExpectedRemainingTurns(currentTurns = 0) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Lens dashboard queries
+// ---------------------------------------------------------------------------
+
+/**
+ * MEASURED cache savings — backward-looking, auditable against the bill:
+ * for rows that carried cache counters, what did cache reads actually save
+ * vs. paying full input price? Distinct from the projected figures in
+ * getCacheEconomics. Also reports the hit ratio per (provider, model).
+ *
+ * @param {Object} [opts] {since}
+ * @returns {{measuredSavedUsd:number, rowsMeasured:number, perModel:Array}|null}
+ */
+function getMeasuredCacheSavings(opts = {}) {
+  if (!init()) return null;
+  const since = opts.since ?? Date.now() - 7 * 24 * 60 * 60 * 1000;
+  try {
+    const rows = db
+      .prepare(
+        `SELECT provider, model, COUNT(*) n,
+                SUM(COALESCE(cache_read_tokens,0)) rd,
+                SUM(COALESCE(cache_creation_tokens,0)) cr,
+                SUM(COALESCE(input_tokens,0)) inp
+         FROM routing_telemetry
+         WHERE timestamp > ? AND cache_read_tokens IS NOT NULL
+         GROUP BY provider, model`
+      )
+      .all(since);
+    const { resolveCacheEconomics } = require("./cache-economics");
+    let saved = 0;
+    let measured = 0;
+    const perModel = [];
+    for (const r of rows) {
+      measured += r.n;
+      const econ = resolveCacheEconomics(r.provider, r.model);
+      const savedUsd = econ.unknownPricing
+        ? null
+        : (r.rd * Math.max(0, econ.inputPerM - econ.cacheReadPerM)) / 1_000_000;
+      if (savedUsd != null) saved += savedUsd;
+      const total = r.rd + r.cr + r.inp;
+      perModel.push({
+        provider: r.provider,
+        model: r.model,
+        requests: r.n,
+        cacheReadTokens: r.rd,
+        hitRatio: total > 0 ? r.rd / total : null,
+        savedUsd,
+      });
+    }
+    perModel.sort((a, b) => (a.hitRatio ?? 1) - (b.hitRatio ?? 1));
+    return { measuredSavedUsd: saved, rowsMeasured: measured, perModel };
+  } catch (err) {
+    logger.debug({ err: err.message }, "Telemetry getMeasuredCacheSavings failed");
+    return null;
+  }
+}
+
+/**
+ * Session drill-down: per-model mix, context-growth series, tool totals.
+ * @param {string} sessionId
+ */
+function getSessionDetail(sessionId) {
+  if (!sessionId || !init()) return null;
+  try {
+    const rows = db
+      .prepare(
+        `SELECT timestamp, provider, model, tier, routing_method, input_tokens,
+                output_tokens, cost_usd, latency_ms, tool_count, tool_calls_made,
+                cache_read_tokens, cache_creation_tokens, status_code, error_type,
+                pinned, switch_reason, message_count
+         FROM routing_telemetry WHERE session_id = ? ORDER BY timestamp ASC LIMIT 2000`
+      )
+      .all(sessionId);
+    if (!rows.length) return null;
+
+    const perModel = new Map();
+    let toolCalls = 0;
+    let cost = 0;
+    for (const r of rows) {
+      const key = `${r.provider}:${r.model}`;
+      const m = perModel.get(key) ?? {
+        provider: r.provider, model: r.model, requests: 0,
+        inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, costUsd: 0,
+      };
+      m.requests++;
+      m.inputTokens += r.input_tokens ?? 0;
+      m.outputTokens += r.output_tokens ?? 0;
+      m.cacheReadTokens += r.cache_read_tokens ?? 0;
+      m.costUsd += r.cost_usd ?? 0;
+      perModel.set(key, m);
+      toolCalls += r.tool_calls_made ?? 0;
+      cost += r.cost_usd ?? 0;
+    }
+
+    return {
+      sessionId,
+      requests: rows.length,
+      totalCostUsd: cost,
+      toolCalls,
+      firstSeen: rows[0].timestamp,
+      lastSeen: rows[rows.length - 1].timestamp,
+      models: [...perModel.values()].sort((a, b) => b.costUsd - a.costUsd),
+      // Input (context) tokens per call over the session — the distiller
+      // cliff and frozen-block plateau are visible here.
+      contextSeries: rows.map((r) => ({
+        t: r.timestamp,
+        inputTokens: r.input_tokens ?? 0,
+        cacheReadTokens: r.cache_read_tokens ?? null,
+        tier: r.tier,
+        model: r.model,
+      })),
+      rows,
+    };
+  } catch (err) {
+    logger.debug({ err: err.message }, "Telemetry getSessionDetail failed");
+    return null;
+  }
+}
+
+// Pivot explorer — every metric/dimension is whitelisted; params never reach
+// SQL as strings.
+const ANALYTICS_METRICS = {
+  spend: "SUM(COALESCE(cost_usd,0))",
+  tokens: "SUM(COALESCE(input_tokens,0)+COALESCE(output_tokens,0))",
+  requests: "COUNT(*)",
+  sessions: "COUNT(DISTINCT session_id)",
+};
+const ANALYTICS_DIMS = {
+  provider: "provider",
+  model: "model",
+  tier: "tier",
+  request_type: "request_type",
+  routing_method: "routing_method",
+  switch_reason: "switch_reason",
+  day: "date(timestamp/1000, 'unixepoch')",
+};
+
+/**
+ * Generic Metric × Dimension (× Stack) pivot with KPI row and
+ * period-over-period deltas (suppressed when the prior window is thin).
+ *
+ * @param {Object} [opts] {metric, by, stack, since, until}
+ */
+function getAnalytics(opts = {}) {
+  if (!init()) return null;
+  const metricExpr = ANALYTICS_METRICS[opts.metric] ?? ANALYTICS_METRICS.spend;
+  const metric = ANALYTICS_METRICS[opts.metric] ? opts.metric : "spend";
+  const byExpr = ANALYTICS_DIMS[opts.by] ?? ANALYTICS_DIMS.provider;
+  const by = ANALYTICS_DIMS[opts.by] ? opts.by : "provider";
+  const stackExpr = opts.stack && ANALYTICS_DIMS[opts.stack] ? ANALYTICS_DIMS[opts.stack] : null;
+  const until = opts.until ?? Date.now();
+  const since = opts.since ?? until - 7 * 24 * 60 * 60 * 1000;
+
+  try {
+    const groupCols = stackExpr ? `${byExpr} AS dim, ${stackExpr} AS stack` : `${byExpr} AS dim`;
+    const groupBy = stackExpr ? "GROUP BY dim, stack" : "GROUP BY dim";
+    const rows = db
+      .prepare(
+        `SELECT ${groupCols}, ${metricExpr} AS value
+         FROM routing_telemetry
+         WHERE timestamp BETWEEN ? AND ?
+         ${groupBy} ORDER BY value DESC LIMIT 500`
+      )
+      .all(since, until);
+
+    const kpiRow = (lo, hi) =>
+      db
+        .prepare(
+          `SELECT SUM(COALESCE(cost_usd,0)) spend,
+                  SUM(COALESCE(input_tokens,0)+COALESCE(output_tokens,0)) tokens,
+                  COUNT(*) requests,
+                  COUNT(DISTINCT session_id) sessions
+           FROM routing_telemetry WHERE timestamp BETWEEN ? AND ?`
+        )
+        .get(lo, hi);
+    const kpis = kpiRow(since, until);
+    const prev = kpiRow(since - (until - since), since);
+    // Thin prior window → deltas are noise, suppress rather than mislead.
+    const kpiDeltas = (prev?.requests ?? 0) >= 10
+      ? {
+        spend: kpis.spend - (prev.spend ?? 0),
+        tokens: kpis.tokens - (prev.tokens ?? 0),
+        requests: kpis.requests - prev.requests,
+        sessions: kpis.sessions - (prev.sessions ?? 0),
+      }
+      : null;
+
+    return { metric, by, stack: stackExpr ? opts.stack : null, since, until, rows, kpis, kpiDeltas };
+  } catch (err) {
+    logger.debug({ err: err.message }, "Telemetry getAnalytics failed");
+    return null;
+  }
+}
+
 module.exports = {
   record,
   query,
@@ -936,6 +1137,9 @@ module.exports = {
   getQualityByTierAndType,
   getExpectedRemainingTurns,
   getCacheEconomics,
+  getMeasuredCacheSavings,
+  getSessionDetail,
+  getAnalytics,
   recordSavings,
   getSavingsSummary,
   cleanup,

package/scripts/convert-routellm.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-"""
-Convert routellm/gpt4_dataset (train.jsonl) → Lynkr kNN bootstrap JSONL.
-
-Stream-downloads from HuggingFace and maps mixtral_score (1-5) to your
-TIER_* model config so the kNN index learns to recommend YOUR real models,
-not RouteLLM's pool (mixtral / gpt-4).
-
-Output format matches scripts/build-knn-index.js bootstrap input:
-    {"query": "...", "provider": "ollama", "model": "minimax-m2.5:cloud",
-     "quality": 95, "cost": 0.001, "latency": 200, "tier": "SIMPLE"}
-
-Usage:
-    .venv/bin/python scripts/convert-routellm.py [--limit 30000] -o routellm.jsonl
-"""
-import argparse
-import json
-import sys
-import urllib.request
-import ssl
-
-# Map mixtral_score → user's tier config.
-# Spread is intentionally aggressive: only score=5 (Mixtral truly nailed it)
-# stays SIMPLE; score=4 escalates to MEDIUM so the kNN index has enough MEDIUM
-# examples to actually recommend non-SIMPLE tiers (vs the previous mapping
-# where 86% of records were SIMPLE and kNN never disagreed with the heuristic).
-SCORE_TO_ROUTE = {
-    5: {"tier": "SIMPLE",    "provider": "ollama",          "model": "minimax-m2.5:cloud", "quality": 95, "cost": 0.001, "latency": 200},
-    4: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 80, "cost": 0.003, "latency": 1500},
-    3: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 70, "cost": 0.003, "latency": 1500},
-    2: {"tier": "COMPLEX",   "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 55, "cost": 0.003, "latency": 1500},
-    1: {"tier": "REASONING", "provider": "azure-anthropic", "model": "claude-opus-4-8",    "quality": 40, "cost": 0.015, "latency": 3500},
-}
-
-URL = "https://huggingface.co/datasets/routellm/gpt4_dataset/resolve/main/train.jsonl"
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("--output", "-o", default="data/routellm-bootstrap.jsonl")
-    p.add_argument("--limit", type=int, default=None,
-                   help="Only convert first N rows")
-    args = p.parse_args()
-
-    print(f"Streaming {URL} …", file=sys.stderr)
-    # Some macOS Python builds have SSL issues with huggingface.co — fall back
-    # to unverified context if needed. The data is public, no auth.
-    ctx = ssl.create_default_context()
-    try:
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-    except (ssl.SSLError, OSError) as e:
-        print(f"SSL strict failed ({e}); retrying with unverified context", file=sys.stderr)
-        ctx = ssl._create_unverified_context()
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-
-
-def _stream(resp, out_path, limit):
-    written = 0
-    by_score = {s: 0 for s in SCORE_TO_ROUTE}
-    skipped = 0
-    with open(out_path, "w") as out:
-        for line in resp:
-            if limit and written >= limit:
-                break
-            try:
-                row = json.loads(line)
-            except Exception:
-                skipped += 1
-                continue
-            score = row.get("mixtral_score")
-            if score not in SCORE_TO_ROUTE:
-                skipped += 1
-                continue
-            route = SCORE_TO_ROUTE[score]
-            rec = {
-                "query": row.get("prompt", ""),
-                "provider": route["provider"],
-                "model": route["model"],
-                "quality": route["quality"],
-                "cost": route["cost"],
-                "latency": route["latency"],
-                "tier": route["tier"],
-            }
-            if not rec["query"]:
-                skipped += 1
-                continue
-            out.write(json.dumps(rec) + "\n")
-            written += 1
-            by_score[score] += 1
-            if written % 5000 == 0:
-                print(f"  {written} written…", file=sys.stderr)
-
-    print(f"\nWrote {written} records to {out_path} ({skipped} skipped)", file=sys.stderr)
-    print(f"By mixtral_score: {by_score}", file=sys.stderr)
-    print(f"\nTier distribution:", file=sys.stderr)
-    for score, route in SCORE_TO_ROUTE.items():
-        n = by_score[score]
-        if n:
-            print(f"  {route['tier']:>10}  {route['provider']}:{route['model']:30s}  n={n}", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()