lynkr 8.0.1 → 9.0.1

package/src/clients/retry.js

@@ -1,200 +1,55 @@
-const logger = require("../logger");
-
 /**
- * Retry configuration for API calls
+ * Retry logic for API calls — backed by Cockatiel
+ *
+ * This module re-exports the Cockatiel-backed retry adapter from resilience.js
+ * while preserving all original exports for consumers.
  */
+const { withCockatielRetry, DEFAULT_RETRY_CONFIG } = require("./resilience");
+
 const DEFAULT_CONFIG = {
-  maxRetries: 3,
-  initialDelay: 1000, // 1 second
-  maxDelay: 30000, // 30 seconds
-  backoffMultiplier: 2,
-  jitterFactor: 0.1, // 10% jitter
-  retryableStatuses: [429, 500, 502, 503, 504],
-  retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'ENETUNREACH', 'ECONNREFUSED'],
+  maxRetries: DEFAULT_RETRY_CONFIG.maxRetries,
+  initialDelay: DEFAULT_RETRY_CONFIG.initialDelay,
+  maxDelay: DEFAULT_RETRY_CONFIG.maxDelay,
+  backoffMultiplier: DEFAULT_RETRY_CONFIG.backoffMultiplier,
+  jitterFactor: DEFAULT_RETRY_CONFIG.jitterFactor,
+  retryableStatuses: DEFAULT_RETRY_CONFIG.retryableStatuses,
+  retryableErrors: DEFAULT_RETRY_CONFIG.retryableErrors,
 };
 
 /**
- * Add jitter to prevent thundering herd
- */
-function addJitter(delay, jitterFactor) {
-  const jitter = delay * jitterFactor * (Math.random() * 2 - 1);
-  return Math.max(0, delay + jitter);
-}
-
-/**
- * Calculate delay with exponential backoff
+ * Calculate delay with exponential backoff (preserved for any direct callers)
  */
 function calculateDelay(attempt, config) {
   const baseDelay = config.initialDelay * Math.pow(config.backoffMultiplier, attempt);
   const cappedDelay = Math.min(baseDelay, config.maxDelay);
-  return addJitter(cappedDelay, config.jitterFactor);
+  const jitter = cappedDelay * config.jitterFactor * (Math.random() * 2 - 1);
+  return Math.max(0, cappedDelay + jitter);
 }
 
 /**
- * Check if error/response is retryable
+ * Check if error/response is retryable (preserved for any direct callers)
  */
 function isRetryable(error, response, config) {
-  // Check response status codes
   if (response && config.retryableStatuses.includes(response.status)) {
     return true;
   }
-
-  // Check error codes
   if (error && error.code && config.retryableErrors.includes(error.code)) {
     return true;
   }
-
-  // Check nested cause (Node undici wraps connection errors as TypeError)
   if (error && error.cause?.code && config.retryableErrors.includes(error.cause.code)) {
     return true;
   }
-
-  // Check for network errors
-  if (error && (error.name === 'FetchError' || error.name === 'AbortError')) {
+  if (error && (error.name === "FetchError" || error.name === "AbortError")) {
     return true;
   }
-
   return false;
 }
 
 /**
- * Detect if this is a cold start (longer than expected response time)
+ * Detect if this is a cold start
  */
 function detectColdStart(startTime, endTime, threshold = 5000) {
-  const duration = endTime - startTime;
-  return duration > threshold;
-}
-
-/**
- * Execute function with retry logic
- */
-async function withRetry(fn, options = {}) {
-  const config = { ...DEFAULT_CONFIG, ...options };
-  let lastError;
-  let lastResponse;
-
-  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
-    const startTime = Date.now();
-
-    try {
-      const result = await fn(attempt);
-      const endTime = Date.now();
-
-      // Detect cold starts for monitoring
-      if (detectColdStart(startTime, endTime)) {
-        logger.warn({
-          attempt,
-          duration: endTime - startTime,
-        }, 'Potential cold start detected');
-      }
-
-      // Check if response indicates we should retry
-      if (result && isRetryable(null, result, config) && attempt < config.maxRetries) {
-        lastResponse = result;
-
-        // Special handling for 429 (rate limiting)
-        if (result.status === 429) {
-          // Check for Retry-After header
-          const retryAfter = result.headers?.get?.('retry-after');
-          let delay;
-
-          if (retryAfter) {
-            // Retry-After can be in seconds or a date
-            const retryAfterNum = parseInt(retryAfter, 10);
-            if (!isNaN(retryAfterNum)) {
-              delay = retryAfterNum * 1000; // Convert to ms
-            } else {
-              const retryAfterDate = new Date(retryAfter);
-              delay = retryAfterDate.getTime() - Date.now();
-            }
-          } else {
-            // Use exponential backoff with longer delays for rate limiting
-            delay = calculateDelay(attempt, {
-              ...config,
-              initialDelay: 2000, // Start at 2s for rate limits
-              maxDelay: 60000, // Up to 1 minute
-            });
-          }
-
-          logger.warn({
-            attempt,
-            delay,
-            retryAfter: retryAfter || 'not specified',
-          }, 'Rate limited (429), retrying after delay');
-
-          await sleep(delay);
-          continue;
-        }
-
-        // Regular retry with exponential backoff
-        const delay = calculateDelay(attempt, config);
-        logger.warn({
-          attempt,
-          status: result.status,
-          delay,
-        }, 'Request failed, retrying with backoff');
-
-        await sleep(delay);
-        continue;
-      }
-
-      // Success or non-retryable error
-      return result;
-
-    } catch (error) {
-      lastError = error;
-      const endTime = Date.now();
-
-      // Check if cold start
-      if (detectColdStart(startTime, endTime)) {
-        logger.warn({
-          attempt,
-          duration: endTime - startTime,
-          error: error.message,
-        }, 'Potential cold start with error detected');
-      }
-
-      // Check if we should retry
-      if (isRetryable(error, null, config) && attempt < config.maxRetries) {
-        const delay = calculateDelay(attempt, config);
-        logger.warn({
-          attempt,
-          error: error.message,
-          code: error.code,
-          delay,
-        }, 'Request error, retrying with backoff');
-
-        await sleep(delay);
-        continue;
-      }
-
-      // Not retryable or out of retries
-      throw error;
-    }
-  }
-
-  // Max retries exceeded
-  if (lastError) {
-    lastError.message = `Max retries (${config.maxRetries}) exceeded: ${lastError.message}`;
-    throw lastError;
-  }
-
-  if (lastResponse) {
-    logger.error({
-      status: lastResponse.status,
-      maxRetries: config.maxRetries,
-    }, 'Max retries exceeded');
-    return lastResponse;
-  }
-
-  throw new Error('Retry logic failed unexpectedly');
-}
-
-/**
- * Sleep helper
- */
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return (endTime - startTime) > threshold;
 }
 
 /**
@@ -202,12 +57,12 @@ function sleep(ms) {
  */
 function createRetryWrapper(fn, defaultOptions = {}) {
   return async function (...args) {
-    return withRetry(() => fn(...args), defaultOptions);
+    return withCockatielRetry(() => fn(...args), defaultOptions);
   };
 }
 
 module.exports = {
-  withRetry,
+  withRetry: withCockatielRetry,
   createRetryWrapper,
   calculateDelay,
   isRetryable,

package/src/config/index.js

@@ -618,6 +618,12 @@ var config = {
     endpoint: moonshotEndpoint,
     model: moonshotModel,
   },
+  codex: {
+    enabled: process.env.CODEX_ENABLED !== "false",
+    binaryPath: process.env.CODEX_BINARY_PATH?.trim() || null,
+    model: process.env.CODEX_MODEL?.trim() || "gpt-5.3-codex",
+    timeout: Number.parseInt(process.env.CODEX_TIMEOUT || "120000", 10) || 120000,
+  },
   hotReload: {
     enabled: hotReloadEnabled,
     debounceMs: Number.isNaN(hotReloadDebounceMs) ? 1000 : hotReloadDebounceMs,
@@ -733,6 +739,10 @@ var config = {
       manifestPath: sandboxManifestPath,
       manifestDirs: sandboxManifestDirs,
     },
+    codeMode: {
+      enabled: process.env.CODE_MODE_ENABLED === 'true',
+      toolListCacheTtl: parseInt(process.env.CODE_MODE_CACHE_TTL, 10) || 60_000,
+    },
   },
   promptCache: {
     enabled: promptCacheEnabled,
@@ -918,6 +928,25 @@ var config = {
     COMPLEX: process.env.TIER_COMPLEX?.trim() || null,
     REASONING: process.env.TIER_REASONING?.trim() || null,
   },
+
+  // Graphify knowledge graph integration (structural analysis)
+  codeGraph: {
+    enabled: process.env.CODE_GRAPH_ENABLED === 'true',
+    command: process.env.CODE_GRAPH_COMMAND || 'graphify',
+    workspace: process.env.CODE_GRAPH_WORKSPACE || process.cwd(),
+    timeout: parseInt(process.env.CODE_GRAPH_TIMEOUT, 10) || 10000,
+  },
+
+  // Large payload optimization (skip cloning media blocks that get discarded)
+  largePayload: {
+    enabled: process.env.LARGE_PAYLOAD_OPTIMIZATION !== 'false',
+    threshold: parseInt(process.env.LARGE_PAYLOAD_THRESHOLD, 10) || 1_048_576,
+  },
+
+  // OpenClaw integration
+  openclaw: {
+    enabled: process.env.OPENCLAW_MODE === "true",
+  },
 };
 
 /**
@@ -964,9 +993,37 @@ function reloadConfig() {
   config.toon.failOpen = process.env.TOON_FAIL_OPEN !== "false";
   config.toon.logStats = process.env.TOON_LOG_STATS !== "false";
 
+  // Tier routing (critical for fixing model name issues without restart)
+  config.modelTiers.SIMPLE = process.env.TIER_SIMPLE?.trim() || null;
+  config.modelTiers.MEDIUM = process.env.TIER_MEDIUM?.trim() || null;
+  config.modelTiers.COMPLEX = process.env.TIER_COMPLEX?.trim() || null;
+  config.modelTiers.REASONING = process.env.TIER_REASONING?.trim() || null;
+  config.modelTiers.enabled = !!(config.modelTiers.SIMPLE && config.modelTiers.MEDIUM && config.modelTiers.COMPLEX && config.modelTiers.REASONING);
+
+  // Ollama model
+  config.ollama.endpoint = process.env.OLLAMA_ENDPOINT ?? config.ollama.endpoint;
+
+  // OpenClaw
+  config.openclaw.enabled = process.env.OPENCLAW_MODE === "true";
+
+  // Graphify
+  config.codeGraph.enabled = process.env.CODE_GRAPH_ENABLED === 'true';
+
+  // Code Mode
+  config.mcp.codeMode.enabled = process.env.CODE_MODE_ENABLED === 'true';
+
   // Log level
   config.logger.level = process.env.LOG_LEVEL ?? "info";
 
+  // Reset circuit breakers so stale OPEN states don't persist
+  try {
+    const { getCircuitBreakerRegistry } = require('../clients/circuit-breaker');
+    getCircuitBreakerRegistry().resetAll();
+    console.log("[CONFIG] Circuit breakers reset");
+  } catch (e) {
+    // Ignore if not yet initialized
+  }
+
   console.log("[CONFIG] Configuration reloaded from environment");
   return config;
 }

package/src/context/compression.js

@@ -11,6 +11,7 @@
 
 const logger = require('../logger');
 const config = require('../config');
+const distill = require('./distill');
 
 /**
  * Compress conversation history to fit within token budget
@@ -62,6 +63,18 @@ function compressHistory(messages, options = {}) {
     compressed = oldMessages.map(msg => compressMessage(msg));
   }
 
+  // Apply Distill dedup across all old messages to collapse repetitive tool results
+  if (compressed.length > 0) {
+    const dedupResult = distill.deduplicateHistory(compressed);
+    if (dedupResult.stats.deduplicated > 0) {
+      compressed = dedupResult.messages;
+      logger.debug({
+        checked: dedupResult.stats.checked,
+        deduplicated: dedupResult.stats.deduplicated,
+      }, '[Distill] History dedup applied to old messages');
+    }
+  }
+
   // Add recent messages (may compress tool results but keep content)
   const recentCompressed = recentMessages.map(msg => compressToolResults(msg));
 
@@ -248,12 +261,15 @@ function compressContentBlock(block) {
  * Compress tool result block
  *
  * Tool results can be very large (file contents, bash output).
- * Compress while preserving essential information.
+ * Uses Distill algorithms (normalization, delta, dedup) before
+ * falling back to head/tail truncation.
  *
  * @param {Object} block - tool_result block
+ * @param {Object} options - Options for compression
+ * @param {string} options.previousResult - Previous tool result for delta rendering
  * @returns {Object} Compressed tool_result
  */
-function compressToolResultBlock(block) {
+function compressToolResultBlock(block, options = {}) {
   if (!block || block.type !== 'tool_result') return block;
 
   const compressed = {
@@ -261,18 +277,32 @@ function compressToolResultBlock(block) {
     tool_use_id: block.tool_use_id,
   };
 
-  // Compress content
+  // Compress content using Distill when content is large enough to benefit
   if (typeof block.content === 'string') {
-    compressed.content = compressText(block.content, 500);
+    if (block.content.length > 500) {
+      const result = distill.compressToolResult(block.content, {
+        previousResult: options.previousResult,
+        maxLength: 500,
+      });
+      compressed.content = result.text;
+    } else {
+      compressed.content = block.content;
+    }
   } else if (Array.isArray(block.content)) {
     compressed.content = block.content.map(item => {
       if (typeof item === 'string') {
-        return compressText(item, 500);
+        if (item.length > 500) {
+          return distill.compressToolResult(item, { maxLength: 500 }).text;
+        }
+        return item;
       } else if (item.type === 'text') {
-        return {
-          type: 'text',
-          text: compressText(item.text, 500)
-        };
+        if (item.text && item.text.length > 500) {
+          return {
+            type: 'text',
+            text: distill.compressToolResult(item.text, { maxLength: 500 }).text,
+          };
+        }
+        return item;
       }
       return item;
     });
@@ -453,7 +483,10 @@ module.exports = {
   compressHistory,
   compressMessage,
   compressToolResults,
+  compressToolResultBlock,
   calculateCompressionStats,
   needsCompression,
   summarizeOldHistory,
+  // Distill re-exports for direct access
+  distill,
 };