lynkr 9.7.2 → 9.9.0

package/src/api/middleware/validation.js

@@ -1,261 +0,0 @@
-const { BadRequestError } = require("./error-handling");
-
-/**
- * Input validation middleware
- *
- * Features:
- * - JSON schema-like validation
- * - Type checking
- * - Range validation
- * - Sanitization
- * - Performance-optimized (no external dependencies)
- */
-
-/**
- * Validate request body against schema
- */
-function validateBody(schema) {
-  return (req, res, next) => {
-    try {
-      const errors = validateObject(req.body, schema, "body");
-
-      if (errors.length > 0) {
-        throw new BadRequestError("Validation failed", { errors });
-      }
-
-      next();
-    } catch (err) {
-      next(err);
-    }
-  };
-}
-
-/**
- * Validate query parameters against schema
- */
-function validateQuery(schema) {
-  return (req, res, next) => {
-    try {
-      const errors = validateObject(req.query, schema, "query");
-
-      if (errors.length > 0) {
-        throw new BadRequestError("Validation failed", { errors });
-      }
-
-      next();
-    } catch (err) {
-      next(err);
-    }
-  };
-}
-
-/**
- * Validate object against schema
- */
-function validateObject(obj, schema, path = "") {
-  const errors = [];
-
-  // Check required fields
-  if (schema.required && Array.isArray(schema.required)) {
-    for (const field of schema.required) {
-      if (obj[field] === undefined || obj[field] === null) {
-        errors.push({
-          field: `${path}.${field}`,
-          message: `Field is required`,
-          code: "required",
-        });
-      }
-    }
-  }
-
-  // Check properties
-  if (schema.properties) {
-    for (const [field, fieldSchema] of Object.entries(schema.properties)) {
-      const value = obj[field];
-
-      // Skip if optional and not present
-      if (value === undefined || value === null) {
-        if (!schema.required || !schema.required.includes(field)) {
-          continue;
-        }
-      }
-
-      // Validate field
-      const fieldErrors = validateField(value, fieldSchema, `${path}.${field}`);
-      errors.push(...fieldErrors);
-    }
-  }
-
-  return errors;
-}
-
-/**
- * Validate individual field
- */
-function validateField(value, schema, path) {
-  const errors = [];
-
-  // Type validation
-  if (schema.type) {
-    const actualType = Array.isArray(value) ? "array" : typeof value;
-
-    if (actualType !== schema.type) {
-      errors.push({
-        field: path,
-        message: `Expected type ${schema.type}, got ${actualType}`,
-        code: "invalid_type",
-      });
-      return errors; // Stop further validation if type is wrong
-    }
-  }
-
-  // String validations
-  if (schema.type === "string") {
-    if (schema.minLength && value.length < schema.minLength) {
-      errors.push({
-        field: path,
-        message: `String length must be at least ${schema.minLength}`,
-        code: "min_length",
-      });
-    }
-
-    if (schema.maxLength && value.length > schema.maxLength) {
-      errors.push({
-        field: path,
-        message: `String length must be at most ${schema.maxLength}`,
-        code: "max_length",
-      });
-    }
-
-    if (schema.pattern) {
-      const regex = new RegExp(schema.pattern);
-      if (!regex.test(value)) {
-        errors.push({
-          field: path,
-          message: `String does not match pattern ${schema.pattern}`,
-          code: "pattern_mismatch",
-        });
-      }
-    }
-
-    if (schema.enum && !schema.enum.includes(value)) {
-      errors.push({
-        field: path,
-        message: `Value must be one of: ${schema.enum.join(", ")}`,
-        code: "invalid_enum",
-      });
-    }
-  }
-
-  // Number validations
-  if (schema.type === "number") {
-    if (schema.minimum !== undefined && value < schema.minimum) {
-      errors.push({
-        field: path,
-        message: `Value must be at least ${schema.minimum}`,
-        code: "minimum",
-      });
-    }
-
-    if (schema.maximum !== undefined && value > schema.maximum) {
-      errors.push({
-        field: path,
-        message: `Value must be at most ${schema.maximum}`,
-        code: "maximum",
-      });
-    }
-  }
-
-  // Array validations
-  if (schema.type === "array") {
-    if (schema.minItems && value.length < schema.minItems) {
-      errors.push({
-        field: path,
-        message: `Array must have at least ${schema.minItems} items`,
-        code: "min_items",
-      });
-    }
-
-    if (schema.maxItems && value.length > schema.maxItems) {
-      errors.push({
-        field: path,
-        message: `Array must have at most ${schema.maxItems} items`,
-        code: "max_items",
-      });
-    }
-
-    // Validate array items
-    if (schema.items) {
-      value.forEach((item, index) => {
-        const itemErrors = validateField(item, schema.items, `${path}[${index}]`);
-        errors.push(...itemErrors);
-      });
-    }
-  }
-
-  // Object validations
-  if (schema.type === "object" && schema.properties) {
-    const objectErrors = validateObject(value, schema, path);
-    errors.push(...objectErrors);
-  }
-
-  return errors;
-}
-
-/**
- * Common validation schemas
- */
-const commonSchemas = {
-  // Messages endpoint
-  messagesRequest: {
-    type: "object",
-    required: ["model", "messages"],
-    properties: {
-      model: {
-        type: "string",
-        minLength: 1,
-        maxLength: 200,
-      },
-      messages: {
-        type: "array",
-        minItems: 1,
-        maxItems: 1000,
-        items: {
-          type: "object",
-          required: ["role", "content"],
-          properties: {
-            role: {
-              type: "string",
-              enum: ["user", "assistant", "system"],
-            },
-            content: {
-              type: "string",
-              minLength: 1,
-            },
-          },
-        },
-      },
-      max_tokens: {
-        type: "number",
-        minimum: 1,
-        maximum: 100000,
-      },
-      temperature: {
-        type: "number",
-        minimum: 0,
-        maximum: 2,
-      },
-      stream: {
-        type: "boolean",
-      },
-    },
-  },
-};
-
-module.exports = {
-  validateBody,
-  validateQuery,
-  validateObject,
-  validateField,
-  commonSchemas,
-};

