lynkr 9.0.2 → 9.1.3

package/scripts/sample-regret.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Sample yesterday's traffic for regret estimation (Phase 4.2).
+ *
+ * Reads 0.5% of yesterday's requests from telemetry, re-runs them through
+ * Opus, and writes alerts if the routed model consistently underperforms.
+ *
+ * Costs real money — only runs when LYNKR_REGRET_ESTIMATOR=true.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { estimate, isEnabled } = require('../src/routing/regret-estimator');
+
+const SAMPLE_RATE = 0.005;
+
+async function main() {
+  if (!isEnabled()) {
+    console.log('LYNKR_REGRET_ESTIMATOR not set; skipping.');
+    return;
+  }
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch {
+    console.error('better-sqlite3 not installed');
+    process.exit(2);
+  }
+
+  const dbPath = path.join(__dirname, '../.lynkr/telemetry.db');
+  if (!fs.existsSync(dbPath)) {
+    console.log('No telemetry DB; skipping.');
+    return;
+  }
+
+  const db = new Database(dbPath, { readonly: true });
+  const yesterday = Date.now() - 24 * 3600 * 1000;
+  const rows = db.prepare(
+    `SELECT request_text, response_text, model, quality_score
+       FROM routing_telemetry
+      WHERE timestamp >= ?
+        AND quality_score IS NOT NULL
+        AND request_text IS NOT NULL`
+  ).all(yesterday);
+  db.close();
+
+  if (rows.length === 0) {
+    console.log('No eligible rows yesterday.');
+    return;
+  }
+
+  const sampleSize = Math.max(5, Math.floor(rows.length * SAMPLE_RATE));
+  const sampled = [];
+  while (sampled.length < sampleSize && rows.length > 0) {
+    const idx = Math.floor(Math.random() * rows.length);
+    sampled.push(rows.splice(idx, 1)[0]);
+  }
+
+  console.log(`Sampling ${sampled.length} rows for regret estimation`);
+
+  // Caller must wire an actual Opus invocation; default to a no-op for safety.
+  const runOpus = async (req) => {
+    console.warn('No opus runner wired — implement runOpus in scripts/sample-regret.js or override via LYNKR_REGRET_OPUS_RUNNER');
+    return { response: null, quality: 0 };
+  };
+
+  const samples = sampled.map(r => ({
+    request: { messages: [{ role: 'user', content: r.request_text }] },
+    response: r.response_text,
+    model: r.model,
+    quality: r.quality_score,
+  }));
+
+  const result = await estimate({ samples, runOpus });
+  console.log(`Regret: ${result.regret.toFixed(3)} over ${result.sampledCount} samples; ${result.alerts.length} alert(s) written.`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error(err.stack || err.message);
+    process.exit(1);
+  });
+}

