lynkr 9.12.0 → 9.14.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 } : {}),
@@ -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) {
@@ -3303,12 +3541,101 @@ async function invokeModel(body, options = {}) {
 
       const fallbackStart = Date.now();
 
+      // Strip the failed primary's routing stamps before re-dispatch: every
+      // provider client prefers body._tierModel over its own configured
+      // model, so leaving the failed tier's model on the body makes the
+      // fallback provider serve a model it doesn't have — azure-openai
+      // treats it as the deployment id and 404s with DeploymentNotFound
+      // (live incident 2026-08-19). The fallback provider must fall through
+      // to its own configured model.
+      const fallbackBody = { ...body };
+      delete fallbackBody._tierModel;
+      delete fallbackBody._suggestionModeModel;
+
       const fallbackResult = await fallbackBreaker.execute(async () => {
-        return await invokeProvider(fallbackProvider, body, incomingHeaders);
+        return await invokeProvider(fallbackProvider, fallbackBody, incomingHeaders);
       });
 
       const fallbackLatency = Date.now() - fallbackStart;
 
+      // Provider clients return {ok:false} on 4xx/5xx instead of throwing,
+      // so a fallback rung that answered with an error body used to sail
+      // through the success path below — logging "Fallback to cloud
+      // provider succeeded" and recording status_code:200 telemetry for
+      // what was actually a double failure. Treat it as one.
+      if (fallbackResult?.ok === false) {
+        const fbErrMessage = fallbackResult.json?.error?.message || String(fallbackResult.text || "").slice(0, 120) || "error response";
+
+        metricsCollector.recordFallbackFailure();
+        metricsCollector.recordDatabricksRequest(false, retries);
+        healthTracker.recordFailure(fallbackProvider, new Error(fbErrMessage), fallbackResult.status);
+
+        logger.warn({
+          originalProvider: initialProvider,
+          fallbackProvider,
+          status: fallbackResult.status,
+          error: fbErrMessage,
+        }, "Fallback provider answered with an error response");
+
+        // Thread the whole trail into the error payload so the client sees
+        // every failure, not just this one (e.g. "moonshot: quota" matters
+        // more than "azure: 404").
+        failureTrail.push(`${fallbackProvider}: HTTP ${fallbackResult.status} — ${fbErrMessage}`);
+        if (fallbackResult.json && typeof fallbackResult.json === "object") {
+          fallbackResult.json._lynkr_failure_trail = failureTrail;
+        }
+
+        const fbFailLatency = Date.now() - startTime;
+        telemetry.record({
+          request_id: crypto.randomUUID(),
+          session_id: body._sessionId || null,
+          timestamp: Date.now(),
+          complexity_score: routingResult.score ?? null,
+          tier: routingDecision.tier,
+          provider: fallbackProvider,
+          model: routingDecision.model ?? body._tierModel ?? null,
+          routing_method: "fallback",
+          was_fallback: true,
+          latency_ms: fbFailLatency,
+          status_code: fallbackResult.status || null,
+          error_type: "fallback_error_response",
+          quality_score: 0,
+          base_tier: routingResult.base_tier ?? null,
+          escalation_source: routingResult.escalation_source ?? null,
+          propensity: routingResult.propensity ?? null,
+          candidates: routingResult.candidates ?? null,
+          pinned: routingResult.pinned ? 1 : 0,
+          switch_reason: routingResult.switch_reason ?? null,
+          cache_decision: routingResult._cacheDecision ?? null,
+        });
+
+        // WS5.4 — feedback loop (fallback answered with an error). Same
+        // hard-negative signal as a double failure.
+        recordFeedbackOutcome({
+          routingResult,
+          body,
+          outcome: {
+            qualityScore: 0,
+            costUsd: null,
+            latencyMs: fbFailLatency,
+            statusCode: fallbackResult.status || null,
+            errorType: "fallback_error_response",
+            wasFallback: true,
+          },
+        });
+
+        return {
+          ...fallbackResult,
+          actualProvider: fallbackProvider,
+          routingDecision: {
+            ...routingDecision,
+            provider: fallbackProvider,
+            method: 'fallback',
+            fallbackReason: reason,
+          },
+        };
+      }
+
       metricsCollector.recordFallbackSuccess(fallbackLatency);
       metricsCollector.recordDatabricksRequest(true, retries);
       healthTracker.recordSuccess(fallbackProvider, fallbackLatency);
@@ -3397,16 +3724,6 @@ async function invokeModel(body, options = {}) {
         },
       });
 
-      // The last rung also answered with an error — thread the whole trail
-      // into the error payload so the client sees every failure, not just
-      // this one (e.g. "moonshot: quota" matters more than "azure: 404").
-      if (fallbackResult?.ok === false) {
-        failureTrail.push(`${fallbackProvider}: HTTP ${fallbackResult.status} — ${fallbackResult.json?.error?.message || String(fallbackResult.text || "").slice(0, 120) || "error response"}`);
-        if (fallbackResult.json && typeof fallbackResult.json === "object") {
-          fallbackResult.json._lynkr_failure_trail = failureTrail;
-        }
-      }
-
       return {
         ...fallbackResult,
         actualProvider: fallbackProvider,
@@ -3540,6 +3857,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/clients/resilience.js

@@ -381,6 +381,15 @@ async function withCockatielRetry(fn, options = {}) {
               const retryAfterDate = new Date(retryAfter);
               delay = retryAfterDate.getTime() - Date.now();
             }
+            // Retry-After is a floor, not the full answer: Azure sends
+            // "Retry-After: 1" on token-window 429s that need far longer to
+            // drain, so honoring it literally re-hammers the window every
+            // second and it never recovers (2026-08-19 incident). Back off
+            // exponentially on top of the header, with jitter.
+            const floorMs = Math.max(0, delay || 0);
+            const backoffMs = 2000 * Math.pow(config.backoffMultiplier, attempt);
+            const cappedMs = Math.min(Math.max(floorMs, backoffMs), 60000);
+            delay = cappedMs + cappedMs * config.jitterFactor * Math.random();
           } else {
             // Exponential backoff with longer delays for rate limiting
             const baseDelay = 2000 * Math.pow(config.backoffMultiplier, attempt);