package/src/routing/drift-monitor.js

@@ -1,113 +0,0 @@
-/**
- * Drift monitor (Phase 4.3).
- *
- * Tracks two kinds of drift:
- *   - Input drift: distribution of query embeddings week-over-week via PSI
- *     (Population Stability Index) over coarse bucket assignments.
- *   - Output drift: refusal rate, average response length, latency
- *     distribution per model.
- *
- * Computes a PSI per metric; alerts when PSI > 0.2 (warning) or > 0.3
- * (full retrain recommended). Writes alerts to data/drift-alerts.json.
- *
- * Auto-retrain is gated on LYNKR_AUTO_RETRAIN=true and not implemented here —
- * the consumer (a cron job or the dashboard) decides what to do.
- */
-
-const fs = require('fs');
-const path = require('path');
-const logger = require('../logger');
-
-const ALERTS_PATH = path.join(__dirname, '../../data/drift-alerts.json');
-const WARN_THRESHOLD = 0.2;
-const RETRAIN_THRESHOLD = 0.3;
-
-function _bucketize(values, bucketCount = 10, min, max) {
-  if (values.length === 0) return new Array(bucketCount).fill(0);
-  const lo = min ?? Math.min(...values);
-  const hi = max ?? Math.max(...values);
-  const range = Math.max(1e-9, hi - lo);
-  const counts = new Array(bucketCount).fill(0);
-  for (const v of values) {
-    const idx = Math.max(0, Math.min(bucketCount - 1, Math.floor(((v - lo) / range) * bucketCount)));
-    counts[idx]++;
-  }
-  return counts;
-}
-
-/**
- * Population Stability Index between two distributions.
- * PSI = Σ (p_new - p_old) · ln(p_new / p_old)
- */
-function psi(oldCounts, newCounts) {
-  const oldTotal = oldCounts.reduce((s, c) => s + c, 0);
-  const newTotal = newCounts.reduce((s, c) => s + c, 0);
-  if (oldTotal === 0 || newTotal === 0) return 0;
-  let sum = 0;
-  for (let i = 0; i < oldCounts.length; i++) {
-    const p = (oldCounts[i] + 0.5) / (oldTotal + oldCounts.length * 0.5);
-    const q = (newCounts[i] + 0.5) / (newTotal + newCounts.length * 0.5);
-    sum += (q - p) * Math.log(q / p);
-  }
-  return sum;
-}
-
-function _writeAlert(alert) {
-  try {
-    fs.mkdirSync(path.dirname(ALERTS_PATH), { recursive: true });
-    let existing = [];
-    if (fs.existsSync(ALERTS_PATH)) {
-      try { existing = JSON.parse(fs.readFileSync(ALERTS_PATH, 'utf8')); } catch {}
-    }
-    const out = Array.isArray(existing) ? existing : [];
-    out.push({ ...alert, timestamp: Date.now() });
-    fs.writeFileSync(ALERTS_PATH, JSON.stringify(out.slice(-200), null, 2));
-  } catch (err) {
-    logger.warn({ err: err.message }, '[DriftMonitor] Alert write failed');
-  }
-}
-
-/**
- * Detect drift between two value series.
- * @param {string} metric - name for logging
- * @param {number[]} oldValues - reference window (e.g. last week)
- * @param {number[]} newValues - current window (e.g. last 24h)
- * @returns {{ psi, level, metric }}
- */
-function detect(metric, oldValues, newValues) {
-  if (oldValues.length < 50 || newValues.length < 20) {
-    return { psi: 0, level: 'insufficient_data', metric };
-  }
-  const combinedMin = Math.min(...oldValues, ...newValues);
-  const combinedMax = Math.max(...oldValues, ...newValues);
-  const oldB = _bucketize(oldValues, 10, combinedMin, combinedMax);
-  const newB = _bucketize(newValues, 10, combinedMin, combinedMax);
-  const p = psi(oldB, newB);
-  let level = 'ok';
-  if (p >= RETRAIN_THRESHOLD) level = 'retrain';
-  else if (p >= WARN_THRESHOLD) level = 'warn';
-
-  if (level !== 'ok') {
-    _writeAlert({ metric, psi: p, level, oldSize: oldValues.length, newSize: newValues.length });
-  }
-  return { psi: p, level, metric };
-}
-
-/**
- * Detect refusal-rate drift by counting the share of responses containing
- * refusal markers in two windows.
- */
-function refusalRateShift(oldResponses, newResponses) {
-  const markers = [/i can't help/i, /i won't/i, /against (?:my )?guidelines/i, /i cannot/i];
-  const _rate = (arr) => arr.filter(t => markers.some(m => m.test(t))).length / Math.max(1, arr.length);
-  return { old: _rate(oldResponses), new: _rate(newResponses) };
-}
-
-module.exports = {
-  psi,
-  detect,
-  refusalRateShift,
-  _bucketize,
-  WARN_THRESHOLD,
-  RETRAIN_THRESHOLD,
-};

