lynkr 9.12.0 → 9.14.0

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", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot"]);
+const SUPPORTED_MODEL_PROVIDERS = new Set(["databricks", "azure-anthropic", "ollama", "openrouter", "edenai", "azure-openai", "openai", "atlas", "llamacpp", "lmstudio", "bedrock", "zai", "vertex", "moonshot", "baidu"]);
 const rawModelProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();
 
 // Validate MODEL_PROVIDER early with a clear error message
@@ -115,6 +115,11 @@ const openAIModel = process.env.OPENAI_MODEL?.trim() || "gpt-4o";
 const openAIEndpoint = process.env.OPENAI_ENDPOINT?.trim() || "https://api.openai.com/v1/chat/completions";
 const openAIOrganization = process.env.OPENAI_ORGANIZATION?.trim() || null;
 
+// Atlas Cloud configuration (OpenAI-compatible Chat Completions)
+const atlasCloudApiKey = process.env.ATLASCLOUD_API_KEY?.trim() || null;
+const atlasCloudModel = process.env.ATLASCLOUD_MODEL?.trim() || "qwen/qwen3.8-max";
+const atlasCloudEndpoint = process.env.ATLASCLOUD_ENDPOINT?.trim() || "https://api.atlascloud.ai/v1/chat/completions";
+
 // llama.cpp configuration
 const llamacppEndpoint = process.env.LLAMACPP_ENDPOINT?.trim() || "http://localhost:8080";
 const llamacppModel = process.env.LLAMACPP_MODEL?.trim() || "default";
@@ -143,6 +148,11 @@ const moonshotApiKey = process.env.MOONSHOT_API_KEY?.trim() || null;
 const moonshotEndpoint = process.env.MOONSHOT_ENDPOINT?.trim() || "https://api.moonshot.ai/v1/chat/completions";
 const moonshotModel = process.env.MOONSHOT_MODEL?.trim() || "kimi-k2-turbo-preview";
 
+// Baidu Qianfan (ERNIE) configuration - OpenAI-compatible v2 Chat Completions API
+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";
+
 // 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";
@@ -292,6 +302,12 @@ if (modelProvider === "openai" && !openAIApiKey) {
   );
 }
 
