lynkr 9.12.0 → 9.13.0

package/README.md

@@ -15,7 +15,7 @@
 <td align="center"><strong>84%</strong><br/>JSON Compression</td>
 <td align="center"><strong>53%</strong><br/>Tool Token Reduction</td>
 <td align="center"><strong>&lt;300ms</strong><br/>Semantic Cache Hits</td>
-<td align="center"><strong>13+</strong><br/>LLM Providers</td>
+<td align="center"><strong>14+</strong><br/>LLM Providers</td>
 <td align="center"><strong>0</strong><br/>Code Changes Required</td>
 </tr>
 </table>
@@ -28,26 +28,25 @@
 
 ## 🚀 New: Wrap Mode for AI Coding Tools
 
-**Use Lynkr's routing with your AI coding assistant — BYO API keys, route by task complexity:**
+**Use Lynkr's routing with your AI coding assistant — maximize your subscription value:**
 
 ```bash
 npm install -g lynkr
 
 
-# Claude Code (with your own ANTHROPIC_API_KEY)
+# Claude Code Pro/Max
 lynkr wrap claude
 
 
 ```
 
 **Wrapping gives you:**
-- ✅ Tier routing (send simple tasks to free Ollama, complex to your configured API provider)
+- ✅ Tier routing (send simple tasks to free Ollama, complex to your subscription/API)
 - ✅ Sticky sessions: one routing decision per conversation via content fingerprinting, with automatic escalation when the task outgrows the model
 - ✅ TOON/RTK compression (84% token reduction on large JSON tool outputs)
 - ✅ Semantic caching (sub-300ms cache hits, 0 tokens billed)