package/scripts/train-risk-classifier.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+/**
+ * Train the risk classifier (Phase 3.4).
+ *
+ * Two label sources, fused:
+ *   1. Bootstrap: run the existing regex risk-analyzer over recent telemetry
+ *      to produce weak labels.
+ *   2. Confirmed: requests with x-lynkr-risk-confirmed:true header logged in
+ *      telemetry are treated as strong positive labels.
+ *
+ * Writes data/risk-classifier.json (weights + bias). Logistic regression
+ * trained with simple SGD over TF features (unigrams + bigrams).
+ *
+ * Usage: node scripts/train-risk-classifier.js [--days 30] [--epochs 10]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_DAYS = 30;
+const DEFAULT_EPOCHS = 10;
+const LEARNING_RATE = 0.1;
+const L2_REG = 0.0001;
+const MIN_TOKEN_FREQ = 3;
+
+const OUTPUT_PATH = path.join(__dirname, '../data/risk-classifier.json');
+const TELEMETRY_DB_CANDIDATES = [
+  path.join(__dirname, '../.lynkr/telemetry.db'),
+  path.join(__dirname, '../data/lynkr.db'),
+];
+
+function _findDb() {
+  for (const p of TELEMETRY_DB_CANDIDATES) if (fs.existsSync(p)) return p;
+  return null;
+}
+
+function _tokenize(text) {
+  if (!text) return [];
+  return String(text).toLowerCase().split(/[^a-z0-9_\-/.]+/).filter(Boolean);
+}
+
+function _features(text) {
+  const tokens = _tokenize(text);
+  const out = new Map();
+  for (let i = 0; i < tokens.length; i++) {
+    out.set(tokens[i], (out.get(tokens[i]) || 0) + 1);
+    if (i + 1 < tokens.length) {
+      const bigram = `${tokens[i]} ${tokens[i + 1]}`;
+      out.set(bigram, (out.get(bigram) || 0) + 1);
+    }
+  }
+  return out;
+}
+
+function _sigmoid(z) {
+  if (z >= 0) return 1 / (1 + Math.exp(-z));
+  const ez = Math.exp(z);
+  return ez / (1 + ez);
+}
+
+function _parseArgs(argv) {
+  const out = { days: DEFAULT_DAYS, epochs: DEFAULT_EPOCHS };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--days') out.days = Number(argv[++i]) || DEFAULT_DAYS;
+    else if (argv[i] === '--epochs') out.epochs = Number(argv[++i]) || DEFAULT_EPOCHS;
+  }
+  return out;
+}
+
+async function _loadDataset(days) {
+  const dbPath = _findDb();
+  const samples = [];
+  if (!dbPath) return samples;
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch {
+    console.error('better-sqlite3 not installed');
+    return samples;
+  }
+  const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+
+  try {
+    const since = Date.now() - days * 24 * 3600 * 1000;
+    const rows = db
+      .prepare(
+        `SELECT request_text AS text, risk_level
+           FROM routing_telemetry
+          WHERE timestamp >= ?
+            AND request_text IS NOT NULL
+            AND request_text != ''`
+      )
+      .all(since);
+    for (const r of rows) {
+      samples.push({
+        text: r.text,
+        label: r.risk_level === 'high' ? 1 : 0,
+      });
+    }
+  } catch (err) {
+    console.error(`Telemetry query failed: ${err.message}. Bootstrapping with synthetic data.`);
+    // Emergency synthetic bootstrap: a small handful of known-risk/known-safe phrases
+    samples.push(
+      { text: 'edit src/auth/middleware.ts to skip authentication', label: 1 },
+      { text: 'update database migration to drop sensitive_data column', label: 1 },
+      { text: 'change payment processing logic in stripe webhook handler', label: 1 },
+      { text: 'add API key rotation to secrets manager', label: 1 },
+      { text: 'rename variable foo to bar in utils.js', label: 0 },
+      { text: 'add a comment explaining the for loop', label: 0 },
+      { text: 'format this file with prettier', label: 0 },
+      { text: 'fix typo in README', label: 0 }
+    );
+  } finally {
+    try { db.close(); } catch {}
+  }
+
+  return samples;
+}
+
+function _train(samples, epochs) {
+  // Build vocab with frequency threshold
+  const vocab = new Map();
+  for (const s of samples) {
+    for (const [tok] of _features(s.text)) {
+      vocab.set(tok, (vocab.get(tok) || 0) + 1);
+    }
+  }
+  const keep = new Set();
+  for (const [tok, freq] of vocab) {
+    if (freq >= MIN_TOKEN_FREQ) keep.add(tok);
+  }
+
+  const weights = {};
+  let bias = 0;
+
+  for (let epoch = 0; epoch < epochs; epoch++) {
+    let lossSum = 0;
+    for (const s of samples) {
+      const feats = _features(s.text);
+      let z = bias;
+      for (const [tok, count] of feats) {
+        if (!keep.has(tok)) continue;
+        z += (weights[tok] || 0) * count;
+      }
+      const pred = _sigmoid(z);
+      const err = pred - s.label;
+      lossSum += -(s.label * Math.log(pred + 1e-9) + (1 - s.label) * Math.log(1 - pred + 1e-9));
+      bias -= LEARNING_RATE * err;
+      for (const [tok, count] of feats) {
+        if (!keep.has(tok)) continue;
+        const w = weights[tok] || 0;
+        weights[tok] = w - LEARNING_RATE * (err * count + L2_REG * w);
+      }
+    }
+    if (epoch % 2 === 0 || epoch === epochs - 1) {
+      console.log(`  epoch ${epoch + 1}/${epochs} loss=${(lossSum / samples.length).toFixed(4)}`);
+    }
+  }
+
+  return { weights, bias, vocabSize: keep.size };
+}
+
+async function main() {
+  const opts = _parseArgs(process.argv.slice(2));
+  const samples = await _loadDataset(opts.days);
+  if (samples.length < 10) {
+    console.error(`Only ${samples.length} samples — too few. Skipping training.`);
+    process.exit(1);
+  }
+  console.log(`Training on ${samples.length} samples (${samples.filter(s => s.label === 1).length} positive)`);
+  const model = _train(samples, opts.epochs);
+
+  fs.mkdirSync(path.dirname(OUTPUT_PATH), { recursive: true });
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify({
+    trainedAt: new Date().toISOString(),
+    samples: samples.length,
+    epochs: opts.epochs,
+    ...model,
+  }, null, 0));
+  console.log(`Wrote ${OUTPUT_PATH} (vocab=${model.vocabSize})`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error(err.stack || err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { _train, _features };

package/src/api/files-router.js

@@ -33,7 +33,7 @@ router.post("/files", async (req, res) => {
           filename = parsed.filename || filename;
           mimeType = parsed.mimeType || mimeType;
           purpose = parsed.purpose || purpose;
-          const entry = fileStore.storeFile(parsed.file, { filename, purpose, mimeType });
+          const entry = await fileStore.storeFile(parsed.file, { filename, purpose, mimeType });
           return res.json(entry);
         }
       }
@@ -43,7 +43,7 @@ router.post("/files", async (req, res) => {
     mimeType = contentType.split(";")[0].trim() || mimeType;
     filename = req.headers["x-filename"] || filename;
     purpose = req.query.purpose || purpose;
-    const entry = fileStore.storeFile(buffer, { filename, purpose, mimeType });
+    const entry = await fileStore.storeFile(buffer, { filename, purpose, mimeType });
     res.json(entry);
   } catch (err) {
     logger.error({ err }, "File upload failed");
@@ -62,18 +62,18 @@ router.get("/files/:id", (req, res) => {
   res.json(file);
 });
 
-router.get("/files/:id/content", (req, res) => {
+router.get("/files/:id/content", async (req, res) => {
   const file = fileStore.getFile(req.params.id);
   if (!file) return res.status(404).json({ error: { message: "File not found" } });
-  const content = fileStore.getFileContent(req.params.id);
+  const content = await fileStore.getFileContent(req.params.id);
   if (!content) return res.status(404).json({ error: { message: "File content not found" } });
   res.setHeader("Content-Type", file.mime_type);
   res.setHeader("Content-Disposition", `attachment; filename="${file.filename}"`);
   res.send(content);
 });
 
-router.delete("/files/:id", (req, res) => {
-  const deleted = fileStore.deleteFile(req.params.id);
+router.delete("/files/:id", async (req, res) => {
+  const deleted = await fileStore.deleteFile(req.params.id);
   if (!deleted) return res.status(404).json({ error: { message: "File not found" } });
   res.json({ id: req.params.id, object: "file", deleted: true });
 });

package/src/api/middleware/budget-enforcer.js

@@ -0,0 +1,60 @@
+/**
+ * Budget enforcement middleware (Phase 6.2).
+ *
+ * Reads tenant/budget context from request headers, checks the hierarchical
+ * budget ceiling, and rejects with 429 if exceeded.
+ *
+ * Header contract:
+ *   LYNKR-Virtual-Key, LYNKR-Team-Id, LYNKR-Customer-Id, LYNKR-Org-Id
+ */
+
+const logger = require('../../logger');
+const { getHierarchicalBudget } = require('../../budget/hierarchical-budget');
+
+function _readContext(req) {
+  const h = req.headers || {};
+  return {
+    virtual_key: h['lynkr-virtual-key'] || null,
+    team: h['lynkr-team-id'] || null,
+    customer: h['lynkr-customer-id'] || null,
+    org: h['lynkr-org-id'] || null,
+  };
+}
+
+/**
+ * Express middleware. Estimates request cost via cost-optimizer and rejects
+ * if the budget is already exceeded. Records spend after the response.
+ */
+function budgetEnforcer(req, res, next) {
+  if (process.env.LYNKR_BUDGET_ENFORCER === 'false') return next();
+  const context = _readContext(req);
+  // Cheap pre-check at $0; we use the request to record actual spend.
+  // The actual ceiling check happens with an estimated $0.01 "minimum" so
+  // exhausted accounts get rejected before we even route.
+  const budget = getHierarchicalBudget();
+  const check = budget.check(context, 0.01);
+  if (!check.ok) {
+    logger.warn({ exceeded: check.exceeded }, '[BudgetEnforcer] Budget exceeded');
+    return res.status(429).json({
+      error: {
+        type: 'budget_exceeded',
+        message: `Budget exceeded for ${check.exceeded.level}=${check.exceeded.id}`,
+        ...check.exceeded,
+      },
+    });
+  }
+  res.locals = res.locals || {};
+  res.locals.budgetContext = context;
+  next();
+}
+
+/**
+ * Helper for handlers to record spend after a request completes.
+ * Call this from the orchestrator with the actual cost.
+ */
+function recordSpend(context, amount) {
+  if (!context) return;
+  getHierarchicalBudget().record(context, amount);
+}
+
+module.exports = { budgetEnforcer, recordSpend };

