lynkr 9.4.6 → 9.5.0

package/src/routing/model-registry.js

@@ -54,9 +54,41 @@ const DATABRICKS_FALLBACK = {
   'databricks-bge-large-en': { input: 0.02, output: 0, context: 512 },
 };
 
-// Default cost for unknown models
+// Default cost for unknown models. Returned with `unknown: true` so callers can
+// distinguish a real price from a fabricated guess.
 const DEFAULT_COST = { input: 1.0, output: 3.0, context: 128000 };
 
+// Curated name aliases (exact, one-directional). Maps a name a caller might use
+// to the canonical key likely present in the pricing data. Misses are harmless
+// (resolution simply continues down the ladder).
+const MODEL_ALIASES = {
+  'claude-sonnet-4-5': 'claude-sonnet-4-5-20250929',
+  'claude-opus-4-1': 'claude-opus-4-1-20250805',
+  'claude-3-5-sonnet': 'claude-3-5-sonnet-20241022',
+};
+
+/**
+ * Parse MODEL_PRICE_OVERRIDES env (JSON object of
+ * { "<model>": { "input": <usd/1M>, "output": <usd/1M>, "context"?: N } }).
+ * Lets operators pin correct prices for models the registry doesn't know.
+ */
+function _loadOverrides() {
+  const out = new Map();
+  const raw = process.env.MODEL_PRICE_OVERRIDES;
+  if (!raw) return out;
+  try {
+    const parsed = JSON.parse(raw);
+    for (const [name, info] of Object.entries(parsed)) {
+      if (info && typeof info.input === 'number' && typeof info.output === 'number') {
+        out.set(name.toLowerCase(), { context: 128000, ...info });
+      }
+    }
+  } catch (err) {
+    logger.warn({ err: err.message }, '[ModelRegistry] Failed to parse MODEL_PRICE_OVERRIDES');
+  }
+  return out;
+}
+
 class ModelRegistry {
   constructor() {
     this.litellmPrices = {};
@@ -64,6 +96,7 @@ class ModelRegistry {
     this.loaded = false;
     this.lastFetch = 0;
     this.modelIndex = new Map();
+    this.overrides = _loadOverrides();
   }
 
   /**
@@ -255,40 +288,70 @@ class ModelRegistry {
    * @returns {Object} Cost info { input, output, context, ... }
    */
   getCost(modelName) {
-    if (!modelName) return { ...DEFAULT_COST, source: 'default' };
+    if (!modelName) return { ...DEFAULT_COST, source: 'default', unknown: true };
 
-    const normalizedName = modelName.toLowerCase();
+    const name = String(modelName).toLowerCase().trim();
+    const hit = this._resolveCost(name);
+    if (hit) return hit;
 
-    // Direct lookup
-    if (this.modelIndex.has(normalizedName)) {
-      return this.modelIndex.get(normalizedName);
-    }
+    // Nothing matched — report unknown rather than silently fabricating a price.
+    logger.debug({ model: modelName }, '[ModelRegistry] Model not found — cost unknown');
+    return { ...DEFAULT_COST, source: 'default', unknown: true };
+  }
 
-    // Try common variations
-    const variations = [
-      normalizedName,
-      normalizedName.replace('databricks-', ''),
-      normalizedName.replace('azure/', ''),
-      normalizedName.replace('bedrock/', ''),
-      normalizedName.replace('anthropic.', ''),
-      normalizedName.split('/').pop(),
-    ];
-
-    for (const variant of variations) {
-      if (this.modelIndex.has(variant)) {
-        return this.modelIndex.get(variant);
-      }
+  /**
+   * Deterministic price resolution. Each step is exact (no bidirectional
+   * substring matching), and the only loose step (longest-prefix) is
+   * one-directional and length-bounded, so unrelated names can't false-match.
+   * Returns a cost object with a `resolution` tag, or null if nothing matched.
+   * @param {string} name - already lowercased/trimmed
+   */
+  _resolveCost(name) {
+    const tag = (value, resolution, matchedAs) => ({
+      ...value,
+      resolution,
+      ...(matchedAs && matchedAs !== name ? { matchedAs } : {}),
+    });
+
+    // 1. Operator overrides (exact) — ground truth.
+    if (this.overrides.has(name)) return tag({ ...this.overrides.get(name), source: 'override' }, 'override');
+
+    // 2. Exact registry hit.
+    if (this.modelIndex.has(name)) return tag(this.modelIndex.get(name), 'exact');
+
+    // 3. Provider-prefix strip (exact).
+    const stripped = [
+      name.replace(/^databricks-/, ''),
+      name.replace(/^azure\//, ''),
+      name.replace(/^bedrock\//, ''),
+      name.replace(/^anthropic\./, ''),
+      name.replace(/^openai\//, ''),
+      name.includes('/') ? name.split('/').pop() : null,
+    ].filter((v) => v && v !== name);
+    for (const v of stripped) {
+      if (this.overrides.has(v)) return tag({ ...this.overrides.get(v), source: 'override' }, 'prefix-strip', v);
+      if (this.modelIndex.has(v)) return tag(this.modelIndex.get(v), 'prefix-strip', v);
     }
 
-    // Fuzzy match for partial names
+    // 4. Curated alias (exact).
+    const alias = MODEL_ALIASES[name];
+    if (alias && this.modelIndex.has(alias)) return tag(this.modelIndex.get(alias), 'alias', alias);
+
+    // 5. Date/version-suffix normalization (e.g. -20250929, -2025-09-29, -v2).
+    const dateless = name.replace(/[-@](\d{8}|\d{4}-\d{2}-\d{2}|v\d+)$/, '');
+    if (dateless !== name && this.modelIndex.has(dateless)) return tag(this.modelIndex.get(dateless), 'date-normalize', dateless);
+
+    // 6. Longest registry key that is a prefix of the requested name. Bounded so
+    //    short keys can't grab unrelated names (e.g. "gpt-5.2-chat-2026" → "gpt-5.2-chat").
+    let best = null;
     for (const [key, value] of this.modelIndex.entries()) {
-      if (key.includes(normalizedName) || normalizedName.includes(key)) {
-        return value;
+      if (key.length >= 6 && name.startsWith(key) && (!best || key.length > best.key.length)) {
+        best = { key, value };
       }
     }
+    if (best) return tag(best.value, 'longest-prefix', best.key);
 
-    logger.debug({ model: modelName }, '[ModelRegistry] Model not found, using default');
-    return { ...DEFAULT_COST, source: 'default' };
+    return null;
   }
 
   /**

package/src/routing/risk-analyzer.js

@@ -13,13 +13,18 @@ const { extractContent } = require('./complexity-analyzer');
 // Substring keywords found in file paths or instruction text.
 // Matched case-insensitively as raw substrings, so "auth" hits
 // "src/auth/login.ts" and "authentication".
+// NOTE: keywords are matched as case-insensitive *substrings* against file
+// paths, so overly generic terms cause false positives. 'session' and 'token'
+// were removed because they match benign paths (src/sessions/*, tokenizer.js,
+// token-budget.js) and were force-escalating ordinary requests to COMPLEX —
+// real secrets/credentials are still covered by the keywords below.
 const PROTECTED_PATH_KEYWORDS = [
-  'auth', 'oauth', 'jwt', 'session', 'security', 'permission', 'rbac',
+  'auth', 'oauth', 'jwt', 'security', 'permission', 'rbac',
   'payment', 'payments', 'billing', 'invoice', 'subscription',
   'migration', 'migrations', 'schema',
   'infra', 'terraform', 'kustomize', 'helm', 'kubernetes',
   '.github/workflows', '.env', 'secret', 'credential',
-  'api-key', 'api_key', 'apikey', 'token',
+  'api-key', 'api_key', 'apikey',
   'webhook', 'admin',
 ];
 

package/src/routing/session-affinity.js

@@ -0,0 +1,96 @@
+/**
+ * Session → Provider Affinity
+ *
+ * A multi-turn agentic conversation builds up tool_use / tool_result history
+ * whose tool-call IDs are formatted for the provider that produced them. If a
+ * later turn re-routes to a *different* provider (because per-turn complexity
+ * or risk changed), that provider rejects the orphaned tool linkage:
+ *
+ *   Azure: 400 "No tool call found for function call output with call_id …"
+ *   Moonshot: 400 "Invalid request: tool_call_id is not found"
+ *
+ * To prevent that, once a session has chosen a provider we keep subsequent
+ * turns on it *while the payload carries tool history*. Fresh turns (no tool
+ * state) still route normally, so per-turn tier routing is preserved.
+ *
+ * @module routing/session-affinity
+ */
+
+const MAX_ENTRIES = 2000;
+const TTL_MS = 60 * 60 * 1000; // 1 hour
+
+/** @type {Map<string, {provider:string, model:string|null, tier:string|null, ts:number}>} */
+const pins = new Map();
+
+function _evictIfNeeded() {
+  if (pins.size <= MAX_ENTRIES) return;
+  // Map preserves insertion order — drop the oldest.
+  const oldest = pins.keys().next().value;
+  if (oldest !== undefined) pins.delete(oldest);
+}
+
+/**
+ * True when the payload contains an in-flight tool exchange — i.e. a prior
+ * assistant tool_use or a user tool_result. These are the turns whose
+ * tool-call IDs break if the provider changes.
+ * @param {object} payload
+ * @returns {boolean}
+ */
+function payloadHasToolHistory(payload) {
+  const messages = payload?.messages;
+  if (!Array.isArray(messages)) return false;
+  for (const msg of messages) {
+    const content = msg?.content;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      const t = block?.type;
+      if (t === "tool_use" || t === "tool_result") return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Return the pinned routing decision for a session, or null if none / expired.
+ * @param {string} sessionId
+ */
+function getPinned(sessionId) {
+  if (!sessionId) return null;
+  const entry = pins.get(sessionId);
+  if (!entry) return null;
+  if (Date.now() - entry.ts > TTL_MS) {
+    pins.delete(sessionId);
+    return null;
+  }
+  return entry;
+}
+
+/**
+ * Record the provider a session routed to, for reuse on later tool-bearing turns.
+ * @param {string} sessionId
+ * @param {{provider:string, model?:string|null, tier?:string|null}} decision
+ */
+function setPinned(sessionId, decision) {
+  if (!sessionId || !decision?.provider) return;
+  // Refresh insertion order so active sessions aren't evicted.
+  pins.delete(sessionId);
+  pins.set(sessionId, {
+    provider: decision.provider,
+    model: decision.model ?? null,
+    tier: decision.tier ?? null,
+    ts: Date.now(),
+  });
+  _evictIfNeeded();
+}
+
+/** Test/maintenance helper. */
+function _clear() {
+  pins.clear();
+}
+
+module.exports = {
+  payloadHasToolHistory,
+  getPinned,
+  setPinned,
+  _clear,
+};

package/src/routing/telemetry.js

@@ -94,7 +94,9 @@ function init() {
         circuit_breaker_state TEXT,
         quality_score   REAL,
         tokens_per_second REAL,
-        cost_efficiency REAL
+        cost_efficiency REAL,
+        request_text    TEXT,
+        response_text   TEXT
       );
 
       CREATE INDEX IF NOT EXISTS idx_telemetry_provider
@@ -110,6 +112,15 @@ function init() {
         ON routing_telemetry(session_id, timestamp);
     `);
 
+    // Migration: add columns to pre-existing tables (CREATE TABLE IF NOT EXISTS
+    // won't add them to a DB created before these columns existed).
+    const existingCols = new Set(db.prepare("PRAGMA table_info(routing_telemetry)").all().map((c) => c.name));
+    for (const col of ["request_text", "response_text"]) {
+      if (!existingCols.has(col)) {
+        db.exec(`ALTER TABLE routing_telemetry ADD COLUMN ${col} TEXT`);
+      }
+    }
+
     logger.info({ dbPath }, "Routing telemetry database initialised");
     return true;
   } catch (err) {
@@ -163,14 +174,14 @@ function record(data) {
           provider, model, routing_method, was_fallback, output_tokens,
           latency_ms, status_code, error_type, cost_usd, tool_calls_made,
           retry_count, circuit_breaker_state, quality_score, tokens_per_second,
-          cost_efficiency
+          cost_efficiency, request_text, response_text
         ) VALUES (
           @request_id, @session_id, @timestamp, @complexity_score, @tier,
           @agentic_type, @tool_count, @input_tokens, @message_count, @request_type,
           @provider, @model, @routing_method, @was_fallback, @output_tokens,
           @latency_ms, @status_code, @error_type, @cost_usd, @tool_calls_made,
           @retry_count, @circuit_breaker_state, @quality_score, @tokens_per_second,
-          @cost_efficiency
+          @cost_efficiency, @request_text, @response_text
         )`
       );
       if (!insert) return;
@@ -201,6 +212,8 @@ function record(data) {
         quality_score: data.quality_score ?? null,
         tokens_per_second: data.tokens_per_second ?? null,
         cost_efficiency: data.cost_efficiency ?? null,
+        request_text: data.request_text ?? null,
+        response_text: data.response_text ?? null,
       });
     } catch (err) {
       logger.debug({ err: err.message }, "Telemetry record failed");

package/.impeccable/live/config.json

@@ -1,8 +0,0 @@
-{
-  "files": ["docs/**/*.html"],
-  "insertBefore": "</body>",
-  "commentSyntax": "html",
-  "cspChecked": true,
-  "framework": "multi-page-static",
-  "devServer": null
-}