package/src/workers/helpers.js

@@ -1,185 +0,0 @@
-/**
- * Worker Pool Helper Functions
- *
- * Provides easy-to-use async wrappers for offloading CPU-intensive operations
- * to worker threads with automatic fallback to sync operations.
- *
- * @module workers/helpers
- */
-
-const { getWorkerPool, isWorkerPoolReady } = require('./pool');
-const config = require('../config');
-
-// Threshold for offloading (bytes)
-const OFFLOAD_THRESHOLD = config.workerPool?.offloadThresholdBytes || 10000;
-
-/**
- * Deep clone an object, using worker thread for large objects
- * @param {*} obj - Object to clone
- * @returns {Promise<*>} - Cloned object
- */
-async function asyncClone(obj) {
-  // Estimate size quickly
-  let estimatedSize;
-  try {
-    estimatedSize = JSON.stringify(obj).length;
-  } catch {
-    // If stringify fails, fall back to sync clone
-    return syncClone(obj);
-  }
-
-  // Use worker for large objects, sync for small ones
-  if (config.workerPool?.enabled !== false && isWorkerPoolReady() && estimatedSize >= OFFLOAD_THRESHOLD) {
-    try {
-      const pool = getWorkerPool();
-      return await pool.clone(obj);
-    } catch (err) {
-      // Fall back to sync on error
-      return syncClone(obj);
-    }
-  }
-
-  return syncClone(obj);
-}
-
-/**
- * Synchronous clone (inline, for small objects)
- */
-function syncClone(obj) {
-  if (typeof structuredClone === 'function') {
-    try {
-      return structuredClone(obj);
-    } catch {
-      // structuredClone can fail on some objects
-    }
-  }
-  return JSON.parse(JSON.stringify(obj));
-}
-
-/**
- * Parse JSON, using worker thread for large strings
- * @param {string} jsonString - JSON string to parse
- * @returns {Promise<*>} - Parsed object
- */
-async function asyncParse(jsonString) {
-  if (typeof jsonString !== 'string') {
-    throw new TypeError('Expected a JSON string');
-  }
-
-  if (config.workerPool?.enabled !== false && isWorkerPoolReady() && jsonString.length >= OFFLOAD_THRESHOLD) {
-    try {
-      const pool = getWorkerPool();
-      return await pool.parse(jsonString);
-    } catch (err) {
-      // Fall back to sync on error
-      return JSON.parse(jsonString);
-    }
-  }
-
-  return JSON.parse(jsonString);
-}
-
-/**
- * Stringify object, using worker thread for large objects
- * @param {*} obj - Object to stringify
- * @returns {Promise<string>} - JSON string
- */
-async function asyncStringify(obj) {
-  // Quick check for size
-  const quick = JSON.stringify(obj);
-
-  if (config.workerPool?.enabled !== false && isWorkerPoolReady() && quick.length >= OFFLOAD_THRESHOLD) {
-    try {
-      const pool = getWorkerPool();
-      return await pool.stringify(obj);
-    } catch {
-      // Already have the result from quick check
-      return quick;
-    }
-  }
-
-  return quick;
-}
-
-/**
- * Transform messages (compression, truncation), using worker thread
- * @param {Array} messages - Messages to transform
- * @param {Object} options - Transform options
- * @returns {Promise<Object>} - Transformed messages with stats
- */
-async function asyncTransform(messages, options = {}) {
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return { messages, transformed: false, stats: {} };
-  }
-
-  if (config.workerPool?.enabled !== false && isWorkerPoolReady()) {
-    try {
-      const pool = getWorkerPool();
-      return await pool.transform(messages, options);
-    } catch (err) {
-      // Return untransformed on error
-      return { messages, transformed: false, stats: {}, error: err.message };
-    }
-  }
-
-  // Sync fallback - basic truncation
-  return syncTransform(messages, options);
-}
-
-/**
- * Synchronous transform fallback
- */
-function syncTransform(messages, options = {}) {
-  const { maxAssistantLength = 5000, maxToolResultLength = 3000 } = options;
-
-  const transformed = messages.map(msg => {
-    if (!msg) return msg;
-
-    // Truncate long assistant messages
-    if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.length > maxAssistantLength) {
-      return {
-        ...msg,
-        content: msg.content.substring(0, maxAssistantLength) + '\n[...truncated...]',
-      };
-    }
-
-    // Truncate tool results
-    if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > maxToolResultLength) {
-      return {
-        ...msg,
-        content: msg.content.substring(0, maxToolResultLength) + '\n[...truncated...]',
-      };
-    }
-
-    return msg;
-  });
-
-  return { messages: transformed, transformed: true, stats: {} };
-}
-
-/**
- * Get worker pool statistics
- * @returns {Object|null} - Pool stats or null if not available
- */
-function getPoolStats() {
-  if (!isWorkerPoolReady()) {
-    return null;
-  }
-  try {
-    const pool = getWorkerPool();
-    return pool.getStats();
-  } catch {
-    return null;
-  }
-}
-
-module.exports = {
-  asyncClone,
-  asyncParse,
-  asyncStringify,
-  asyncTransform,
-  syncClone,
-  syncTransform,
-  getPoolStats,
-  OFFLOAD_THRESHOLD,
-};