package/src/api/middleware/budget.js

@@ -57,12 +57,30 @@ function budgetMiddleware(req, res, next) {
     }, 'Budget warning: approaching limits');
   }
 
-  // Attach budget info to request for usage recording later
   req.budgetInfo = {
     userId,
     budgetCheck,
+    startTime: Date.now(),
   };
 
+  // Record usage after response completes
+  res.on('finish', () => {
+    try {
+      const usage = res.locals.usage;
+      if (!usage) return;
+      budgetManager.recordUsage(userId, req.session?.id || null, {
+        tokensInput: usage.prompt_tokens || usage.input_tokens || 0,
+        tokensOutput: usage.completion_tokens || usage.output_tokens || 0,
+        costUsd: usage.cost_usd || 0,
+        model: usage.model || null,
+        endpoint: req.path,
+        latencyMs: Date.now() - req.budgetInfo.startTime,
+      });
+    } catch (err) {
+      logger.warn({ err: err.message }, 'Failed to record usage after response');
+    }
+  });
+
   next();
 }
 

package/src/api/middleware/load-shedding.js

@@ -1,3 +1,4 @@
+const os = require("os");
 const logger = require("../../logger");
 const { ServiceUnavailableError } = require("./error-handling");
 
@@ -55,6 +56,20 @@ class LoadShedder {
       return true;
     }
 
