lynkr 9.11.0 → 9.13.0

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 } : {}),
@@ -310,6 +310,18 @@ async function invokeAzureAnthropic(body, incomingHeaders = {}) {
     incomingAuth = null;
   }
 
+  // Anthropic OAuth tokens are only meaningful at api.anthropic.com. When this
+  // provider points at any OTHER Anthropic-compatible host (Azure AI Foundry
+  // Claude, a corporate gateway), forwarding Claude Code's sk-ant-oat token
+  // earns a 401 there — and the configured x-api-key below is the right auth.
+  // This also means a subscription token never leaves the box unless the
+  // endpoint is Anthropic itself.
+  const isAnthropicDirect = String(config.azureAnthropic.endpoint || "").includes("api.anthropic.com");
+  if (incomingAuth && !isAnthropicDirect) {
+    logger.debug({ endpoint: config.azureAnthropic.endpoint }, "Azure Anthropic: non-Anthropic endpoint — using configured API key instead of client OAuth token");
+    incomingAuth = null;
+  }
+
   // Headers Anthropic uses to verify client identity for subscription OAuth tokens.
   // If we strip these, Anthropic returns 429 rate_limit_error with no rate-limit
   // headers (its terse anti-proxy response). Forward every Anthropic-relevant
@@ -876,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.");
@@ -992,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
@@ -1053,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",
@@ -1093,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",
@@ -1111,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",
@@ -1126,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",
@@ -1152,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,
@@ -1161,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({
@@ -1265,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
       };
 
@@ -1373,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.");
@@ -1935,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;
@@ -2094,7 +2215,11 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
     max_tokens: body.max_tokens || 16384,
     temperature: isKimiPinned ? 1 : (body.temperature ?? 0.7),
     top_p: isKimiPinned ? 0.95 : (body.top_p ?? 1.0),
-    stream: false,  // Force non-streaming - OpenAI SSE to Anthropic SSE conversion not implemented
+    // Streaming honored since the Phase-2b sse-transformer landed: the raw
+    // OpenAI SSE stream is returned below and reshaped in flight by the
+    // orchestrator (moonshot is in DEFAULT_OPENAI_SSE_PROVIDERS). Buffered
+    // requests keep the Anthropic conversion path unchanged.
+    stream: body.stream ?? false,
   };
 
   if (Array.isArray(body.tools) && body.tools.length > 0) {
@@ -2132,6 +2257,13 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
     throw err;
   }
 
+  // Streaming request: hand the raw OpenAI SSE stream to the orchestrator's
+  // stream branch (sse-transformer reshapes it). The Anthropic conversion
+  // below is buffered-only — it would consume the stream.
+  if (response?.stream) {
+    return response;
+  }
+
   const rawMsg = response?.json?.choices?.[0]?.message;
   logger.debug({
     responseOk: response?.ok,
@@ -2168,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
  */
@@ -2244,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,
     }
   };
 }
@@ -2728,6 +2987,7 @@ const PROVIDER_INVOKERS = {
   openrouter: invokeOpenRouter,
   edenai: invokeEdenAI,
   openai: invokeOpenAI,
+  atlas: invokeAtlas,
   llamacpp: invokeLlamaCpp,
   lmstudio: invokeLMStudio,
   bedrock: invokeBedrock,
@@ -2735,6 +2995,7 @@ const PROVIDER_INVOKERS = {
   vertex: invokeVertex,
   moonshot: invokeMoonshot,
   codex: invokeCodex,
+  baidu: invokeBaidu,
 };
 
 function invokeProvider(provider, body, incomingHeaders) {
@@ -3000,6 +3261,8 @@ async function invokeModel(body, options = {}) {
       pinned: routingResult.pinned ? 1 : 0,
       switch_reason: routingResult.switch_reason ?? null,
       cache_decision: routingResult._cacheDecision ?? null,
+      cache_read_tokens: result.json?.usage?.cache_read_input_tokens ?? null,
+      cache_creation_tokens: result.json?.usage?.cache_creation_input_tokens ?? null,
     });
 
     // WS5.4 — feedback loop (success path).
@@ -3351,6 +3614,8 @@ async function invokeModel(body, options = {}) {
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
       cache_decision: routingResult._cacheDecision ?? null,
+      cache_read_tokens: fallbackResult.json?.usage?.cache_read_input_tokens ?? null,
+      cache_creation_tokens: fallbackResult.json?.usage?.cache_creation_input_tokens ?? null,
       });
 
       // WS5.4 — feedback loop (fallback success). The served provider
@@ -3513,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;
 }