-- ✅ Works with API keys (Claude, Aider, Codex, Copilot, Cursor)
-
-> **Note on subscription (OAuth) logins:** Anthropic's Feb 2026 usage policy prohibits third-party tools from using OAuth tokens issued to Free/Pro/Max accounts. Wrap mode's tier routing, compression, and caching require an API key — they do not apply to and are not compatible with Claude Pro/Max subscription auth. See [ToS Compliance](docs/wrap-guide.md#tos-compliance) for details.
+- ✅ **3-5x more usage from the same subscription limits**
+- ✅ Works with OAuth (Claude, Copilot, Cursor) or API keys (Aider, Codex)
 
 [Full wrap guide →](docs/wrap-guide.md)
 
@@ -69,7 +68,7 @@ The fastest path is the interactive wizard:
 lynkr init
 ```
 
-It asks four questions — usage mode (BYO API keys, direct), tier picks for SIMPLE/MEDIUM/COMPLEX/REASONING across the 12 supported providers, credentials for what you chose, and a few routing-intelligence knobs — then writes a fully-populated `.env` with sensible production defaults for everything else (caching, compression, policy budgets, MCP sandbox, rate limiting).
+It asks four questions — usage mode (Claude Pro/Max via wrap, or direct API keys), tier picks for SIMPLE/MEDIUM/COMPLEX/REASONING across the 14 supported providers, credentials for what you chose, and a few routing-intelligence knobs — then writes a fully-populated `.env` with sensible production defaults for everything else (caching, compression, policy budgets, MCP sandbox, rate limiting).
 
 Useful flags:
 
@@ -217,9 +216,24 @@ Claude Code / Cursor / Codex / Cline / Continue
 | **Azure OpenAI** | Cloud | GPT-4o, o1, o3 | $$$ |
 | **Azure Anthropic** | Cloud | Claude Sonnet, Opus | $$$ |
 | **OpenAI** | Cloud | GPT-4o, o3-mini | $$$ |
+| **Atlas Cloud** | Cloud | Qwen, DeepSeek, and other OpenAI-compatible models | $-$$$ |
 | **DeepSeek** | Cloud | DeepSeek R1, Reasoner | $ |
-
-**4 local providers** for 100% offline, free usage. **10+ cloud providers** for scale.
+| **Z.ai** | Cloud | GLM-4.7, GLM-4.5-Air | $ |
+| **Moonshot AI** | Cloud | Kimi K2.6, Kimi K3 | $ |
+| **Baidu Qianfan** | Cloud | ERNIE 4.5 Turbo, ERNIE X1.1 | $ (unverified — not yet probed against a live key) |
+
+**4 local providers** for 100% offline, free usage. **14+ cloud providers** for scale.
+
+<div align="center">
+  <a href="https://www.atlascloud.ai/?utm_source=github&amp;utm_medium=readme&amp;utm_campaign=lynkr">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://www.atlascloud.ai/logo-white.svg">
+      <img src="https://www.atlascloud.ai/logo.svg" alt="Atlas Cloud" width="196">
+    </picture>
+  </a>
+  <br>
+  <sub>Use Lynkr with Atlas Cloud's OpenAI-compatible API and route across its live model catalog with one optional provider configuration. <a href="https://www.atlascloud.ai/?utm_source=github&amp;utm_medium=readme&amp;utm_campaign=lynkr">Explore Atlas Cloud</a>.</sub>
+</div>
 
 ---
 

package/bin/lynkr-init.js

@@ -89,6 +89,17 @@ const PROVIDERS = {
     extras: [],
     defaultModel: 'gpt-4o',
   },
+  atlas: {
+    label: 'Atlas Cloud (OpenAI-compatible)',
+    local: false,
+    creds: [
+      { key: 'ATLASCLOUD_API_KEY', label: 'Atlas Cloud API key', secret: true },
+    ],
+    extras: [
+      { key: 'ATLASCLOUD_ENDPOINT', label: 'Chat Completions endpoint', default: 'https://api.atlascloud.ai/v1/chat/completions' },
+    ],
+    defaultModel: 'qwen/qwen3.8-max',
+  },
   openrouter: {
     label: 'OpenRouter (100+ models, one key)',
     local: false,
@@ -159,12 +170,21 @@ const PROVIDERS = {
     extras: [],
     defaultModel: 'kimi-k2-turbo-preview',
   },
+  baidu: {
+    label: 'Baidu Qianfan (ERNIE)',
+    local: false,
+    creds: [
+      { key: 'BAIDU_API_KEY', label: 'Baidu Qianfan API key (bce-v3/ALTAK-...)', secret: true },
+    ],
+    extras: [],
+    defaultModel: 'ernie-4.5-turbo-128k',
+  },
 };
 
 const PROVIDER_ORDER = [
   'ollama', 'llamacpp', 'lmstudio',
-  'azure-anthropic', 'azure-openai', 'openai', 'openrouter', 'edenai',
-  'databricks', 'bedrock', 'vertex', 'zai', 'moonshot',
+  'azure-anthropic', 'azure-openai', 'openai', 'atlas', 'openrouter', 'edenai',
+  'databricks', 'bedrock', 'vertex', 'zai', 'moonshot', 'baidu',
 ];
 const TIERS = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
 
@@ -319,6 +339,9 @@ const BASELINE_ENV = {
   MOONSHOT_API_KEY: '',
   MOONSHOT_ENDPOINT: 'https://api.moonshot.ai/v1/chat/completions',
   MOONSHOT_MODEL: 'kimi-k2.6',
+  BAIDU_API_KEY: '',
+  BAIDU_ENDPOINT: 'https://qianfan.baidubce.com/v2/chat/completions',
+  BAIDU_MODEL: 'ernie-4.5-turbo-128k',
   LLAMACPP_ENDPOINT: 'http://localhost:8080',
   LLAMACPP_MODEL: 'default',
   LLAMACPP_TIMEOUT_MS: '120000',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lynkr",
-  "version": "9.12.0",
+  "version": "9.13.0",
   "files": [
     "index.js",
     "install.sh",
@@ -37,7 +37,7 @@
     "dev": "nodemon index.js",
     "lint": "eslint src index.js",
     "test": "npm run test:unit && npm run test:performance",
-    "test:unit": "DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com LOG_FILE_ENABLED=false node --test test/routing.test.js test/hybrid-routing-integration.test.js test/retry-logic.test.js test/sse-transformer.test.js test/passthrough-stream.test.js test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js test/azure-openai-config.test.js test/azure-openai-format-conversion.test.js test/azure-openai-routing.test.js test/azure-openai-streaming.test.js test/azure-openai-error-resilience.test.js test/azure-openai-integration.test.js test/openai-integration.test.js test/toon-compression.test.js test/gcf-compression.test.js test/llamacpp-integration.test.js test/resilience.test.js test/telemetry-routing.test.js test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js test/distill.test.js test/large-payload.test.js test/prompt-cache-injection.test.js test/risk-analyzer.test.js test/interaction-block.test.js test/preflight.test.js test/token-reduction.test.js test/session-affinity.test.js test/cache-state.test.js test/cache-switch-cost.test.js test/lens-recommendations.test.js test/model-registry-cost.test.js test/output-format-guard.test.js test/tier-fallback.test.js test/wrap.test.js test/init.test.js test/tool-call-response-metadata.test.js test/degradation.test.js test/routing-telemetry-columns.test.js test/sticky-routing.test.js test/knn-ambiguous-escalate.test.js test/deescalator.test.js test/client-profiles.test.js test/strip-internal-fields.test.js test/complexity-tool-subtraction.test.js test/bandit.test.js test/routing-propensity.test.js test/reward-pipeline.test.js test/knn-cold-start.test.js test/calibration.test.js test/feedback-loop.test.js test/session-fingerprint.test.js test/side-request-guards.test.js test/verifier.test.js test/intent-score.test.js test/difficulty-classifier.test.js test/classifier-setup.test.js test/usage-stats.test.js test/loop-guard.test.js test/moonshot-model-mapping.test.js",
+    "test:unit": "DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com LOG_FILE_ENABLED=false node --test test/routing.test.js test/hybrid-routing-integration.test.js test/retry-logic.test.js test/sse-transformer.test.js test/passthrough-stream.test.js test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js test/azure-openai-config.test.js test/azure-openai-format-conversion.test.js test/azure-openai-routing.test.js test/azure-openai-streaming.test.js test/azure-openai-error-resilience.test.js test/azure-openai-integration.test.js test/openai-integration.test.js test/atlas-integration.test.js test/toon-compression.test.js test/gcf-compression.test.js test/llamacpp-integration.test.js test/resilience.test.js test/telemetry-routing.test.js test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js test/distill.test.js test/large-payload.test.js test/prompt-cache-injection.test.js test/risk-analyzer.test.js test/interaction-block.test.js test/preflight.test.js test/token-reduction.test.js test/session-affinity.test.js test/cache-state.test.js test/cache-switch-cost.test.js test/lens-recommendations.test.js test/model-registry-cost.test.js test/output-format-guard.test.js test/tier-fallback.test.js test/wrap.test.js test/init.test.js test/tool-call-response-metadata.test.js test/degradation.test.js test/routing-telemetry-columns.test.js test/sticky-routing.test.js test/knn-ambiguous-escalate.test.js test/deescalator.test.js test/client-profiles.test.js test/strip-internal-fields.test.js test/complexity-tool-subtraction.test.js test/bandit.test.js test/routing-propensity.test.js test/reward-pipeline.test.js test/knn-cold-start.test.js test/calibration.test.js test/feedback-loop.test.js test/session-fingerprint.test.js test/side-request-guards.test.js test/verifier.test.js test/intent-score.test.js test/difficulty-classifier.test.js test/classifier-setup.test.js test/usage-stats.test.js test/loop-guard.test.js test/moonshot-model-mapping.test.js test/baidu-model-mapping.test.js",
     "test:memory": "DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node --test test/memory/store.test.js test/memory/surprise.test.js test/memory/extractor.test.js test/memory/search.test.js test/memory/retriever.test.js test/memory/distiller.test.js test/memory/distiller-freeze.test.js test/memory/wiki.test.js test/memory/skills-cache.test.js test/memory/tencentdb-launcher.test.js",
     "test:new-features": "DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node --test test/passthrough-mode.test.js test/openrouter-error-resilience.test.js test/format-conversion.test.js",
     "test:performance": "DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node test/hybrid-routing-performance.test.js && DATABRICKS_API_KEY=test-key DATABRICKS_API_BASE=http://test.com node test/performance-tests.js",

package/src/api/openai-router.js

@@ -588,6 +588,22 @@ router.post("/chat/completions", async (req, res) => {
         const content = lynkrBadge(result.body) + (openaiResponse.choices[0].message.content || "");
         let toolCalls = openaiResponse.choices[0].message.tool_calls;
 
+        // Guard: never serve a clean empty completion. Upstream failures
+        // (e.g. exhausted 429 retries) can surface here as a contentless
+        // message with finish_reason "stop"; agent clients read that as
+        // "task complete" and terminate mid-task. Killing the stream without
+        // a finish chunk makes the client retry instead.
+        if (!content && (!toolCalls || toolCalls.length === 0)) {
+          logger.error({
+            finishReason: openaiResponse.choices[0]?.finish_reason,
+            terminationReason: result?.terminationReason,
+            status: result?.status,
+          }, "Empty completion reached serving path — aborting stream to force client retry");
+          res.write(`data: ${JSON.stringify({ error: { message: "Upstream returned an empty completion; retry.", type: "server_error", code: "empty_completion" } })}\n\n`);
+          res.destroy();
+          return;
+        }
+
         if (clientType !== "unknown" && toolCalls && toolCalls.length > 0) {
           toolCalls = toolCalls.map(tc => {
             const mapped = mapToolForClient(tc.function?.name || "", tc.function?.arguments || "{}", clientType);
@@ -764,6 +780,21 @@ router.post("/chat/completions", async (req, res) => {
         }, "Tool names mapped for non-streaming chat/completions");
       }
 
+      // Guard (mirrors the streaming path): never serve a clean empty
+      // completion — upstream failures can surface as contentless messages
+      // with finish_reason "stop", which agent clients read as "done" and
+      // terminate mid-task. A 502 is retryable; an empty 200 is a silent kill.
+      const _msg = openaiResponse.choices?.[0]?.message;
+      if (!_msg?.content && !(_msg?.tool_calls?.length > 0)) {
+        logger.error({
+          finishReason: openaiResponse.choices?.[0]?.finish_reason,
+          usage: openaiResponse.usage,
+        }, "Empty completion reached non-streaming serving path — returning 502");
+        return res.status(502).json({
+          error: { message: "Upstream returned an empty completion; retry.", type: "server_error", code: "empty_completion" }
+        });
+      }
+
       logger.info({
         duration: Date.now() - startTime,
         mode: "non-streaming",
@@ -939,6 +970,18 @@ function getConfiguredProviders() {
     });
   }
 
+  if (config.baidu?.apiKey) {
+    providers.push({
+      name: "baidu",
+      type: "baidu-qianfan",
+      models: [
+        config.baidu.model || "ernie-4.5-turbo-128k",
+        "ernie-4.5-turbo-128k",
+        "ernie-x1.1"
+      ]
+    });
+  }
+
   if (config.vertex?.projectId) {
     providers.push({
       name: "vertex",

package/src/api/providers-handler.js

@@ -107,6 +107,19 @@ function getConfiguredProviders() {
     });
   }
 
+  // Check Atlas Cloud (OpenAI-compatible Chat Completions)
+  if (config.atlas?.apiKey) {
+    providers.push({
+      name: "atlas",
+      type: "atlas-cloud",
+      baseUrl: config.atlas.endpoint || "https://api.atlascloud.ai/v1/chat/completions",
+      enabled: true,
+      models: [
+        { id: config.atlas.model || "qwen/qwen3.8-max", name: "Configured Model" },
+      ]
+    });
+  }
+
   // Check OpenRouter
   if (config.openrouter?.apiKey) {
     providers.push({
@@ -210,6 +223,21 @@ function getConfiguredProviders() {
     });
   }
 
+  // Check Baidu Qianfan (ERNIE)
+  if (config.baidu?.apiKey) {
+    providers.push({
+      name: "baidu",
+      type: "baidu-qianfan",
+      baseUrl: config.baidu.endpoint || "https://qianfan.baidubce.com/v2/chat/completions",
+      enabled: true,
+      models: [
+        { id: config.baidu.model || "ernie-4.5-turbo-128k", name: "Configured Model" },
+        { id: "ernie-4.5-turbo-128k", name: "ERNIE 4.5 Turbo 128K" },
+        { id: "ernie-x1.1", name: "ERNIE X1.1 (reasoning)" },
+      ]
+    });
+  }
+
   // Check Vertex AI (Google Cloud)
   if (config.vertex?.projectId) {
     const region = config.vertex.region || "us-east5";

package/src/clients/databricks.js

@@ -77,7 +77,7 @@ function _stripInternalFields(body) {
   return cleaned || body;
 }
 
-async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride }, providerLabel) {
+async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride, maxRetriesOverride }, providerLabel) {
   const agent = url.startsWith('https:') ? httpsAgent : httpAgent;
   body = _stripInternalFields(body);
   const isStreaming = body.stream === true;
@@ -158,7 +158,7 @@ async function performJsonRequest(url, { headers = {}, body, retryableStatusesOv
 
     return result;
   }, {
-    maxRetries: config.apiRetry?.maxRetries || 3,
+    maxRetries: maxRetriesOverride ?? (config.apiRetry?.maxRetries || 3),
     initialDelay: config.apiRetry?.initialDelay || 1000,
     maxDelay: config.apiRetry?.maxDelay || 30000,
     ...(retryableStatusesOverride ? { retryableStatuses: retryableStatusesOverride } : {}),
@@ -888,6 +888,23 @@ function detectAzureFormat(url) {
 }
 
 
+/**
+ * Stable per-conversation cache key for GPT-5.6 declared prompt caching.
+ * Prefers the session id; falls back to hashing the first user message,
+ * which is identical across every turn of the same conversation.
+ */
+function derivePromptCacheKey(body) {
+  if (body._sessionId) return String(body._sessionId).slice(0, 64);
+  const first = (body.messages || []).find(m => m.role === "user");
+  let text = "";
+  if (first) {
+    text = typeof first.content === "string"
+      ? first.content
+      : JSON.stringify(first.content);
+  }
+  return "conv-" + crypto.createHash("sha1").update(text.slice(0, 4000)).digest("hex").slice(0, 32);
+}
+
 async function invokeAzureOpenAI(body, incomingHeaders = {}) {
   if (!config.azureOpenAI?.endpoint || !config.azureOpenAI?.apiKey) {
     throw new Error("Azure OpenAI endpoint or API key is not configured.");
@@ -1004,6 +1021,16 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
     const responsesInput = [];
     // Track function call IDs for matching with outputs
     const pendingCallIds = [];
+    // Fallback IDs must be DETERMINISTIC: the same history must render
+    // byte-identically on every turn, or provider prompt caching never hits.
+    // (Was Date.now()+Math.random(), which re-randomized history each turn.)
+    let stableIdCounter = 0;
+    const stableCallId = (name, args) => {
+      const h = crypto.createHash("sha1")
+        .update(`${name || ""}|${args || ""}|${stableIdCounter++}`)
+        .digest("hex").slice(0, 16);
+      return `call_${h}`;
+    };
 
     // Detect if this is a continuation request (has tool results)
     // Azure content filter triggers on full system prompt in continuations
@@ -1065,36 +1092,32 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
 
     for (const msg of azureBody.messages) {
       if (msg.role === "system") {
-        // For continuation requests, use minimal system prompt to avoid content filter
-        // Azure's jailbreak detection triggers on security-related text in continuations
-        if (hasToolResults) {
-          responsesInput.push({
-            type: "message",
-            role: "developer",
-            content: "You are a helpful coding assistant. Continue helping the user based on the tool results."
-          });
-        } else {
-          // Initial request - use full system prompt
-          responsesInput.push({
-            type: "message",
-            role: "developer",
-            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-          });
-        }
+        // The system prompt must be IDENTICAL on every turn of a conversation:
+        // (a) swapping it per turn breaks provider prompt-cache prefixes, and
+        // (b) replacing it on continuations silently dropped the client
+        // agent's actual instructions mid-task. Strip system-reminder blocks
+        // uniformly (that was the content-filter trigger, not the prompt).
+        const sysText = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+        responsesInput.push({
+          type: "message",
+          role: "developer",
+          content: stripSystemReminders(sysText) || sysText
+        });
       } else if (msg.role === "user") {
         // Check if content contains tool_result blocks (Anthropic format)
         if (Array.isArray(msg.content)) {
           for (const block of msg.content) {
             if (block.type === "tool_result") {
-              const callId = block.tool_use_id || pendingCallIds.shift() || `call_${Date.now()}`;
+              const callId = block.tool_use_id || pendingCallIds.shift() || stableCallId("result", block.content);
               responsesInput.push({
                 type: "function_call_output",
                 call_id: callId,
                 output: typeof block.content === 'string' ? block.content : JSON.stringify(block.content || "")
               });
             } else if (block.type === "text") {
-              // For continuation requests, strip system-reminder tags to avoid jailbreak filter
-              const textContent = hasToolResults ? stripSystemReminders(block.text || "") : (block.text || "");
+              // Strip system-reminder tags on EVERY turn (uniformly), so the
+              // same message renders identically across turns (cache prefix).
+              const textContent = stripSystemReminders(block.text || "");
               if (textContent) {  // Only add if there's content after stripping
                 responsesInput.push({
                   type: "message",
@@ -1105,11 +1128,9 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
             }
           }
         } else {
-          // For continuation requests, strip system-reminder tags to avoid jailbreak filter
+          // Strip system-reminder tags uniformly on every turn (cache prefix).
           let userContent = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
-          if (hasToolResults) {
-            userContent = stripSystemReminders(userContent);
-          }
+          userContent = stripSystemReminders(userContent);
           if (userContent) {  // Only add if there's content after stripping
             responsesInput.push({
               type: "message",
@@ -1123,7 +1144,7 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         if (msg.tool_calls && msg.tool_calls.length > 0) {
           // OpenAI format: tool_calls array
           for (const tc of msg.tool_calls) {
-            const callId = tc.id || `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            const callId = tc.id || stableCallId(tc.function?.name || tc.name, tc.function?.arguments);
             pendingCallIds.push(callId);
             responsesInput.push({
               type: "function_call",
@@ -1138,7 +1159,7 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
           // Anthropic format: content is array of blocks
           for (const block of msg.content) {
             if (block.type === "tool_use") {
-              const callId = block.id || `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+              const callId = block.id || stableCallId(block.name, block.input);
               pendingCallIds.push(callId);
               responsesInput.push({
                 type: "function_call",
@@ -1164,7 +1185,7 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         }
       } else if (msg.role === "tool") {
         // Tool results become function_call_output
-        const callId = msg.tool_call_id || pendingCallIds.shift() || `call_${Date.now()}`;
+        const callId = msg.tool_call_id || pendingCallIds.shift() || stableCallId("tool", msg.content);
         responsesInput.push({
           type: "function_call_output",
           call_id: callId,
@@ -1173,12 +1194,26 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
       }
     }
 
+    // Reasoning effort: honor the client's request, else the env default.
+    // Without this, gpt-5.x reasoning models run at their shallowest setting.
+    const reasoningEffort = body.reasoning_effort
+      ?? body.reasoning?.effort
+      ?? process.env.AZURE_OPENAI_REASONING_EFFORT
+      ?? null;
     const responsesBody = {
       input: responsesInput,
       model: azureBody.model,
-      max_output_tokens: azureBody.max_tokens,
+      // gpt-5.x deployments store the cap under max_completion_tokens.
+      max_output_tokens: azureBody.max_completion_tokens ?? azureBody.max_tokens,
       tools: responsesTools,
       tool_choice: azureBody.tool_choice,
+      ...(isGpt5 && reasoningEffort ? { reasoning: { effort: reasoningEffort } } : {}),
+      // GPT-5.6 caching is declaration-based: a stable per-conversation key
+      // makes prefix cache matching reliable (~90% discount on agent loops).
+      // _sessionId is empty on the agentic path, so fall back to a hash of
+      // the conversation's first user message — stable across every turn of
+      // the same task. Keep per-key traffic under ~15 req/min.
+      ...(isGpt5 ? { prompt_cache_key: derivePromptCacheKey(body) } : {}),
       stream: false
     };
     logger.debug({
@@ -1277,6 +1312,11 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
           completion_tokens: result.json.usage.completion_tokens ?? result.json.usage.output_tokens ?? 0,
           total_tokens: result.json.usage.total_tokens
             ?? ((result.json.usage.input_tokens ?? 0) + (result.json.usage.output_tokens ?? 0)),
+          // Provider-side prompt-cache hits (Responses API: input_tokens_details,
+          // Chat Completions: prompt_tokens_details) — telemetry reads this name.
+          cache_read_input_tokens: result.json.usage.input_tokens_details?.cached_tokens
+            ?? result.json.usage.prompt_tokens_details?.cached_tokens
+            ?? null,
         } : undefined
       };
 
@@ -1385,6 +1425,69 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
   return performJsonRequest(endpoint, { headers, body: openAIBody }, "OpenAI");
 }
 
+async function invokeAtlas(body) {
+  if (!config.atlas?.apiKey) {
+    throw new Error("Atlas Cloud API key is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = config.atlas.endpoint || "https://api.atlascloud.ai/v1/chat/completions";
+  const headers = {
+    "Authorization": `Bearer ${config.atlas.apiKey}`,
+    "Content-Type": "application/json",
+  };
+
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+  if (body.system) {
+    messages.unshift({ role: "system", content: body.system });
+  }
+
+  const atlasBody = {
+    model: body._suggestionModeModel || body._tierModel || config.atlas.model || "qwen/qwen3.8-max",
+    messages,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens ?? 16384,
+    top_p: body.top_p ?? 1.0,
+    stream: body.stream ?? false,
+  };
+
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    toolsToSend = STANDARD_TOOLS;
+    toolsInjected = true;
+  }
+
+  if (toolsToSend.length > 0) {
+    atlasBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    atlasBody.parallel_tool_calls = false;
+    atlasBody.tool_choice = "auto";
+  }
+
+  logger.debug({
+    endpoint,
+    model: atlasBody.model,
+    hasTools: !!atlasBody.tools,
+    toolCount: atlasBody.tools?.length || 0,
+    toolsInjected,
+    temperature: atlasBody.temperature,
+    max_tokens: atlasBody.max_tokens,
+  }, "=== ATLAS CLOUD REQUEST ===");
+
+  // Chat completions are billable POSTs, so Atlas requests are never replayed
+  // automatically. Callers can retry explicitly with their own idempotency policy.
+  return performJsonRequest(endpoint, {
+    headers,
+    body: atlasBody,
+    maxRetriesOverride: 0,
+    retryableStatusesOverride: [],
+  }, "Atlas Cloud");
+}
+
 async function invokeLlamaCpp(body, incomingHeaders = {}) {
   if (!config.llamacpp?.endpoint) {
     throw new Error("llama.cpp endpoint is not configured.");
@@ -1947,6 +2050,12 @@ async function invokeZai(body, incomingHeaders = {}) {
     zaiBody = { ...body };
     zaiBody.model = mappedModel;
 
+    // Force buffered mode: with stream:true this endpoint returns ANTHROPIC
+    // SSE, but the downstream transformer parses OPENAI SSE — every chunk is
+    // unreadable and the client receives an empty completion. Buffered JSON
+    // converts correctly; the router synthesizes client-side SSE as usual.
+    zaiBody.stream = false;
+
     // Inject standard tools if client didn't send any (passthrough mode)
     if (!Array.isArray(zaiBody.tools) || zaiBody.tools.length === 0) {
       zaiBody.tools = STANDARD_TOOLS;
@@ -2191,6 +2300,129 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
   return response;
 }
 
+/**
+ * Baidu Qianfan (ERNIE) Provider
+ *
+ * Qianfan's v2 endpoint is an OpenAI-compatible Chat Completions API
+ * (bearer-token auth, key format "bce-v3/ALTAK-..."). Modeled on
+ * invokeMoonshot: request side reuses the shared openrouter-utils
+ * converters, response is converted to Anthropic shape locally so the
+ * orchestrator branch is a plain passthrough.
+ *
+ * NOTE: sampling-param quirks and the exact model roster below are best
+ * effort from public docs, not yet probed against a live key. Revisit the
+ * modelMap and pinned-params logic (see Moonshot's kimi-k* precedent) once
+ * real traffic surfaces 400s.
+ */
+async function invokeBaidu(body, incomingHeaders = {}) {
+  if (!config.baidu?.apiKey) {
+    throw new Error("Baidu API key is not configured. Set BAIDU_API_KEY in your .env file.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = config.baidu.endpoint || "https://qianfan.baidubce.com/v2/chat/completions";
+
+  // Model mapping: Anthropic names → Baidu ERNIE names.
+  // Starting point only — refine once TIER_* mappings and live-probe results
+  // are known (see file-level NOTE above).
+  const modelMap = {
+    "claude-sonnet-4-5-20250929": "ernie-4.5-turbo-128k",
+    "claude-sonnet-4-5": "ernie-4.5-turbo-128k",
+    "claude-sonnet-4.5": "ernie-4.5-turbo-128k",
+    "claude-3-5-sonnet": "ernie-4.5-turbo-128k",
+    "claude-opus-4-5": "ernie-x1.1",
+    "claude-haiku-4-5-20251001": "ernie-speed-8k",
+    "claude-haiku-4-5": "ernie-speed-8k",
+    "claude-3-haiku": "ernie-speed-8k",
+  };
+
+  const requestedModel = body._tierModel || body.model || config.baidu.model;
+  // Honor tier-selected ERNIE ids (e.g. TIER_REASONING=baidu:ernie-x1.1)
+  // instead of silently swapping in the .env default model.
+  const mappedModel = modelMap[requestedModel]
+    || (/^ernie-/i.test(requestedModel || "") ? requestedModel : null)
+    || config.baidu.model
+    || "ernie-4.5-turbo-128k";
+
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  // Qianfan's OpenAI-compatible endpoint supports the system role natively.
+  if (body.system) {
+    const systemContent = Array.isArray(body.system)
+      ? body.system.map(s => s.text || s).join("\n")
+      : body.system;
+    messages.unshift({ role: "system", content: systemContent });
+  }
+
+  const baiduBody = {
+    model: mappedModel,
+    messages,
+    max_tokens: body.max_tokens || 16384,
+    temperature: body.temperature ?? 0.7,
+    top_p: body.top_p ?? 1.0,
+    // Streaming honored once "baidu" is added to DEFAULT_OPENAI_SSE_PROVIDERS
+    // (sse-transformer.js) and confirmed to match OpenAI SSE shape. Buffered
+    // requests use the Anthropic conversion path below regardless.
+    stream: body.stream ?? false,
+  };
+
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    baiduBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
+    baiduBody.tool_choice = "auto";
+    baiduBody.parallel_tool_calls = false;
+  }
+
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.baidu.apiKey}`,
+  };
+
+  logger.debug({
+    endpoint,
+    model: baiduBody.model,
+    originalModel: requestedModel,
+    messageCount: baiduBody.messages?.length || 0,
+    hasTools: !!baiduBody.tools,
+    toolCount: baiduBody.tools?.length || 0,
+  }, "=== Baidu Qianfan REQUEST ===");
+
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: baiduBody,
+    retryableStatusesOverride: [500, 502, 503, 504],
+  }, "Baidu");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`Baidu Qianfan rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  // Streaming request: hand the raw stream to the orchestrator's stream
+  // branch. The Anthropic conversion below is buffered-only.
+  if (response?.stream) {
+    return response;
+  }
+
+  if (response?.ok && response?.json) {
+    const anthropicJson = convertOpenAIToAnthropic(response.json);
+    return {
+      ok: response.ok,
+      status: response.status,
+      json: anthropicJson,
+      text: JSON.stringify(anthropicJson),
+      contentType: "application/json",
+      headers: response.headers,
+    };
+  }
+
+  return response;
+}
+
 /**
  * Convert OpenAI response to Anthropic format
  */
@@ -2267,6 +2499,10 @@ function convertOpenAIToAnthropic(response) {
     usage: {
       input_tokens: response.usage?.prompt_tokens || 0,
       output_tokens: response.usage?.completion_tokens || 0,
+      // Provider-side prompt-cache hits — telemetry reads this field name.
+      cache_read_input_tokens: response.usage?.cache_read_input_tokens
+        ?? response.usage?.prompt_tokens_details?.cached_tokens
+        ?? null,
     }
   };
 }
@@ -2751,6 +2987,7 @@ const PROVIDER_INVOKERS = {
   openrouter: invokeOpenRouter,
   edenai: invokeEdenAI,
   openai: invokeOpenAI,
+  atlas: invokeAtlas,
   llamacpp: invokeLlamaCpp,
   lmstudio: invokeLMStudio,
   bedrock: invokeBedrock,
@@ -2758,6 +2995,7 @@ const PROVIDER_INVOKERS = {
   vertex: invokeVertex,
   moonshot: invokeMoonshot,
   codex: invokeCodex,
+  baidu: invokeBaidu,
 };
 
 function invokeProvider(provider, body, incomingHeaders) {
@@ -3540,6 +3778,8 @@ module.exports = {
   invokeZai,
   invokeOllama,
   invokeMoonshot,
+  invokeBaidu,
+  invokeAtlas,
   PROVIDER_INVOKERS,
   stripLynkrBadges,
   destroyHttpAgents,

package/src/clients/provider-capabilities.js

@@ -11,7 +11,7 @@ const NATIVE_THINKING_BEDROCK_MODELS = [
   "claude-haiku",
 ];
 
-const REASONING_CONTENT_PROVIDERS = new Set(["moonshot", "openrouter", "edenai", "openai", "azure-openai"]);
+const REASONING_CONTENT_PROVIDERS = new Set(["moonshot", "openrouter", "edenai", "openai", "azure-openai", "atlas"]);
 
 function supportsNativeThinking(providerType, model) {
   if (NATIVE_THINKING_PROVIDERS.has(providerType)) return true;

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) {
@@ -1839,8 +1851,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
@@ -2606,6 +2623,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;

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",

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':

package/scripts/convert-routellm.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-"""
-Convert routellm/gpt4_dataset (train.jsonl) → Lynkr kNN bootstrap JSONL.
-
-Stream-downloads from HuggingFace and maps mixtral_score (1-5) to your
-TIER_* model config so the kNN index learns to recommend YOUR real models,
-not RouteLLM's pool (mixtral / gpt-4).
-
-Output format matches scripts/build-knn-index.js bootstrap input:
-    {"query": "...", "provider": "ollama", "model": "minimax-m2.5:cloud",
-     "quality": 95, "cost": 0.001, "latency": 200, "tier": "SIMPLE"}
-
-Usage:
-    .venv/bin/python scripts/convert-routellm.py [--limit 30000] -o routellm.jsonl
-"""
-import argparse
-import json
-import sys
-import urllib.request
-import ssl
-
-# Map mixtral_score → user's tier config.
-# Spread is intentionally aggressive: only score=5 (Mixtral truly nailed it)
-# stays SIMPLE; score=4 escalates to MEDIUM so the kNN index has enough MEDIUM
-# examples to actually recommend non-SIMPLE tiers (vs the previous mapping
-# where 86% of records were SIMPLE and kNN never disagreed with the heuristic).
-SCORE_TO_ROUTE = {
-    5: {"tier": "SIMPLE",    "provider": "ollama",          "model": "minimax-m2.5:cloud", "quality": 95, "cost": 0.001, "latency": 200},
-    4: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 80, "cost": 0.003, "latency": 1500},
-    3: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 70, "cost": 0.003, "latency": 1500},
-    2: {"tier": "COMPLEX",   "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 55, "cost": 0.003, "latency": 1500},
-    1: {"tier": "REASONING", "provider": "azure-anthropic", "model": "claude-opus-4-8",    "quality": 40, "cost": 0.015, "latency": 3500},
-}
-
-URL = "https://huggingface.co/datasets/routellm/gpt4_dataset/resolve/main/train.jsonl"
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("--output", "-o", default="data/routellm-bootstrap.jsonl")
-    p.add_argument("--limit", type=int, default=None,
-                   help="Only convert first N rows")
-    args = p.parse_args()
-
-    print(f"Streaming {URL} …", file=sys.stderr)
-    # Some macOS Python builds have SSL issues with huggingface.co — fall back
-    # to unverified context if needed. The data is public, no auth.
-    ctx = ssl.create_default_context()
-    try:
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-    except (ssl.SSLError, OSError) as e:
-        print(f"SSL strict failed ({e}); retrying with unverified context", file=sys.stderr)
-        ctx = ssl._create_unverified_context()
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-
-
-def _stream(resp, out_path, limit):
-    written = 0
-    by_score = {s: 0 for s in SCORE_TO_ROUTE}
-    skipped = 0
-    with open(out_path, "w") as out:
-        for line in resp:
-            if limit and written >= limit:
-                break
-            try:
-                row = json.loads(line)
-            except Exception:
-                skipped += 1
-                continue
-            score = row.get("mixtral_score")
-            if score not in SCORE_TO_ROUTE:
-                skipped += 1
-                continue
-            route = SCORE_TO_ROUTE[score]
-            rec = {
-                "query": row.get("prompt", ""),
-                "provider": route["provider"],
-                "model": route["model"],
-                "quality": route["quality"],
-                "cost": route["cost"],
-                "latency": route["latency"],
-                "tier": route["tier"],
-            }
-            if not rec["query"]:
-                skipped += 1
-                continue
-            out.write(json.dumps(rec) + "\n")
-            written += 1
-            by_score[score] += 1
-            if written % 5000 == 0:
-                print(f"  {written} written…", file=sys.stderr)
-
-    print(f"\nWrote {written} records to {out_path} ({skipped} skipped)", file=sys.stderr)
-    print(f"By mixtral_score: {by_score}", file=sys.stderr)
-    print(f"\nTier distribution:", file=sys.stderr)
-    for score, route in SCORE_TO_ROUTE.items():
-        n = by_score[score]
-        if n:
-            print(f"  {route['tier']:>10}  {route['provider']}:{route['model']:30s}  n={n}", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()