lynkr 9.14.1 → 9.14.3

package/src/clients/gpt-utils.js

@@ -25,7 +25,7 @@ function stringSimilarity(s1, s2) {
   // Tokenize by whitespace and common delimiters
   const tokenize = (s) => new Set(
     s.toLowerCase()
-      .split(/[\s\-_\/\.\,\:\;]+/)
+      .split(/[\s\-_/.,:;]+/)
       .filter(t => t.length > 0)
   );
 
@@ -38,6 +38,45 @@ function stringSimilarity(s1, s2) {
   return union.size > 0 ? intersection.size / union.size : 0;
 }
 
+// Common argument keys a Read-style tool might carry its target path under,
+// across different clients/harnesses.
+const FILE_PATH_ARG_KEYS = ['file_path', 'path', 'filePath', 'filename', 'file'];
+
+/**
+ * Pull a file-path argument out of a (possibly stringified) args object,
+ * trying the common key spellings different clients use.
+ * @param {string|Object} args
+ * @returns {string|null}
+ */
+function extractFilePathArg(args) {
+  let obj = args;
+  if (typeof obj === 'string') {
+    try { obj = JSON.parse(obj); } catch { return null; }
+  }
+  if (!obj || typeof obj !== 'object') return null;
+  for (const key of FILE_PATH_ARG_KEYS) {
+    if (typeof obj[key] === 'string' && obj[key]) return obj[key];
+  }
+  return null;
+}
+
+/**
+ * Extract a read window [start, end) from read-tool args (offset/limit in
+ * lines, the convention Claude Code, opencode, and Cursor all share).
+ * Missing offset → 0; missing limit → open-ended (whole rest of the file).
+ * @param {string|Object} args
+ * @returns {{ start: number, end: number }}
+ */
+function extractReadWindow(args) {
+  let obj = args;
+  if (typeof obj === 'string') {
+    try { obj = JSON.parse(obj); } catch { obj = null; }
+  }
+  const start = Number.isFinite(obj?.offset) ? obj.offset : 0;
+  const limit = Number.isFinite(obj?.limit) && obj.limit > 0 ? obj.limit : Infinity;
+  return { start, end: start + limit };
+}
+
 /**
  * Check if two tool calls are semantically similar
  * @param {Object} call1 - First tool call {name, arguments}
@@ -59,17 +98,53 @@ function areSimilarToolCalls(call1, call2) {
 
   if (argsStr1 === argsStr2) return true;
 
+  const toolName = (name1 || '').toLowerCase();
+
+  // Read-style tools: NOT Jaccard-fuzzy-matched (see below for why), and NOT
+  // matched on path alone either. This rule has flip-flopped through two live
+  // incidents, so the history matters:
+  //
+  //   1. Jaccard on paths merged reads of DIFFERENT files (repo paths share
+  //      nearly every token) → fixed by exact path equality.
+  //   2. Exact-args-only let an agent re-read one file at OVERLAPPING offsets
+  //      ~10 times, restating the same conclusion, without ever tripping the
+  //      guard → fixed by counting any same-path read as similar.
+  //   3. That overcorrected: paging through DISJOINT regions of one large
+  //      file is exactly how a coding agent works on it (live incident: a
+  //      4,000-line settings.rs read at offsets 975/3485/3800 tripped the
+  //      warn threshold, and the injected "STOP calling this tool" order
+  //      killed the work turn — repeatedly).
+  //
+  // The rule that satisfies all three: same file + OVERLAPPING (or identical)
+  // windows → similar (re-reading content you already have); same file +
+  // DISJOINT windows → paging, not a loop. Whole-file reads (no offset/limit)
+  // have an open-ended window, so they overlap everything in that file —
+  // repeated whole-file re-reads still count, incident #2 stays fixed.
+  if (toolName.includes('read')) {
+    const path1 = extractFilePathArg(args1);
+    const path2 = extractFilePathArg(args2);
+    if (path1 && path2 && path1 === path2) {
+      const w1 = extractReadWindow(args1);
+      const w2 = extractReadWindow(args2);
+      const overlaps = w1.start < w2.end && w2.start < w1.end;
+      if (overlaps) {
+        logger.debug({ tool: name1, path: path1, w1, w2 }, "Same-file overlapping re-read detected");
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+
   // Only search-style tools get fuzzy matching; mutating tools with
   // near-identical args may be intentional repeats.
-  // 'read' is deliberately NOT fuzzy-matched: its argument is a file path, and
-  // absolute paths in one repo share nearly every Jaccard token
-  // (/Users/x/project/src/…), so reads of DIFFERENT files scored ≥0.8 and
-  // merged into one "repeated call" signature (live incident: an opencode
+  // 'read' is handled above, deliberately NOT via Jaccard: its argument is a
+  // file path, and absolute paths in one repo share nearly every Jaccard
+  // token (/Users/x/project/src/…), so reads of DIFFERENT files scored ≥0.8
+  // and merged into one "repeated call" signature (live incident: an opencode
   // code-trace reading server.js, openai-router.js and orchestrator/index.js
-  // was flagged as a loop). A genuine re-read of the same file is caught by
-  // the exact-match branch above.
+  // was flagged as a loop).
   const searchTools = ['grep', 'glob', 'search', 'find', 'bash', 'shell'];
-  const toolName = (name1 || '').toLowerCase();
   const isSearchTool = searchTools.some(t => toolName.includes(t));
 
   if (isSearchTool) {
@@ -91,4 +166,5 @@ function areSimilarToolCalls(call1, call2) {
 
 module.exports = {
   areSimilarToolCalls,
+  extractReadWindow,
 };

package/src/clients/health-probe.js

@@ -0,0 +1,157 @@
+/**
+ * Synthetic circuit-breaker health probe (ROUTING-NOTES §1 gap audit).
+ *
+ * Problem: cockatiel's halfOpenAfter is a pure timer — after it elapses, the
+ * NEXT LIVE USER REQUEST is the recovery probe. A user pays the latency/cost
+ * of testing a dead provider, and a provider with no traffic never recovers.
+ *
+ * Fix (the pattern LiteLLM ships as health-check-driven routing): a
+ * background loop that, for every breaker currently OPEN or HALF_OPEN, runs
+ * a cheap synthetic request *through the breaker* (`breaker.execute(probe)`)
+ * on a schedule. A success closes the circuit via cockatiel's normal
+ * half-open transition; a failure re-opens it. Healthy breakers are never
+ * probed — the loop is zero-cost when everything is up.
+ *
+ * Probes are registered per provider name (the breaker registry key).
+ * Built-in probes cover the local providers (ollama / llamacpp / lmstudio),
+ * whose cheap GET endpoints are well-known, free, and exactly where the
+ * dead-upstream-hang problem historically lived. Cloud providers can be
+ * added via registerHealthProbe(name, fn); without one, their recovery
+ * stays as before (next live request) — no behavior regression.
+ */
+
+const config = require('../config');
+const logger = require('../logger');
+const { getCockatielRegistry } = require('./resilience');
+
+const PROBE_INTERVAL_MS = Number.parseInt(process.env.LYNKR_HEALTH_PROBE_INTERVAL_MS, 10) || 30_000;
+const PROBE_TIMEOUT_MS = Number.parseInt(process.env.LYNKR_HEALTH_PROBE_TIMEOUT_MS, 10) || 5_000;
+const ENABLED = process.env.LYNKR_HEALTH_PROBE_ENABLED !== 'false';
+
+/** @type {Map<string, () => Promise<void>>} providerName → probe fn (throws on unhealthy) */
+const probes = new Map();
+
+async function _cheapGet(url, headers = {}) {
+  const response = await fetch(url, {
+    method: 'GET',
+    headers,
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+  });
+  if (!response.ok) {
+    throw new Error(`health probe ${url} → ${response.status}`);
+  }
+  // Drain the (small) body so the socket is released cleanly.
+  await response.arrayBuffer().catch(() => {});
+}
+
+function _registerBuiltins() {
+  if (config.ollama?.endpoint) {
+    probes.set('ollama', () => _cheapGet(`${config.ollama.endpoint}/api/tags`));
+  }
+  if (config.llamacpp?.endpoint) {
+    const headers = config.llamacpp.apiKey
+      ? { Authorization: `Bearer ${config.llamacpp.apiKey}` }
+      : {};
+    probes.set('llamacpp', () => _cheapGet(`${config.llamacpp.endpoint}/v1/models`, headers));
+  }
+  if (config.lmstudio?.endpoint) {
+    const headers = config.lmstudio.apiKey
+      ? { Authorization: `Bearer ${config.lmstudio.apiKey}` }
+      : {};
+    probes.set('lmstudio', () => _cheapGet(`${config.lmstudio.endpoint}/v1/models`, headers));
+  }
+}
+
+/**
+ * Register (or override) a synthetic probe for a provider. The function must
+ * resolve when the provider is healthy and throw/reject when it is not.
+ * @param {string} providerName — must match the circuit breaker registry key
+ * @param {() => Promise<void>} probeFn
+ */
+function registerHealthProbe(providerName, probeFn) {
+  probes.set(providerName, probeFn);
+}
+
+class HealthProber {
+  constructor() {
+    this.timer = null;
+    this.stats = { sweeps: 0, probesSent: 0, recoveries: 0, failures: 0, lastSweepAt: null };
+  }
+
+  start() {
+    if (this.timer || !ENABLED) return;
+    _registerBuiltins();
+    this.timer = setInterval(() => {
+      this.sweep().catch((err) => {
+        logger.debug({ error: err.message }, '[HealthProbe] sweep error');
+      });
+    }, PROBE_INTERVAL_MS);
+    // Never keep the process alive just to probe.
+    this.timer.unref?.();
+    logger.info(
+      { intervalMs: PROBE_INTERVAL_MS, providers: [...probes.keys()] },
+      '[HealthProbe] Synthetic circuit-breaker probing started'
+    );
+  }
+
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  /**
+   * One probing pass: probe every registered provider whose breaker is not
+   * closed. Runs probes through the breaker itself so state transitions use
+   * cockatiel's own half-open machinery.
+   */
+  async sweep() {
+    this.stats.sweeps += 1;
+    this.stats.lastSweepAt = Date.now();
+    const registry = getCockatielRegistry();
+    const work = [];
+    for (const [providerName, probeFn] of probes) {
+      const breaker = registry.breakers.get(providerName);
+      if (!breaker || breaker.state === 'CLOSED') continue;
+      work.push(
+        (async () => {
+          this.stats.probesSent += 1;
+          try {
+            await breaker.execute(probeFn);
+            this.stats.recoveries += 1;
+            logger.info({ provider: providerName }, '[HealthProbe] Provider recovered via synthetic probe — circuit closed without a live request paying for the test');
+          } catch (err) {
+            // Expected while the provider is still down (or the circuit is
+            // OPEN and not yet past halfOpenAfter, where execute rejects
+            // immediately without dialing). Stay quiet; the breaker's own
+            // state logging covers transitions.
+            this.stats.failures += 1;
+            logger.debug({ provider: providerName, error: err.message }, '[HealthProbe] probe failed');
+          }
+        })()
+      );
+    }
+    await Promise.all(work);
+  }
+
+  getStatus() {
+    return {
+      enabled: ENABLED,
+      running: !!this.timer,
+      intervalMs: PROBE_INTERVAL_MS,
+      registeredProviders: [...probes.keys()],
+      ...this.stats,
+    };
+  }
+}
+
+let prober = null;
+
+/** @returns {HealthProber} singleton */
+function getHealthProber() {
+  if (!prober) prober = new HealthProber();
+  return prober;
+}
+
+module.exports = { getHealthProber, registerHealthProbe };

package/src/clients/openai-format.js

@@ -113,21 +113,48 @@ function convertOpenAIToAnthropic(openaiRequest) {
         });
       }
     } else if (msg.role === "tool") {
-      // OpenAI tool response → Anthropic tool_result
-      const previousMsg = anthropicMessages[anthropicMessages.length - 1];
-
-      // Tool results must follow assistant message with tool_use
-      // Add as separate user message with tool_result
-      anthropicMessages.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: msg.tool_call_id,
-            content: msg.content
-          }
-        ]
-      });
+      // OpenAI tool response → Anthropic tool_result. Two Anthropic rules
+      // apply (violating either 400s the request):
+      //   1. Every tool_use_id must match a tool_use block in the preceding
+      //      assistant message — orphans are rejected as "unexpected
+      //      tool_use_id".
+      //   2. All tool_results for one assistant turn must arrive in a SINGLE
+      //      user message — OpenAI sends parallel tool results as consecutive
+      //      role:"tool" messages, which must merge, not split.
+      const lastAssistant = anthropicMessages.findLast?.(m => m.role === "assistant")
+        ?? [...anthropicMessages].reverse().find(m => m.role === "assistant");
+      const hasMatchingToolUse = Array.isArray(lastAssistant?.content) &&
+        lastAssistant.content.some(b => b?.type === "tool_use" && b.id === msg.tool_call_id);
+
+      if (!hasMatchingToolUse) {
+        // Orphaned result (history truncated or ids rewritten by the client):
+        // degrade to plain text so the request survives instead of 400ing.
+        logger.warn({ toolCallId: msg.tool_call_id }, "Orphaned tool result — no matching tool_use in prior assistant message; converting to text");
+        const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        anthropicMessages.push({
+          role: "user",
+          content: [{ type: "text", text: `[Tool result ${msg.tool_call_id}]: ${text}` }]
+        });
+        continue;
+      }
+
+      const resultBlock = {
+        type: "tool_result",
+        tool_use_id: msg.tool_call_id,
+        content: msg.content
+      };
+
+      const prev = anthropicMessages[anthropicMessages.length - 1];
+      const prevIsToolResultCarrier = prev?.role === "user" &&
+        Array.isArray(prev.content) &&
+        prev.content.length > 0 &&
+        prev.content.every(b => b?.type === "tool_result");
+
+      if (prevIsToolResultCarrier) {
+        prev.content.push(resultBlock);
+      } else {
+        anthropicMessages.push({ role: "user", content: [resultBlock] });
+      }
     }
   }
 