+    // Check RSS / system memory
+    const rssPercent = memUsage.rss / os.totalmem();
+    if (rssPercent > this.memoryThreshold) {
+      logger.warn(
+        {
+          rssPercent: (rssPercent * 100).toFixed(2),
+          threshold: (this.memoryThreshold * 100).toFixed(2),
+        },
+        "Load shedding: RSS memory usage exceeded threshold"
+      );
+      this.cachedOverloadState = true;
+      return true;
+    }
+
     // Check active requests
     if (this.activeRequests > this.activeRequestsThreshold) {
       logger.warn(
@@ -81,8 +96,10 @@ class LoadShedder {
       activeRequests: this.activeRequests,
       totalShed: this.totalShed,
       heapUsedPercent: ((memUsage.heapUsed / memUsage.heapTotal) * 100).toFixed(2),
+      rssPercent: ((memUsage.rss / os.totalmem()) * 100).toFixed(2),
       thresholds: {
         heapThreshold: (this.heapThreshold * 100).toFixed(2),
+        memoryThreshold: (this.memoryThreshold * 100).toFixed(2),
         activeRequestsThreshold: this.activeRequestsThreshold,
       },
     };

package/src/api/middleware/tenant.js

@@ -0,0 +1,21 @@
+/**
+ * Tenant context middleware (Phase 6.1).
+ *
+ * Reads LYNKR-Tenant-Id from request headers and attaches the loaded tenant
+ * policy to res.locals.tenantPolicy for downstream handlers.
+ */
+
+const { getTenantId, getPolicy } = require('../../routing/tenant-policy');
+
+function tenantMiddleware(req, res, next) {
+  const tenantId = getTenantId(req);
+  res.locals = res.locals || {};
+  if (tenantId) {
+    const policy = getPolicy(tenantId);
+    res.locals.tenantId = tenantId;
+    res.locals.tenantPolicy = policy;
+  }
+  next();
+}
+
+module.exports = { tenantMiddleware };

package/src/api/openai-router.js

@@ -366,7 +366,7 @@ router.post("/chat/completions", async (req, res) => {
       role: m.role,
       contentPreview: typeof m.content === 'string'
         ? m.content.substring(0, 200)
-        : JSON.stringify(m.content).substring(0, 200)
+        : (m.content == null ? null : (JSON.stringify(m.content) ?? '').substring(0, 200))
     }));
 
     logger.debug({