+if (modelProvider === "atlas" && !atlasCloudApiKey) {
+  throw new Error(
+    "Set ATLASCLOUD_API_KEY before starting the proxy.",
+  );
+}
+
 if (modelProvider === "ollama") {
   try {
     new URL(ollamaEndpoint);
@@ -340,7 +356,7 @@ const tiersConfigured = !!(
 if (fallbackEnabled && tiersConfigured) {
   const localProviders = ["ollama", "llamacpp", "lmstudio"];
   if (localProviders.includes(fallbackProvider)) {
-    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, edenai, openai, bedrock`);
+    throw new Error(`FALLBACK_PROVIDER cannot be '${fallbackProvider}' (local providers should not be fallbacks). Use cloud providers: databricks, azure-anthropic, azure-openai, openrouter, edenai, openai, atlas, bedrock`);
   }
   let fallbackMisconfigured = false;
   if (fallbackProvider === "databricks" && (!rawBaseUrl || !apiKey)) {
@@ -355,6 +371,9 @@ if (fallbackEnabled && tiersConfigured) {
   if (fallbackProvider === "bedrock" && !bedrockApiKey) {
     fallbackMisconfigured = true;
   }
+  if (fallbackProvider === "atlas" && !atlasCloudApiKey) {
+    fallbackMisconfigured = true;
+  }
   if (fallbackMisconfigured) {
     console.warn(`[WARN] FALLBACK_PROVIDER='${fallbackProvider}' is enabled but missing credentials. Fallback will not work until configured.`);
   }
@@ -602,6 +621,11 @@ var config = {
     endpoint: openAIEndpoint,
     organization: openAIOrganization,
   },
+  atlas: {
+    apiKey: atlasCloudApiKey,
+    model: atlasCloudModel,
+    endpoint: atlasCloudEndpoint,
+  },
   llamacpp: {
     endpoint: llamacppEndpoint,
     model: llamacppModel,
@@ -634,6 +658,11 @@ var config = {
     endpoint: moonshotEndpoint,
     model: moonshotModel,
   },
+  baidu: {
+    apiKey: baiduApiKey,
+    endpoint: baiduEndpoint,
+    model: baiduModel,
+  },
   codex: {
     enabled: process.env.CODEX_ENABLED !== "false",
     binaryPath: process.env.CODEX_BINARY_PATH?.trim() || null,
@@ -654,7 +683,7 @@ var config = {
     fallbackProvider,
   },
   toolResultCompression: {
-    enabled: true,
+    enabled: process.env.TOOL_RESULT_COMPRESSION_ENABLED !== "false",
   },
   caveman: {
     enabled: cavemanEnabled,
@@ -1085,6 +1114,9 @@ function reloadConfig() {
   config.edenai.model = process.env.EDENAI_MODEL ?? "openai/gpt-4o-mini";
   config.azureOpenAI.apiKey = process.env.AZURE_OPENAI_API_KEY?.trim() || null;
   config.openai.apiKey = process.env.OPENAI_API_KEY?.trim() || null;
+  config.atlas.apiKey = process.env.ATLASCLOUD_API_KEY?.trim() || null;
+  config.atlas.model = process.env.ATLASCLOUD_MODEL?.trim() || "qwen/qwen3.8-max";
+  config.atlas.endpoint = process.env.ATLASCLOUD_ENDPOINT?.trim() || "https://api.atlascloud.ai/v1/chat/completions";
   config.bedrock.apiKey = process.env.AWS_BEDROCK_API_KEY?.trim() || null;
   config.zai.apiKey = process.env.ZAI_API_KEY?.trim() || null;
   config.zai.model = process.env.ZAI_MODEL?.trim() || "GLM-4.7";
@@ -1092,6 +1124,8 @@ function reloadConfig() {
   config.vertex.model = process.env.VERTEX_MODEL?.trim() || "gemini-2.0-flash";
   config.moonshot.apiKey = process.env.MOONSHOT_API_KEY?.trim() || null;
   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";
 
   // Model provider settings
   const newProvider = (process.env.MODEL_PROVIDER ?? "databricks").toLowerCase();

package/src/context/tool-result-compressor.js

@@ -9,20 +9,23 @@
  */
 
 const logger = require("../logger");
+const crypto = require("crypto");
 
 // ── Tee Recovery Cache ───────────────────────────────────────────────
 
 const teeCache = new Map();
 const TEE_MAX_SIZE = 200;
 const TEE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-let teeCounter = 0;
 
 function teeStore(original) {
-  if (teeCache.size >= TEE_MAX_SIZE) {
+  // Content-derived id: the same tool result must compress to byte-identical
+  // output on every turn, or the tee marker breaks provider prompt-cache
+  // prefixes. (Was Date.now()+counter — new bytes in old messages each turn.)
+  const id = "tee_" + crypto.createHash("sha1").update(original).digest("hex").slice(0, 16);
+  if (!teeCache.has(id) && teeCache.size >= TEE_MAX_SIZE) {
     const oldest = teeCache.keys().next().value;
     teeCache.delete(oldest);
   }
-  const id = `tee_${Date.now()}_${teeCounter++}`;
   teeCache.set(id, { content: original, createdAt: Date.now() });
   return id;
 }

package/src/orchestrator/index.js

@@ -43,7 +43,9 @@ function getDestinationUrl(providerType) {
     case 'edenai':
       return config.edenai?.endpoint ?? 'unknown';
     case 'openai':
-      return 'https://api.openai.com/v1/chat/completions';
+      return config.openai?.endpoint ?? 'https://api.openai.com/v1/chat/completions';
+    case 'atlas':
+      return config.atlas?.endpoint ?? 'https://api.atlascloud.ai/v1/chat/completions';
     case 'llamacpp':
       return config.llamacpp?.endpoint ?? 'unknown';
     case 'lmstudio':
@@ -56,6 +58,8 @@ function getDestinationUrl(providerType) {
       return config.vertex?.endpoint ?? 'unknown';
     case 'moonshot':
       return config.moonshot?.endpoint ?? 'unknown';
+    case 'baidu':
+      return config.baidu?.endpoint ?? 'unknown';
     case 'codex':
       return 'codex://app-server (local process)';
     default:
@@ -1145,8 +1149,16 @@ function sanitizePayload(payload) {
     } else {
       clean.tools = ensureAnthropicToolFormat(clean.tools);
     }
-  } else if (providerType === "azure-openai" || providerType === "openai") {
-    // Azure OpenAI / OpenAI support tools — keep Anthropic format; the
+  } else if (providerType === "baidu") {
+    // Baidu Qianfan supports tools - keep them in Anthropic format
+    // They will be converted to OpenAI format in invokeBaidu
+    if (!Array.isArray(clean.tools) || clean.tools.length === 0) {
+      delete clean.tools;
+    } else {
+      clean.tools = ensureAnthropicToolFormat(clean.tools);
+    }
+  } else if (providerType === "azure-openai" || providerType === "openai" || providerType === "atlas") {
+    // Azure OpenAI / OpenAI-compatible providers support tools — keep Anthropic format; the
     // client converts to Chat Completions / Responses format. Without this
     // branch the unknown-provider catch-all below deletes the tools.
     if (!Array.isArray(clean.tools) || clean.tools.length === 0) {
@@ -1344,6 +1356,18 @@ function buildNonJsonResponse(databricksResponse) {
   };
 }
 
+/**
+ * Visible routing badge for live-streamed responses, built from the actual
+ * post-routing decision (tier fallbacks included). Matches the format of
+ * openai-router's lynkrBadge and the Anthropic router's intent badge so
+ * LYNKR_BADGE_PREFIX_RE strips all three identically from replayed history.
+ */
+function buildRoutingBadge(rd) {
+  if (!rd || !rd.tier) return null;
+  const score = typeof rd.score === "number" ? ` · score ${rd.score}` : "";
+  return `*[Lynkr] ${rd.tier} → ${rd.model || "—"} (${rd.provider || "—"})${score}*\n\n`;
+}
+
 function buildStreamingResponse(databricksResponse) {
   return {
     status: databricksResponse.status,
@@ -1743,7 +1767,24 @@ IMPORTANT TOOL USAGE RULES:
   };
   const headroomProvider = process.env.HEADROOM_PROVIDER || 'anthropic';
   const headroomSafeProviders = headroomProviderMap[headroomProvider] || new Set();
-  const headroomCompatible = headroomSafeProviders.has(providerType);
+  // Under tier routing the static providerType is just the MODEL_PROVIDER
+  // default (usually "databricks") — the real provider is chosen per-request
+  // later in invokeModel, AFTER this compression point, so gating on it
+  // silently disabled Headroom for every tier-routed setup. Gate on the
+  // configured tier fleet instead: compress only when every routable tier
+  // provider is format-safe, since any request may land on any tier.
+  let headroomCompatible = headroomSafeProviders.has(providerType);
+  if (!headroomCompatible) {
+    try {
+      const { getModelTierSelector } = require('../routing/model-tiers');
+      const sel = getModelTierSelector();
+      const tierProviders = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING']
+        .map((t) => { try { return sel.selectModel(t)?.provider; } catch { return null; } })
+        .filter(Boolean)
+        .map((p) => (p === 'z-ai' ? 'zai' : p));
+      headroomCompatible = tierProviders.length > 0 && tierProviders.every((p) => headroomSafeProviders.has(p));
+    } catch { /* tier routing not configured — keep the static gate result */ }
+  }
 
   if (isHeadroomEnabled() && headroomCompatible && cleanPayload.messages && cleanPayload.messages.length > 0) {
     try {
@@ -1839,8 +1880,13 @@ IMPORTANT TOOL USAGE RULES:
   // before they reach the model (saves 60-90% on test/git/lint output)
   if (config.toolResultCompression?.enabled !== false) {
     const { compressToolResults } = require("../context/tool-result-compressor");
-    const tier = cleanPayload._routingTier || "MEDIUM";
-    compressToolResults(cleanPayload.messages, { tier });
+    // Fixed threshold: compression must be deterministic per message — the
+    // routed tier flaps between turns, and re-compressing history differently
+    // breaks provider prompt-cache prefixes. COMPLEX (>2000 chars) compresses
+    // only bulky outputs: with prompt caching live, resending history is
+    // cheap, so lighter lossiness beats aggressive compression; still bounds
+    // context growth enough to stay clear of the token-budget compressor.
+    compressToolResults(cleanPayload.messages, { tier: "COMPLEX" });
   }
 
   // MCP-aware tool dedup: drop built-in tools superseded by present MCP tools
@@ -2036,7 +2082,16 @@ IMPORTANT TOOL USAGE RULES:
         const routingDecision = databricksResponse.routingDecision || {};
         const transformed = sseTransform.openaiToAnthropicSSE(databricksResponse.stream, {
           model: requestedModel,
-          badgeText: config.routing?.visibleInteraction ? options?.streamBadgeText || null : null,
+          // Badge precedence: an explicit streamBadgeText (Anthropic router's
+          // pre-computed intent badge) wins; otherwise build one from the
+          // ACTUAL post-routing decision so OpenAI-surface live streams
+          // (opencode et al.) show which model served the response —
+          // previously this path silently dropped the badge entirely.
+          // History pollution is covered: stripLynkrBadges in invokeModel
+          // removes resubmitted badges before anything reaches a provider.
+          badgeText: config.routing?.visibleInteraction
+            ? (options?.streamBadgeText || buildRoutingBadge(routingDecision))
+            : null,
           onClose: (stats) => {
             try {
               const telemetry = require("../routing/telemetry");
@@ -2063,6 +2118,7 @@ IMPORTANT TOOL USAGE RULES:
               logger.info({
                 provider: routingDecision.provider || _streamProvider,
                 stopReason: stats.stopReason,
+                finishReason: stats.finishReason ?? null,
                 toolCalls: stats.toolCalls.map((t) => t.name),
                 outputTokens: stats.usage.output_tokens,
               }, "[SSETransform] Stream closed");
@@ -2606,6 +2662,12 @@ IMPORTANT TOOL USAGE RULES:
       if (Array.isArray(anthropicPayload?.content)) {
         anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);
       }
+    } else if (actualProvider === "baidu") {
+      // Baidu Qianfan responses are already converted to Anthropic format in invokeBaidu
+      anthropicPayload = databricksResponse.json;
+      if (Array.isArray(anthropicPayload?.content)) {
+        anthropicPayload.content = policy.sanitiseContent(anthropicPayload.content);
+      }
     } else if (actualProvider === "codex") {
       // Codex responses are already in Anthropic format from invokeCodex
       anthropicPayload = databricksResponse.json;
@@ -3168,4 +3230,6 @@ module.exports = {
   toAnthropicResponse,
   // Exported for unit testing of loop trimming (task-preservation contract).
   trimLoopMessages,
+  // Exported for unit testing of the live-stream routing badge.
+  buildRoutingBadge,
 };

package/src/orchestrator/sse-transformer.js

@@ -30,6 +30,7 @@ const logger = require("../logger");
 // responses; the buffered path still lifts it into thinking blocks.
 const DEFAULT_OPENAI_SSE_PROVIDERS = [
   "openai",
+  "atlas",
   "azure-openai",
   "openrouter",
   "databricks",
@@ -255,6 +256,7 @@ async function* _openaiToAnthropicEvents(upstream, opts = {}) {
       error: { type: "overloaded_error", message: `Lynkr: upstream stream failed — retry (${err.message})` },
     });
     stats.stopReason = "stream_error";
+    stats.finishReason = finishReason ?? null;
     if (opts.onClose) { try { opts.onClose(stats); } catch { /* non-fatal */ } }
     return;
   }
@@ -262,10 +264,36 @@ async function* _openaiToAnthropicEvents(upstream, opts = {}) {
   // Normal end of stream ([DONE] or upstream EOF).
   yield* startMessage();
   yield* closeTextBlock();
+
+  // An EOF with no finish_reason is a dropped upstream, not a completed
+  // turn. Mapping it to end_turn hands the client a success-shaped stop —
+  // agent loops halt mid-task believing the model chose to stop (live
+  // incident 2026-08-19: opencode stalled between tool calls; the stream
+  // closed as end_turn with null output tokens). Spec-compliant upstreams
+  // always send finish_reason on the last choice chunk, so signal an error
+  // and let the client retry, mirroring the mid-flight failure path above.
+  // Accumulated tool fragments are NOT flushed: without finish_reason their
+  // argument JSON may be truncated mid-string.
+  if (!finishReason) {
+    logger.warn(
+      { droppedToolFragments: toolAcc.size, outputTokens: stats.usage.output_tokens },
+      "[SSETransform] Upstream ended without finish_reason — signaling stream error"
+    );
+    yield _sse("error", {
+      type: "error",
+      error: { type: "overloaded_error", message: "Lynkr: upstream ended without finish_reason — retry" },
+    });
+    stats.stopReason = "stream_error";
+    stats.finishReason = null;
+    if (opts.onClose) { try { opts.onClose(stats); } catch { /* non-fatal */ } }
+    return;
+  }
+
   yield* flushToolBlocks();
 
   const stopReason = _mapFinishReason(finishReason);
   stats.stopReason = stopReason;
+  stats.finishReason = finishReason;
   yield _sse("message_delta", {
     type: "message_delta",
     delta: { stop_reason: stopReason, stop_sequence: null },

package/src/routing/index.js

@@ -84,6 +84,7 @@ function _enabledProviders() {
   if (config.openrouter?.apiKey) out.push('openrouter');
   if (config.edenai?.apiKey) out.push('edenai');
   if (config.openai?.apiKey) out.push('openai');
+  if (config.atlas?.apiKey) out.push('atlas');
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) out.push('azure-openai');
   if (config.ollama?.endpoint) out.push('ollama');
   if (config.llamacpp?.endpoint) out.push('llamacpp');
@@ -126,6 +127,7 @@ function getBestCloudProvider() {
   if (config.openrouter?.apiKey) return 'openrouter';
   if (config.edenai?.apiKey) return 'edenai';
   if (config.openai?.apiKey) return 'openai';
+  if (config.atlas?.apiKey) return 'atlas';
   if (config.azureOpenAI?.endpoint && config.azureOpenAI?.apiKey) return 'azure-openai';
 
   return getFallbackProvider();

package/src/routing/intent-score.js

@@ -366,6 +366,14 @@ function _reconcile(anchorScore, anchorClass, classifierResult) {
   return { score: anchorScore, reconciled: 'up_gated' };
 }
 
+// Memoize the final reconciled score per cleaned text. The classifier leg is
+// live and can time out under load, sending identical text down different
+// fallback paths — which made the same turn score differently between the
+// router and the pin-drift checker (observed: 63 vs 77 for one prompt under
+// suite-wide Ollama contention). First resolution wins for the process life.
+const _scoreMemo = new Map();
+const _SCORE_MEMO_MAX = 500;
+
 async function scoreIntent(payload, opts = {}) {
   const mode = opts.mode ?? intentScoreMode();
   if (mode === 'legacy') return null;
@@ -373,6 +381,21 @@ async function scoreIntent(payload, opts = {}) {
   const text = extractCleanUserText(payload);
   if (!text) return null;
 
+  // Only memoize plain calls — opts that alter scoring (custom centroids,
+  // embedFn, risk/context inputs) must not share cache entries.
+  const memoizable = !opts.centroids && !opts.embedFn && !opts.forceMatched
+    && !opts.riskLevel && !opts.skipClassifier && !opts.priorTurns;
+  if (memoizable && _scoreMemo.has(text)) return _scoreMemo.get(text);
+  const _memoSet = (result) => {
+    if (memoizable && result) {
+      if (_scoreMemo.size >= _SCORE_MEMO_MAX) {
+        _scoreMemo.delete(_scoreMemo.keys().next().value);
+      }
+      _scoreMemo.set(text, result);
+    }
+    return result;
+  };
+
   try {
     const centroids = opts.centroids !== undefined ? opts.centroids : await getDefaultCentroids();
     if (centroids) {
@@ -421,7 +444,7 @@ async function scoreIntent(payload, opts = {}) {
             finalScore: score,
           }, '[IntentScore] classifier reconciled anchor score');
         }
-        return {
+        return _memoSet({
           score,
           mode: reconciled ? 'anchor+classifier' : 'anchor',
           class: cls,
@@ -431,13 +454,15 @@ async function scoreIntent(payload, opts = {}) {
           classifierTier: classifierResult?.tier ?? null,
           classifierConfidence: classifierResult?.confidence ?? null,
           reconciled,
-        };
+        });
       }
     }
   } catch (err) {
     logger.debug({ err: err.message }, '[IntentScore] anchor scoring failed — lexical fallback');
   }
 
+  // Lexical fallback is NOT memoized: it usually means the embedding service
+  // was unavailable; pinning it would lock in degraded scores after recovery.
   return { score: _lexicalCleanScore(text), mode: 'lexical', text };
 }
 

package/src/routing/model-tiers.js

@@ -333,6 +333,8 @@ class ModelTierSelector {
         return config.azureOpenAI?.deployment || null;
       case 'openai':
         return config.openai?.model || null;
+      case 'atlas':
+        return config.atlas?.model || null;
       case 'ollama':
         return config.ollama?.model || null;
       case 'openrouter':
@@ -349,6 +351,8 @@ class ModelTierSelector {
         return config.zai?.model || null;
       case 'moonshot':
         return config.moonshot?.model || null;
+      case 'baidu':
+        return config.baidu?.model || null;
       case 'codex':
         return config.codex?.model || null;
       case 'vertex':