@@ -261,7 +288,10 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
 
   // Build OpenAI response
   // Ensure ID has the chatcmpl- prefix that OpenAI clients expect
-  const responseId = id && id.startsWith("chatcmpl-") ? id : `chatcmpl-${Date.now()}`;
+  // Preserve the upstream id whatever its prefix (msg_… from Anthropic-shaped
+  // providers) — clients don't validate the prefix and a stable id keeps
+  // request tracing intact across the format conversion.
+  const responseId = id || `chatcmpl-${Date.now()}`;
   const openaiResponse = {
     id: responseId,
     object: "chat.completion",
@@ -277,11 +307,23 @@ function convertAnthropicToOpenAI(anthropicResponse, model = "claude-3-5-sonnet-
         finish_reason: mapStopReason(stop_reason)
       }
     ],
-    usage: {
-      prompt_tokens: usage?.input_tokens || 0,
-      completion_tokens: usage?.output_tokens || 0,
-      total_tokens: (usage?.input_tokens || 0) + (usage?.output_tokens || 0)
-    }
+    // OpenAI semantics: prompt_tokens INCLUDES cached tokens (Anthropic's
+    // input_tokens excludes cache reads/writes). Dropping cache tokens made
+    // clients like opencode undercount context — with prompt caching on,
+    // most of a turn's input is cache-read (issue: sidebar token drift).
+    usage: (() => {
+      const cacheRead = usage?.cache_read_input_tokens || 0;
+      const cacheWrite = usage?.cache_creation_input_tokens || 0;
+      const promptTokens = (usage?.input_tokens || 0) + cacheRead + cacheWrite;
+      const completionTokens = usage?.output_tokens || 0;
+      const u = {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens
+      };
+      if (cacheRead > 0) u.prompt_tokens_details = { cached_tokens: cacheRead };
+      return u;
+    })()
   };
 
   // Add citations if present
