lynkr 9.7.3 → 9.9.1

package/src/dashboard/api.js

@@ -13,6 +13,7 @@ function providerMeta() {
     'azure-anthropic': { type: 'cloud', configured: !!(c.azureAnthropic?.endpoint && c.azureAnthropic?.apiKey) },
     bedrock:           { type: 'cloud', configured: !!c.bedrock?.apiKey },
     openrouter:        { type: 'cloud', configured: !!c.openrouter?.apiKey },
+    edenai:            { type: 'cloud', configured: !!c.edenai?.apiKey },
     openai:            { type: 'cloud', configured: !!c.openai?.apiKey },
     'azure-openai':    { type: 'cloud', configured: !!(c.azureOpenAI?.endpoint && c.azureOpenAI?.apiKey) },
     vertex:            { type: 'cloud', configured: !!c.vertex?.projectId },

package/src/logger/index.js

@@ -95,10 +95,23 @@ if (config.oversizedErrorLogging?.enabled) {
 	});
 }
 
+// Root level must be the most verbose of any enabled stream, or quieter
+// streams starve louder ones: LOG_LEVEL=silent (the recommended wrap
+// setting) used to make LOG_FILE_ENABLED capture nothing — the exact
+// sessions that most need a log file. Per-stream levels still apply, so
+// the console stays at LOG_LEVEL.
+const LEVEL_ORDER = ["trace", "debug", "info", "warn", "error", "fatal", "silent"];
+const rootLevel = streams
+	.map((s) => s.level)
+	.reduce(
+		(min, l) => (LEVEL_ORDER.indexOf(l) < LEVEL_ORDER.indexOf(min) ? l : min),
+		config.logger.level,
+	);
+
 // Create logger with multistream
 const logger = pino(
 	{
-		level: config.logger.level,
+		level: rootLevel,
 		name: "claude-backend",
 		base: {
 			env: config.env,

package/src/memory/search.js

@@ -10,7 +10,7 @@ const MAX_QUERY_LENGTH = 1000;
 const MAX_OR_TERMS = 50;
 
 // ============================================================================
-// KEYWORD SANITIZATION (NEW - Critical for FTS5 Safety)
+// KEYWORD SANITIZATION
 // ============================================================================
 
 /**
@@ -52,13 +52,13 @@ function sanitizeKeywords(keywords) {
 }
 
 // ============================================================================
-// FTS5 QUERY PREPARATION (UPDATED - Hardened)
+// FTS5 QUERY PREPARATION
 // ============================================================================
 
 /**
  * Prepare FTS5 query - handle special characters and phrases
  * 
- * CRITICAL FIX for better-sqlite3 v12+ (SQLite 3.46+):
+ * For better-sqlite3 v12+ (SQLite 3.46+):
  * - Commas and periods inside quoted strings cause "fts5: syntax error near ,"
  * - Solution: Extract keywords and search for them individually with OR
  * - This is more robust than attempting to quote complex phrases
@@ -66,7 +66,6 @@ function sanitizeKeywords(keywords) {
 function prepareFTS5Query(query) {
   let cleaned = query.trim();
 
-  // Length validation
   if (cleaned.length > MAX_QUERY_LENGTH) {
     logger.warn({ 
       queryLength: cleaned.length, 
@@ -145,7 +144,7 @@ function prepareFTS5Query(query) {
 }
 
 // ============================================================================
-// SEARCH FUNCTIONS (UPDATED)
+// SEARCH FUNCTIONS
 // ============================================================================
 
 /**
@@ -175,7 +174,6 @@ function searchMemories(options) {
       ftsQuery: ftsQuery.substring(0, 100) 
     }, 'FTS5 query prepared');
 
-    // Build SQL with filters
     let sql = `
       SELECT m.id, m.session_id, m.content, m.type, m.category,
              m.importance, m.surprise_score, m.access_count, m.decay_factor,
@@ -188,7 +186,6 @@ function searchMemories(options) {
 
     const params = [ftsQuery];
 
-    // Add filters
     if (sessionId) {
       sql += ` AND (m.session_id = ? OR m.session_id IS NULL)`;
       params.push(sessionId);
@@ -211,7 +208,6 @@ function searchMemories(options) {
       params.push(minImportance);
     }
 
-    // Order by FTS5 rank and importance
     sql += ` ORDER BY memories_fts.rank, m.importance DESC LIMIT ?`;
     params.push(limit);
 
@@ -264,9 +260,8 @@ function searchMemories(options) {
 function searchWithExpansion(options) {
   const { query, limit = 10 } = options;
 
-  // Extract keywords from query
   const keywords = extractKeywords(query);
-  const sanitizedKeywords = sanitizeKeywords(keywords);  // ✅ ADDED
+  const sanitizedKeywords = sanitizeKeywords(keywords);
 
   // Search with original query (already sanitized by prepareFTS5Query)
   const results = searchMemories({ ...options, limit: limit * 2 });
@@ -275,7 +270,7 @@ function searchWithExpansion(options) {
   if (results.length < limit && sanitizedKeywords.length > 1) {
     const seen = new Set(results.map((r) => r.id));
 
-    for (const keyword of sanitizedKeywords) {  // ✅ CHANGED - use sanitized
+    for (const keyword of sanitizedKeywords) {
       if (results.length >= limit) break;
 
       const kwResults = searchMemories({
@@ -315,7 +310,7 @@ function extractKeywords(text) {
 }
 
 /**
- * Find similar memories by keyword overlap (UPDATED - sanitized)
+ * Find similar memories by keyword overlap
  */
 function findSimilar(memoryId, limit = 5) {
   const memory = store.getMemory(memoryId);
@@ -324,12 +319,12 @@ function findSimilar(memoryId, limit = 5) {
   }
 
   const keywords = extractKeywords(memory.content);
-  const sanitizedKeywords = sanitizeKeywords(keywords);  // ✅ ADDED
-  
+  const sanitizedKeywords = sanitizeKeywords(keywords);
+
   if (sanitizedKeywords.length === 0) return [];
 
   // Build OR query with SANITIZED keywords
-  const query = sanitizedKeywords.join(" OR ");  // ✅ CHANGED - use sanitized
+  const query = sanitizedKeywords.join(" OR ");
 
   const results = searchMemories({
     query,
@@ -339,27 +334,6 @@ function findSimilar(memoryId, limit = 5) {
   return results.filter((r) => r.id !== memoryId).slice(0, limit);
 }
 
-/**
- * Search by content similarity (UPDATED - sanitized)
- */
-function searchByContent(content, options = {}) {
-  const keywords = extractKeywords(content);
-  const sanitizedKeywords = sanitizeKeywords(keywords);  // ✅ ADDED
-  
-  if (sanitizedKeywords.length === 0) return [];
-
-  const query = sanitizedKeywords.slice(0, 5).join(" OR ");  // ✅ CHANGED
-  return searchMemories({ ...options, query });
-}
-
-/**
- * Count search results without fetching them
- */
-function countSearchResults(options) {
-  const results = searchMemories({ ...options, limit: 1000 });
-  return results.length;
-}
-
 // ============================================================================
 // EXPORTS
 // ============================================================================
@@ -369,9 +343,7 @@ module.exports = {
   searchWithExpansion,
   extractKeywords,
   findSimilar,
-  searchByContent,
-  countSearchResults,
   prepareFTS5Query,
-  sanitizeKeyword,      // ✅ NEW - exported for testing
-  sanitizeKeywords,     // ✅ NEW - exported for testing
+  sanitizeKeyword,      // exported for testing
+  sanitizeKeywords,     // exported for testing
 };

package/src/memory/tools.js

@@ -13,19 +13,16 @@ const MAX_QUERY_LENGTH = 1000;
 const MAX_CONTENT_LENGTH = 5000;
 
 // ============================================================================
-// MEMORY TOOLS (UPDATED WITH VALIDATION)
+// MEMORY TOOLS
 // ============================================================================
 
 /**
  * Tool: memory_search
  * Search long-term memories for relevant facts
- * 
- * UPDATED: Added input validation to prevent FTS5 errors and injection
  */
 async function memory_search(args, context = {}) {
   const { query, limit = 10, type, category } = args;
 
-  // ✅ Validate query exists and is string
   if (!query || typeof query !== 'string') {
     return {
       ok: false,
@@ -35,18 +32,16 @@ async function memory_search(args, context = {}) {
     };
   }
 
-  // ✅ Validate query length
   if (query.length > MAX_QUERY_LENGTH) {
     return {
       ok: false,
-      content: JSON.stringify({ 
+      content: JSON.stringify({
         error: `Query too long (max ${MAX_QUERY_LENGTH} characters)`,
         provided: query.length
       }),
     };
   }
 
-  // ✅ Validate type if provided
   if (type && !VALID_TYPES.includes(type)) {
     return {
       ok: false,
@@ -57,7 +52,6 @@ async function memory_search(args, context = {}) {
     };
   }
 
-  // ✅ Validate category if provided
   if (category && !VALID_CATEGORIES.includes(category)) {
     return {
       ok: false,
@@ -68,7 +62,6 @@ async function memory_search(args, context = {}) {
     };
   }
 
-  // ✅ Validate limit
   if (typeof limit !== 'number' || limit < 1 || limit > 100) {
     return {
       ok: false,
@@ -121,8 +114,6 @@ async function memory_search(args, context = {}) {
 /**
  * Tool: memory_add
  * Manually add a fact to long-term memory
- * 
- * UPDATED: Enhanced validation
  */
 async function memory_add(args, context = {}) {
   const {
@@ -132,7 +123,6 @@ async function memory_add(args, context = {}) {
     importance = 0.5,
   } = args;
 
-  // ✅ Validate content
   if (!content || typeof content !== 'string') {
     return {
       ok: false,
@@ -142,7 +132,6 @@ async function memory_add(args, context = {}) {
     };
   }
 
-  // ✅ Validate content length
   if (content.length > MAX_CONTENT_LENGTH) {
     return {
       ok: false,
@@ -163,7 +152,6 @@ async function memory_add(args, context = {}) {
     };
   }
 
-  // ✅ Validate type
   if (!VALID_TYPES.includes(type)) {
     return {
       ok: false,
@@ -174,7 +162,6 @@ async function memory_add(args, context = {}) {
     };
   }
 
-  // ✅ Validate category
   if (!VALID_CATEGORIES.includes(category)) {
     return {
       ok: false,
@@ -185,7 +172,6 @@ async function memory_add(args, context = {}) {
     };
   }
 
-  // ✅ Validate importance
   if (typeof importance !== 'number' || importance < 0 || importance > 1) {
     return {
       ok: false,
@@ -241,13 +227,10 @@ async function memory_add(args, context = {}) {
 /**
  * Tool: memory_forget
  * Remove memories matching a query
- * 
- * UPDATED: Enhanced validation
  */
 async function memory_forget(args, context = {}) {
   const { query, confirm = false } = args;
 
-  // ✅ Validate query
   if (!query || typeof query !== 'string') {
     return {
       ok: false,
@@ -257,7 +240,6 @@ async function memory_forget(args, context = {}) {
     };
   }
 
-  // ✅ Validate query length
   if (query.length > MAX_QUERY_LENGTH) {
     return {
       ok: false,
@@ -268,7 +250,6 @@ async function memory_forget(args, context = {}) {
     };
   }
 
-  // ✅ Validate confirm is boolean
   if (typeof confirm !== 'boolean') {
     return {
       ok: false,
@@ -280,7 +261,6 @@ async function memory_forget(args, context = {}) {
   }
 
   try {
-    // Search for matching memories
     const matches = search.searchMemories({
       query,
       limit: 50, // Check up to 50 matches
@@ -318,7 +298,6 @@ async function memory_forget(args, context = {}) {
       };
     }
 
-    // Delete all matching memories
     let deletedCount = 0;
     for (const memory of matches) {
       const deleted = store.deleteMemory(memory.id);
@@ -386,7 +365,7 @@ async function memory_stats(args, context = {}) {
 }
 
 // ============================================================================
-// TOOL DEFINITIONS (UPDATED)
+// TOOL DEFINITIONS
 // ============================================================================
 
 const MEMORY_TOOLS = {

package/src/orchestrator/bypass.js

@@ -90,10 +90,12 @@ function detectBypass({ payload, headers = {} }) {
     };
   }
 
-  // Pattern 3: Warmup / count probes — a single short user message.
+  // Pattern 3: Warmup / count / quota probes — single short user messages.
+  // Unbypassed probes reach a real model, whose confused replies get
+  // memory-extracted and re-injected into real turns.
   if (messages.length === 1 && messages[0]?.role === "user") {
     const firstText = getText(messages[0].content).trim();
-    if (firstText === "Warmup" || firstText === "count") {
+    if (firstText === "Warmup" || firstText === "count" || firstText === "quota") {
       return { kind: firstText.toLowerCase(), text: "OK" };
     }
   }