@@ -427,10 +469,18 @@ function convertAnthropicStreamChunkToOpenAI(chunk, model = "claude-3-5-sonnet-2
           finish_reason: mapStopReason(stopReason)
         }
       ],
+      // Anthropic's message_delta usage carries output_tokens and (on newer
+      // API versions) cumulative input_tokens — forward whatever is present
+      // instead of hardcoding prompt_tokens: 0.
       usage: usage ? {
-        prompt_tokens: 0, // Not available in streaming
+        prompt_tokens: (usage.input_tokens || 0) +
+          (usage.cache_read_input_tokens || 0) +
+          (usage.cache_creation_input_tokens || 0),
         completion_tokens: usage.output_tokens || 0,
-        total_tokens: usage.output_tokens || 0
+        total_tokens: (usage.input_tokens || 0) +
+          (usage.cache_read_input_tokens || 0) +
+          (usage.cache_creation_input_tokens || 0) +
+          (usage.output_tokens || 0)
       } : undefined
     };
   } else if (eventType === "message_stop") {

package/src/clients/provider-capabilities.js

@@ -1,5 +1,3 @@
-const config = require("../config");
-
 const NATIVE_THINKING_PROVIDERS = new Set(["azure-anthropic", "databricks"]);
 
 const NATIVE_THINKING_BEDROCK_MODELS = [
@@ -34,8 +32,35 @@ function getThinkingBehavior(providerType, model) {
   return "none";
 }
 
+/**
+ * Anthropic-shaped `thinking` request param to send upstream, honoring an
+ * explicit client request and otherwise defaulting to disabled.
+ *
+ * Confirmed live (2026-08-27) against both endpoints directly: Baidu
+ * Qianfan's `glm-5.2` and Moonshot's Kimi (`kimi-k3`) both emit verbose
+ * `reasoning_content` on EVERY call by default, sharing the same token
+ * budget as the visible answer — with no instruction at all, a baseline
+ * call to either returned ~500-600 chars of reasoning_content, an EMPTY
+ * `content`, and `finish_reason:"length"` (the whole max_tokens budget
+ * spent on reasoning, none left for the actual answer). The GLM/Qwen
+ * convention `enable_thinking:false` does NOT suppress this on either
+ * endpoint — only this Anthropic-shaped `{type:"disabled"}` param does
+ * (also confirmed live, on both). Not a caveman-specific issue — the same
+ * budget waste happens on every request to these two providers; caveman's
+ * elaborate constraint set just makes it worse, since the model has more to
+ * visibly deliberate against.
+ *
+ * @param {Object} body - incoming Anthropic-format request body
+ * @returns {Object} the `thinking` param to send upstream
+ */
+function resolveThinkingParam(body) {
+  if (body?.thinking && typeof body.thinking === "object") return body.thinking;
+  return { type: "disabled" };
+}
+
 module.exports = {
   supportsNativeThinking,
   supportsReasoningContent,
   getThinkingBehavior,
+  resolveThinkingParam,
 };

package/src/clients/resilience.js

@@ -195,7 +195,6 @@ class CockatielCircuitBreaker {
     this._lastStateChange = Date.now();
 
     // Recreate the policy to reset state
-    const oldPolicy = this._policy;
     this._policy = circuitBreaker(handleAll, {
       breaker: new ConsecutiveBreaker(this.failureThreshold),
       halfOpenAfter: this.halfOpenAfter,

package/src/clients/responses-format.js

@@ -10,61 +10,6 @@
 const logger = require("../logger");
 const { repairToolCallIds } = require("./tool-call-repair");
 
-/**
- * Map client tool names back to Lynkr tool names
- * Used when processing incoming function_call messages from various AI coding clients
- * Supports: Codex CLI, Cline (VS Code), Continue.dev
- * @param {string} clientToolName - Client tool name (e.g., shell_command, execute_command, read_file)
- * @returns {string} Lynkr tool name (e.g., Bash, Read)
- */
-function mapClientToolToLynkr(clientToolName) {
-  const reverseMapping = {
-    // ============== CODEX CLI ==============
-    "shell": "Bash",
-    "shell_command": "Bash",
-    "read_file": "Read",
-    "write_file": "Write",
-    "apply_patch": "Edit",
-    "glob_file_search": "Glob",
-    "rg": "Grep",
-    "list_dir": "ListDir",
-
-    // ============== CLINE (VS Code) ==============
-    "execute_command": "Bash",
-    // "read_file" already mapped above
-    "write_to_file": "Write",
-    "replace_in_file": "Edit",
-    "search_files": "Grep",
-    "list_files": "ListDir",
-
-    // ============== KILO CODE (Fork of Cline) ==============
-    // Most tools same as Cline, but apply_diff is different
-    "apply_diff": "Edit",
-    "codebase_search": "Grep",
-    "delete_file": "Bash",  // No direct equivalent, use Bash rm
-    "browser_action": "WebFetch",  // Approximate mapping
-
-    // ============== CONTINUE.DEV ==============
-    "run_terminal_command": "Bash",
-    // "read_file" already mapped above
-    "create_new_file": "Write",
-    "edit_existing_file": "Edit",
-    "exact_search": "Grep",
-    "read_currently_open_file": "Read",
-
-    // ============== Lowercase Lynkr tools (pass-through) ==============
-    "bash": "Bash",
-    "read": "Read",
-    "write": "Write",
-    "edit": "Edit",
-    "glob": "Glob",
-    "grep": "Grep",
-    "listdir": "ListDir"
-  };
-
-  return reverseMapping[clientToolName] || clientToolName;
-}
-
 /**
  * Convert Responses API request to Chat Completions format
  * @param {Object} responsesRequest - Responses API format request
@@ -189,7 +134,6 @@ function convertResponsesToChat(responsesRequest) {
             }, "Converted multimodal content array to string");
           } else {
             // No text found, keep as array (might be image-only)
-            content = content;
           }
         }
 

package/src/clients/routing.js

@@ -15,7 +15,7 @@ const config = require('../config');
 
 // Synchronous version for benchmarking/tests
 // (when tiers are disabled, routing is purely static)
-function determineProviderSync(payload) {
+function determineProviderSync(_payload) {
   const primaryProvider = config.modelProvider?.type || 'databricks';
   const defaultModel = config.modelProvider?.defaultModel || 'databricks-claude-sonnet-4-5';
 

package/src/config/index.js

@@ -62,7 +62,7 @@ function resolveConfigPath(targetPath) {
   return path.resolve(normalised);
 }
 
-const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "edenai", "azure-openai", "openai", "atlas", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot", "baidu"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "edenai", "azure-openai", "openai", "atlas", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot", "baidu", "fireworks"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 
 // Validate MODEL_PROVIDER early with a clear error message
@@ -153,6 +153,11 @@ const baiduApiKey = process.env.BAIDU_API_KEY?.trim() || null;
 const baiduEndpoint = process.env.BAIDU_ENDPOINT?.trim() || "https://qianfan.baidubce.com/v2/chat/completions";
 const baiduModel = process.env.BAIDU_MODEL?.trim() || "ernie-4.5-turbo-128k";
 
+// Fireworks AI configuration - OpenAI-compatible serverless inference API
+const fireworksApiKey = process.env.FIREWORKS_API_KEY?.trim() || null;
+const fireworksEndpoint = process.env.FIREWORKS_ENDPOINT?.trim() || "https://api.fireworks.ai/inference/v1/chat/completions";
+const fireworksModel = process.env.FIREWORKS_MODEL?.trim() || "accounts/fireworks/models/kimi-k2-instruct-0905";
+
 // Vertex AI (Google Gemini) configuration
 const vertexApiKey = process.env.VERTEX_API_KEY?.trim() || process.env.GOOGLE_API_KEY?.trim() || null;
 const vertexModel = process.env.VERTEX_MODEL?.trim() || "gemini-2.0-flash";
@@ -545,7 +550,6 @@ const agentsEnabled = process.env.AGENTS_ENABLED === "true";
 // LLM Audit logging configuration
 const auditEnabled = process.env.LLM_AUDIT_ENABLED === "true"; // default false
 const auditLogFile = process.env.LLM_AUDIT_LOG_FILE ?? path.join(process.cwd(), "logs", "llm-audit.log");
-const auditMaxContentLength = Number.parseInt(process.env.LLM_AUDIT_MAX_CONTENT_LENGTH ?? "5000", 10); // Legacy fallback
 const auditMaxSystemLength = Number.parseInt(process.env.LLM_AUDIT_MAX_SYSTEM_LENGTH ?? "2000", 10);
 const auditMaxUserLength = Number.parseInt(process.env.LLM_AUDIT_MAX_USER_LENGTH ?? "3000", 10);
 const auditMaxResponseLength = Number.parseInt(process.env.LLM_AUDIT_MAX_RESPONSE_LENGTH ?? "3000", 10);
@@ -663,6 +667,11 @@ var config = {
     endpoint: baiduEndpoint,
     model: baiduModel,
   },
+  fireworks: {
+    apiKey: fireworksApiKey,
+    endpoint: fireworksEndpoint,
+    model: fireworksModel,
+  },
   codex: {
     enabled: process.env.CODEX_ENABLED !== "false",
     binaryPath: process.env.CODEX_BINARY_PATH?.trim() || null,
@@ -1126,6 +1135,8 @@ function reloadConfig() {
   config.moonshot.model = process.env.MOONSHOT_MODEL?.trim() || "kimi-k2-turbo-preview";
   config.baidu.apiKey = process.env.BAIDU_API_KEY?.trim() || null;
   config.baidu.model = process.env.BAIDU_MODEL?.trim() || "ernie-4.5-turbo-128k";
+  config.fireworks.apiKey = process.env.FIREWORKS_API_KEY?.trim() || null;
+  config.fireworks.model = process.env.FIREWORKS_MODEL?.trim() || "accounts/fireworks/models/kimi-k2-instruct-0905";
 
   // Model provider settings
   const newProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();

package/src/context/budget.js

@@ -223,7 +223,7 @@ function finalizeBudgetEnforcement(original, optimized, strategy, initialCheck,
 /**
  * Compress system prompt aggressively for budget enforcement
  */
-function compressSystemPromptAggressively(systemPromptContent, payload) {
+function compressSystemPromptAggressively(systemPromptContent, _payload) {
   let text = typeof systemPromptContent === 'string'
     ? systemPromptContent
     : systemPrompt.flattenBlocks(systemPromptContent);