lynkr 9.5.0 → 9.7.0

package/src/clients/databricks.js

@@ -51,7 +51,7 @@ const httpsAgent = new https.Agent({
   keepAliveMsecs: 30000,
 });
 
-async function performJsonRequest(url, { headers = {}, body }, providerLabel) {
+async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride }, providerLabel) {
   const agent = url.startsWith('https:') ? httpsAgent : httpAgent;
   const isStreaming = body.stream === true;
 
@@ -134,10 +134,11 @@ async function performJsonRequest(url, { headers = {}, body }, providerLabel) {
     maxRetries: config.apiRetry?.maxRetries || 3,
     initialDelay: config.apiRetry?.initialDelay || 1000,
     maxDelay: config.apiRetry?.maxDelay || 30000,
+    ...(retryableStatusesOverride ? { retryableStatuses: retryableStatusesOverride } : {}),
   });
 }
 
-async function invokeDatabricks(body) {
+async function invokeDatabricks(body, incomingHeaders = {}) {
   if (!config.databricks?.url) {
     throw new Error("Databricks configuration is missing required URL.");
   }
@@ -181,34 +182,224 @@ async function invokeDatabricks(body) {
   return performJsonRequest(config.databricks.url, { headers, body: databricksBody }, "Databricks");
 }
 
-async function invokeAzureAnthropic(body) {
+async function invokeAzureAnthropic(body, incomingHeaders = {}) {
   if (!config.azureAnthropic?.endpoint) {
     throw new Error("Azure Anthropic endpoint is not configured.");
   }
 
-  // Inject standard tools if client didn't send any (passthrough mode)
-  if (!Array.isArray(body.tools) || body.tools.length === 0) {
-    body.tools = STANDARD_TOOLS;
-    logger.debug({
-      injectedToolCount: STANDARD_TOOLS.length,
-      injectedToolNames: STANDARD_TOOL_NAMES,
-      reason: "Client did not send tools (passthrough mode)"
-    }, "=== INJECTING STANDARD TOOLS (Azure Anthropic) ===");
+  // Copy body so we don't mutate the caller's object across agent-loop iterations.
+  const azureBody = { ...body };
+
+  // Tier routing wins over whatever model Claude Code sent.
+  if (azureBody._tierModel) {
+    azureBody.model = azureBody._tierModel;
   }
 
-  const headers = {
-    "Content-Type": "application/json",
-    "x-api-key": config.azureAnthropic.apiKey,
-    "anthropic-version": config.azureAnthropic.version ?? "2023-06-01",
+  // Strip ALL Lynkr-internal fields (convention: leading underscore). Anthropic
+  // rejects unknown top-level keys with "Extra inputs are not permitted", and
+  // the orchestrator sprinkles fields like _requestMode, _tierModel, _workspace,
+  // _sessionId, _tenantPolicy, _suggestionModeModel onto the payload.
+  for (const key of Object.keys(azureBody)) {
+    if (key.startsWith('_')) delete azureBody[key];
+  }
+
+  // Tier routing can dispatch here even when the orchestrator formatted the
+  // payload for a different provider (the orchestrator picks format from the
+  // static MODEL_PROVIDER, not the tier-resolved provider). Normalize OpenAI-style
+  // shapes back to Anthropic format so the API doesn't reject the request.
+
+  // 1) Tools: {type:"function", function:{...}} -> {name, description, input_schema}
+  if (Array.isArray(azureBody.tools)) {
+    azureBody.tools = azureBody.tools.map((tool) => {
+      if (tool?.type === "function" && tool.function) {
+        return {
+          name: tool.function.name,
+          description: tool.function.description,
+          input_schema: tool.function.parameters ?? { type: "object", properties: {} },
+        };
+      }
+      return tool;
+    });
+  }
+
+  // Strip Lynkr's Caveman "[brevity] …" trailer from the system prompt — it
+  // changes the prompt vs. what Claude Code would send to Anthropic directly,
+  // and Anthropic's OAuth subscription anti-abuse is sensitive to that drift.
+  const stripBrevity = (s) => {
+    if (typeof s !== 'string') return s;
+    const idx = s.indexOf('[brevity]');
+    if (idx === -1) return s;
+    return s.slice(0, idx).trimEnd();
   };
-  return performJsonRequest(
+  if (typeof azureBody.system === 'string') {
+    azureBody.system = stripBrevity(azureBody.system);
+  } else if (Array.isArray(azureBody.system)) {
+    azureBody.system = azureBody.system
+      .map((block) => block && typeof block === 'object' && typeof block.text === 'string'
+        ? { ...block, text: stripBrevity(block.text) }
+        : block)
+      .filter((block) => !(block && typeof block === 'object' && block.text === ''));
+  }
+
+  // 2) System prompt: Anthropic wants top-level `system`, not a system message.
+  //    Promote any leading role:"system" messages into the top-level field.
+  if (Array.isArray(azureBody.messages) && azureBody.messages.length > 0) {
+    const systemMessages = [];
+    while (azureBody.messages.length > 0 && azureBody.messages[0]?.role === "system") {
+      systemMessages.push(azureBody.messages.shift());
+    }
+    if (systemMessages.length > 0) {
+      const systemText = systemMessages
+        .map((m) => (typeof m.content === "string"
+          ? m.content
+          : Array.isArray(m.content)
+            ? m.content.map((b) => b?.text || "").join("\n")
+            : ""))
+        .filter(Boolean)
+        .join("\n\n");
+      // Merge with any existing top-level system (string or array).
+      if (azureBody.system) {
+        const existing = typeof azureBody.system === "string"
+          ? azureBody.system
+          : Array.isArray(azureBody.system)
+            ? azureBody.system.map((s) => s?.text || s).join("\n")
+            : "";
+        azureBody.system = existing ? `${existing}\n\n${systemText}` : systemText;
+      } else {
+        azureBody.system = systemText;
+      }
+    }
+  }
+
+  // OAuth passthrough: prefer incoming Bearer token (Claude Pro/Max subscription)
+  // over a configured API key.
+  const incomingAuth = incomingHeaders?.authorization || incomingHeaders?.Authorization;
+
+  // 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
+  // request header from Claude Code verbatim — anthropic-beta, anthropic-version,
+  // user-agent, x-app, x-stainless-*, etc. Strip only hop-by-hop and proxy-control
+  // headers that would confuse fetch or leak Lynkr's identity.
+  const HOP_BY_HOP = new Set([
+    'host', 'connection', 'keep-alive', 'transfer-encoding', 'upgrade',
+    'proxy-authorization', 'proxy-authenticate', 'te', 'trailer',
+    'content-length', 'accept-encoding',
+  ]);
+  const LYNKR_INTERNAL = new Set([
+    'x-lynkr-tenant-id', 'x-lynkr-workspace', 'x-workspace-cwd',
+    'x-session-id', 'x-request-id',
+  ]);
+
+  const headers = {};
+  for (const [name, value] of Object.entries(incomingHeaders || {})) {
+    if (value == null) continue;
+    const lower = name.toLowerCase();
+    if (HOP_BY_HOP.has(lower)) continue;
+    if (LYNKR_INTERNAL.has(lower)) continue;
+    // Skip authorization here; we re-add it below with our preferred source.
+    if (lower === 'authorization') continue;
+    headers[name] = value;
+  }
+
+  // Always set these explicitly (override anything Claude Code sent that we
+  // don't want to forward verbatim).
+  headers["Content-Type"] = "application/json";
+  if (!headers["anthropic-version"] && !headers["Anthropic-Version"]) {
+    headers["anthropic-version"] = config.azureAnthropic.version ?? "2023-06-01";
+  }
+
+  if (incomingAuth && incomingAuth.startsWith('Bearer ')) {
+    headers["Authorization"] = incomingAuth;
+
+    // Claude Code OAuth Access Tokens (sk-ant-oat01-...) require the OAuth
+    // anthropic-beta header to be accepted by api.anthropic.com. Without it
+    // Anthropic responds 429 rate_limit_error with empty rate-limit headers
+    // and message:"Error" — its terse anti-proxy response. Ensure it's set.
+    const token = incomingAuth.slice('Bearer '.length);
+    if (token.startsWith('sk-ant-oat')) {
+      const existingBeta = headers['anthropic-beta'] || headers['Anthropic-Beta'];
+      const oauthBeta = 'oauth-2025-04-20';
+      if (!existingBeta) {
+        headers['anthropic-beta'] = oauthBeta;
+      } else if (!String(existingBeta).split(',').map(s => s.trim()).includes(oauthBeta)) {
+        headers['anthropic-beta'] = `${existingBeta},${oauthBeta}`;
+      }
+    }
+  } else if (config.azureAnthropic.apiKey) {
+    headers["x-api-key"] = config.azureAnthropic.apiKey;
+  } else {
+    throw new Error("Azure Anthropic requires authentication (OAuth token or API key)");
+  }
+
+  logger.debug({
+    forwardedHeaderKeys: Object.keys(headers),
+    targetModel: azureBody.model,
+  }, "Azure Anthropic: header forwarding");
+
+  // Don't retry 429 for Anthropic OAuth subscription. Claude Code has its own
+  // backoff and UI — retrying here just amplifies the burst and trips Anthropic's
+  // anti-abuse, keeping us 429ed for longer. Still retry 5xx (server faults).
+  const result = await performJsonRequest(
     config.azureAnthropic.endpoint,
-    { headers, body },
+    {
+      headers,
+      body: azureBody,
+      retryableStatusesOverride: [500, 502, 503, 504],
+    },
     "Azure Anthropic",
   );
+
+  if (!result?.ok) {
+    logger.warn({
+      status: result?.status,
+      error: result?.json?.error?.message || result?.text?.substring(0, 200),
+      model: azureBody.model,
+    }, "Azure Anthropic API error");
+  }
+
+  return result;
+}
+
+/**
+ * Lift any <think>...</think> tags leaked into text content blocks into proper
+ * Anthropic thinking content blocks. No-op if the response is already clean.
+ * Operates on the response shape returned by performJsonRequest (object/string).
+ */
+function _liftLeakedThinkingBlocks(response) {
+  // performJsonRequest may wrap the JSON body — find it.
+  const payload = response?.json ?? response?.body ?? response;
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.content)) {
+    return response;
+  }
+  const thinkRegex = /<think>([\s\S]*?)<\/think>/g;
+  const newContent = [];
+  let lifted = 0;
+  for (const block of payload.content) {
+    if (block?.type === "text" && typeof block.text === "string" && block.text.includes("<think>")) {
+      const thoughts = [];
+      let m;
+      while ((m = thinkRegex.exec(block.text)) !== null) thoughts.push(m[1].trim());
+      thinkRegex.lastIndex = 0;
+      const cleaned = block.text.replace(thinkRegex, "").trim();
+      const merged = thoughts.filter(Boolean).join("\n\n");
+      if (merged) {
+        newContent.push({ type: "thinking", thinking: merged });
+        lifted++;
+      }
+      if (cleaned) newContent.push({ type: "text", text: cleaned });
+    } else {
+      newContent.push(block);
+    }
+  }
+  if (lifted > 0) {
+    payload.content = newContent;
+    logger.debug({ lifted }, "Ollama: lifted leaked <think> tags into thinking content blocks");
+  }
+  return response;
 }
 
-async function invokeOllama(body) {
+async function invokeOllama(body, incomingHeaders = {}) {
   if (!config.ollama?.endpoint) {
     throw new Error("Ollama endpoint is not configured.");
   }
@@ -296,14 +487,30 @@ async function invokeOllama(body) {
       logger.debug({ keepAlive: ollamaBody.keep_alive }, "Ollama keep_alive configured");
     }
 
-    return performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama");
+    const response = await performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama");
+    // Even on the Anthropic-native path, Ollama Cloud's MiniMax M2.5 adapter
+    // sometimes leaks <think>...</think> as raw text inside content blocks
+    // instead of emitting a thinking content block (ollama/ollama#14220 was
+    // patched server-side 2026-02-13 but coverage is incomplete). Sanitize:
+    // pull leaked <think> tags out of text blocks and re-shape them as proper
+    // Anthropic thinking blocks before returning to Claude Code, otherwise
+    // Claude Code's loop sees stop_reason="end_turn" + empty text and halts.
+    return _liftLeakedThinkingBlocks(response);
   }
 
   // ---- Legacy path (Ollama < v0.14.0, /api/chat with OpenAI format) ----
   const endpoint = `${config.ollama.endpoint}/api/chat`;
   const headers = { "Content-Type": "application/json" };
 
-  // Convert Anthropic messages to Ollama format (content blocks → strings)
+  // Convert Anthropic messages to Ollama format.
+  //
+  // CRITICAL for MiniMax M2/M2.5 and other interleaved-thinking models:
+  // assistant `thinking` blocks MUST be preserved across turns (re-emitted as
+  // <think>...</think> in content) and `tool_use` blocks MUST become OpenAI
+  // tool_calls. Dropping these is the root cause of the 5-10-call stall — see
+  // https://www.minimax.io/news/why-is-interleaved-thinking-important-for-m2
+  // and HF model card: "Do not remove the <think>...</think> part, otherwise
+  // the model's performance will be negatively affected."
   const convertedMessages = [];
 
   if (body.system && typeof body.system === "string" && body.system.trim().length > 0) {
@@ -311,29 +518,98 @@ async function invokeOllama(body) {
   }
 
   (body.messages || []).forEach(msg => {
-    let content = msg.content;
-    if (Array.isArray(content)) {
-      content = content
-        .filter(block => block.type === 'text')
-        .map(block => block.text || '')
-        .join('\n');
+    const content = msg.content;
+
+    // Plain string content — pass through unchanged.
+    if (typeof content === "string") {
+      convertedMessages.push({ role: msg.role, content });
+      return;
+    }
+
+    if (!Array.isArray(content)) {
+      convertedMessages.push({ role: msg.role, content: "" });
+      return;
     }
-    convertedMessages.push({ role: msg.role, content: content || '' });
+
+    // Block-array content. Separate by block type.
+    if (msg.role === "assistant") {
+      const textParts = [];
+      const toolCalls = [];
+      for (const block of content) {
+        if (!block || typeof block !== "object") continue;
+        if (block.type === "thinking" && typeof block.thinking === "string" && block.thinking.trim()) {
+          // Re-emit thinking as <think>...</think> so MiniMax can re-read its own reasoning.
+          textParts.push(`<think>${block.thinking}</think>`);
+        } else if (block.type === "redacted_thinking" && typeof block.data === "string") {
+          textParts.push(`<think>${block.data}</think>`);
+        } else if (block.type === "text" && typeof block.text === "string") {
+          textParts.push(block.text);
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: typeof block.input === "string" ? block.input : JSON.stringify(block.input ?? {}),
+            },
+          });
+        }
+      }
+      const assistantMsg = { role: "assistant", content: textParts.join("\n") };
+      if (toolCalls.length > 0) assistantMsg.tool_calls = toolCalls;
+      convertedMessages.push(assistantMsg);
+      return;
+    }
+
+    // role === "user" — may contain tool_result blocks that need to become
+    // role:"tool" messages in OpenAI format (one per tool_result).
+    const userTextParts = [];
+    const toolResultMsgs = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      if (block.type === "text" && typeof block.text === "string") {
+        userTextParts.push(block.text);
+      } else if (block.type === "tool_result") {
+        let resultText = "";
+        if (typeof block.content === "string") {
+          resultText = block.content;
+        } else if (Array.isArray(block.content)) {
+          resultText = block.content
+            .map(c => (c?.type === "text" ? (c.text || "") : ""))
+            .join("\n");
+        }
+        toolResultMsgs.push({
+          role: "tool",
+          tool_call_id: block.tool_use_id,
+          content: resultText,
+        });
+      }
+    }
+    if (userTextParts.length > 0) {
+      convertedMessages.push({ role: "user", content: userTextParts.join("\n") });
+    }
+    for (const tm of toolResultMsgs) convertedMessages.push(tm);
   });
 
-  // Deduplicate consecutive messages with same role
+  // MERGE consecutive messages with same role (only user/assistant — never
+  // touch tool messages, each tool_call_id needs its own response).
+  //
+  // Previous behavior silently DROPPED the second message, which destroyed
+  // the user's prompt when Claude Code preceded it with a <system-reminder>
+  // user message — symptom: model said "I don't see a specific path".
   const deduplicated = [];
-  let lastRole = null;
   for (const msg of convertedMessages) {
-    if (msg.role === lastRole) {
+    const prev = deduplicated[deduplicated.length - 1];
+    if (prev && prev.role === msg.role && msg.role !== "tool" && !prev.tool_calls && !msg.tool_calls) {
+      const merged = [prev.content, msg.content].filter(Boolean).join("\n\n");
+      prev.content = merged;
       logger.debug({
-        skippedRole: msg.role,
-        contentPreview: msg.content.substring(0, 50)
-      }, 'Ollama: Skipping duplicate consecutive message with same role');
+        role: msg.role,
+        mergedLen: merged.length,
+      }, 'Ollama: Merged consecutive same-role messages');
       continue;
     }
     deduplicated.push(msg);
-    lastRole = msg.role;
   }
 
   const ollamaBody = {
@@ -363,7 +639,7 @@ async function invokeOllama(body) {
   return performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama");
 }
 
-async function invokeOpenRouter(body) {
+async function invokeOpenRouter(body, incomingHeaders = {}) {
   if (!config.openrouter?.endpoint || !config.openrouter?.apiKey) {
     throw new Error("OpenRouter endpoint or API key is not configured.");
   }
@@ -436,7 +712,7 @@ function detectAzureFormat(url) {
 }
 
 
-async function invokeAzureOpenAI(body) {
+async function invokeAzureOpenAI(body, incomingHeaders = {}) {
   if (!config.azureOpenAI?.endpoint || !config.azureOpenAI?.apiKey) {
     throw new Error("Azure OpenAI endpoint or API key is not configured.");
   }
@@ -480,10 +756,17 @@ async function invokeAzureOpenAI(body) {
   const isGpt5 = /gpt-5/i.test(azureDeployment);
   const maxTokensKey = isGpt5 ? "max_completion_tokens" : "max_tokens";
 
+  // gpt-5 family supports much larger output budgets than 16k. The previous
+  // 16384 hard cap caused silent mid-stream truncations on long "explain this
+  // codebase" responses (Azure returns finish_reason=length → Anthropic
+  // stop_reason=max_tokens → Claude Code halts and asks the user to continue).
+  // Raise to 32768 as a sane default; respect a higher client-supplied
+  // body.max_tokens up to that ceiling.
+  const azureOpenAIMaxOutput = 32768;
   const azureBody = {
     messages,
     temperature: body.temperature ?? 0.3,
-    [maxTokensKey]: Math.min(body.max_tokens ?? 16384, 16384),
+    [maxTokensKey]: Math.min(body.max_tokens ?? azureOpenAIMaxOutput, azureOpenAIMaxOutput),
     top_p: body.top_p ?? 1.0,
     stream: false,
     model: azureDeployment
@@ -841,7 +1124,7 @@ async function invokeAzureOpenAI(body) {
 }
 
 
-async function invokeOpenAI(body) {
+async function invokeOpenAI(body, incomingHeaders = {}) {
   if (!config.openai?.apiKey) {
     throw new Error("OpenAI API key is not configured.");
   }
@@ -922,7 +1205,7 @@ async function invokeOpenAI(body) {
   return performJsonRequest(endpoint, { headers, body: openAIBody }, "OpenAI");
 }
 
-async function invokeLlamaCpp(body) {
+async function invokeLlamaCpp(body, incomingHeaders = {}) {
   if (!config.llamacpp?.endpoint) {
     throw new Error("llama.cpp endpoint is not configured.");
   }
@@ -1033,7 +1316,7 @@ async function invokeLlamaCpp(body) {
   return performJsonRequest(endpoint, { headers, body: llamacppBody }, "llama.cpp");
 }
 
-async function invokeLMStudio(body) {
+async function invokeLMStudio(body, incomingHeaders = {}) {
   if (!config.lmstudio?.endpoint) {
     throw new Error("LM Studio endpoint is not configured.");
   }
@@ -1104,7 +1387,65 @@ async function invokeLMStudio(body) {
   return performJsonRequest(endpoint, { headers, body: lmstudioBody }, "LM Studio");
 }
 
-async function invokeBedrock(body) {
+/**
+ * Flatten an Anthropic-style content value into a plain string for the
+ * Bedrock Converse API.
+ *
+ * Prompt-cache injection (injectPromptCaching) rewrites string `system`
+ * fields and message `content` into arrays of `{ type, text, cache_control }`
+ * blocks. The Converse API has no `cache_control` concept and expects
+ * `system: [{ text: "<string>" }]` and message content blocks shaped as
+ * `{ text: "<string>" }`. Passing the injected array through unchanged would
+ * either drop the cache markers silently or nest an array under `text`,
+ * producing a ValidationException.
+ *
+ * @param {string|Array|undefined} value - String or array of content blocks
+ * @returns {string} Concatenated plain text
+ */
+function flattenContentToText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value
+      .map(block => {
+        if (typeof block === "string") return block;
+        if (block && typeof block === "object") return block.text || block.content || "";
+        return "";
+      })
+      .join("");
+  }
+  return String(value);
+}
+
+/**
+ * Normalize a request body for the Bedrock Converse API.
+ *
+ * Strips `cache_control` markers and flattens any array-shaped `system` /
+ * message `content` (left behind by prompt-cache injection) back into the
+ * plain strings the Converse API expects. Returns a shallow copy with a
+ * normalized `messages` array; the original body is not mutated.
+ *
+ * @param {Object} body - Anthropic-format request body
+ * @returns {Object} Body safe for Converse request construction
+ */
+function normalizeBodyForConverse(body) {
+  const normalized = { ...body };
+
+  if (normalized.system !== undefined) {
+    normalized.system = flattenContentToText(normalized.system);
+  }
+
+  if (Array.isArray(normalized.messages)) {
+    normalized.messages = normalized.messages.map(msg => ({
+      ...msg,
+      content: flattenContentToText(msg.content),
+    }));
+  }
+
+  return normalized;
+}
+
+async function invokeBedrock(body, incomingHeaders = {}) {
   // 1. Validate Bearer token
   if (!config.bedrock?.apiKey) {
     throw new Error(
@@ -1130,7 +1471,10 @@ async function invokeBedrock(body) {
     }, "=== INJECTING STANDARD TOOLS (Bedrock) ===");
   }
 
-  const bedrockBody = { ...body, tools: toolsToSend };
+  // Normalize away cache_control / array shapes that prompt-cache injection
+  // may have applied: the Converse API expects plain-string system and
+  // message content, not Anthropic cache_control blocks.
+  const bedrockBody = { ...normalizeBodyForConverse(body), tools: toolsToSend };
 
   // 4. Detect model family and convert format
   const modelId = body._tierModel || config.bedrock.modelId;
@@ -1295,7 +1639,7 @@ async function invokeBedrock(body) {
  * Z.AI offers GLM models through an Anthropic-compatible API at ~1/7 the cost.
  * Minimal transformation needed - mostly passthrough with model mapping.
  */
-async function invokeZai(body) {
+async function invokeZai(body, incomingHeaders = {}) {
   if (!config.zai?.apiKey) {
     throw new Error("Z.AI API key is not configured. Set ZAI_API_KEY in your .env file.");
   }
@@ -1485,7 +1829,7 @@ async function invokeZai(body) {
  * Moonshot offers Kimi models through an OpenAI-compatible chat completions API.
  * Uses native system role support (unlike Z.AI which merges into user message).
  */
-async function invokeMoonshot(body) {
+async function invokeMoonshot(body, incomingHeaders = {}) {
   if (!config.moonshot?.apiKey) {
     throw new Error("Moonshot API key is not configured. Set MOONSHOT_API_KEY in your .env file.");
   }
@@ -1735,7 +2079,7 @@ function sanitizeSchemaForGemini(schema) {
  * Supports Google Gemini models through Vertex AI.
  * Converts Anthropic format to Gemini format and back.
  */
-async function invokeVertex(body) {
+async function invokeVertex(body, incomingHeaders = {}) {
   const apiKey = config.vertex?.apiKey;
 
   if (!apiKey) {
@@ -1991,7 +2335,7 @@ function convertGeminiToAnthropic(response, requestedModel) {
   };
 }
 
-async function invokeCodex(body) {
+async function invokeCodex(body, incomingHeaders = {}) {
   const { getCodexProcess } = require("./codex-process");
   const { convertAnthropicToCodexPrompt, convertCodexResponseToAnthropic } = require("./codex-utils");
 
@@ -2098,12 +2442,77 @@ function captureResponseText(resultJson) {
   return text ? text.slice(0, TELEMETRY_TEXT_MAXLEN) : null;
 }
 
+// Strip prior-turn Lynkr routing badges from assistant content[]. The badge
+// is injected into the response stream as a content block (see router.js paths
+// near lines 213, 1078, 1264, 1402) so the TUI renders it. Claude Code persists
+// content[] into the session transcript and resubmits it as conversation
+// history on each subsequent request, so without this strip the badge text
+// dominates the model's view of its own prior turns — which breaks M2.5's
+// interleaved-thinking continuity (HF model card requires preserved <think>
+// blocks across turns; resubmitted badges replace them and Tau²/BrowseComp
+// scores collapse). Render-side injection stays untouched; this only sanitises
+// what we forward upstream.
+// Matches a Lynkr badge string anchored at the start, e.g.
+//   "*[Lynkr] SIMPLE → minimax-m2.5:cloud (ollama) · score 21*\n\n\n"
+// The badge format never contains an inner `*` until the closing one, so a
+// non-greedy lazy match is unnecessary — match up to (and including) the
+// closing `*` plus trailing whitespace.
+const LYNKR_BADGE_PREFIX_RE = /^\*\[Lynkr\][^*\n]*\*\s*/;
+
+function stripLynkrBadges(messages) {
+  if (!Array.isArray(messages)) return messages;
+  let mutated = false;
+  let badgeCount = 0;
+  const out = messages.map((msg) => {
+    if (msg?.role !== 'assistant') return msg;
+
+    // String content variant — assistant.content is a bare string. This is
+    // what the orchestrator's OpenAI-format response branch produces, and
+    // it's where badges actually leak in the Ollama agent loop.
+    if (typeof msg.content === 'string') {
+      if (!LYNKR_BADGE_PREFIX_RE.test(msg.content)) return msg;
+      const stripped = msg.content.replace(LYNKR_BADGE_PREFIX_RE, '');
+      mutated = true;
+      badgeCount++;
+      return { ...msg, content: stripped };
+    }
+
+    // Array content variant — Anthropic-format responses keep content as an
+    // array of blocks.
+    if (Array.isArray(msg.content)) {
+      const before = msg.content.length;
+      const filtered = msg.content.filter((b) =>
+        !(b?.type === 'text' && typeof b.text === 'string' && LYNKR_BADGE_PREFIX_RE.test(b.text))
+      );
+      if (filtered.length === before) return msg;
+      mutated = true;
+      badgeCount += before - filtered.length;
+      // Anthropic rejects empty content[]; substitute a benign placeholder for
+      // turns where the badge was the entire assistant text.
+      return { ...msg, content: filtered.length ? filtered : [{ type: 'text', text: '' }] };
+    }
+
+    return msg;
+  });
+  return mutated ? out : messages;
+}
+
 async function invokeModel(body, options = {}) {
   const { determineProviderSmart, isFallbackEnabled, getFallbackProvider } = require("./routing");
   const metricsCollector = getMetricsCollector();
   const registry = getCircuitBreakerRegistry();
   const healthTracker = getHealthTracker();
 
+  // Extract incoming headers for OAuth passthrough
+  const incomingHeaders = options.headers || {};
+
+  // Sanitise inbound history before any provider sees it. See stripLynkrBadges
+  // comment for the M2.5-collapse rationale. Safe for all providers — the badge
+  // is never legitimate prior-turn content.
+  if (Array.isArray(body?.messages)) {
+    body = { ...body, messages: stripLynkrBadges(body.messages) };
+  }
+
   // Determine provider via async tier routing
   // Thread workspace for code-graph integration (from X-Lynkr-Workspace header or body._workspace)
   const workspace = body._workspace || options.workspace || null;
@@ -2124,6 +2533,13 @@ async function invokeModel(body, options = {}) {
   const { injectPromptCaching } = require('./prompt-cache-injection');
   injectPromptCaching(body, initialProvider);
 
+  // Always-on markdown formatting guard. Stops formatting-weak backends
+  // (Moonshot/Kimi, Ollama, etc.) from emitting mangled ASCII box-drawing
+  // "diagrams". Keyed off the routing-resolved provider/model; skipped for
+  // Claude-family backends which already format cleanly.
+  const { injectFormatGuard } = require('../context/output-format-guard');
+  injectFormatGuard(body, { provider: initialProvider, model: tierSelectedModel });
+
   // Build routing decision object for response headers
   const routingDecision = {
     provider: initialProvider,
@@ -2210,31 +2626,31 @@ async function invokeModel(body, options = {}) {
     // Try initial provider with circuit breaker
     const result = await breaker.execute(async () => {
       if (initialProvider === "azure-openai") {
-        return await invokeAzureOpenAI(body);
+        return await invokeAzureOpenAI(body, incomingHeaders);
       } else if (initialProvider === "azure-anthropic") {
-        return await invokeAzureAnthropic(body);
+        return await invokeAzureAnthropic(body, incomingHeaders);
       } else if (initialProvider === "ollama") {
-        return await invokeOllama(body);
+        return await invokeOllama(body, incomingHeaders);
       } else if (initialProvider === "openrouter") {
-        return await invokeOpenRouter(body);
+        return await invokeOpenRouter(body, incomingHeaders);
       } else if (initialProvider === "openai") {
-        return await invokeOpenAI(body);
+        return await invokeOpenAI(body, incomingHeaders);
       } else if (initialProvider === "llamacpp") {
-        return await invokeLlamaCpp(body);
+        return await invokeLlamaCpp(body, incomingHeaders);
       } else if (initialProvider === "lmstudio") {
-        return await invokeLMStudio(body);
+        return await invokeLMStudio(body, incomingHeaders);
       } else if (initialProvider === "bedrock") {
-        return await invokeBedrock(body);
+        return await invokeBedrock(body, incomingHeaders);
       } else if (initialProvider === "zai") {
-        return await invokeZai(body);
+        return await invokeZai(body, incomingHeaders);
       } else if (initialProvider === "vertex") {
-        return await invokeVertex(body);
+        return await invokeVertex(body, incomingHeaders);
       } else if (initialProvider === "moonshot") {
-        return await invokeMoonshot(body);
+        return await invokeMoonshot(body, incomingHeaders);
       } else if (initialProvider === "codex") {
-        return await invokeCodex(body);
+        return await invokeCodex(body, incomingHeaders);
       }
-      return await invokeDatabricks(body);
+      return await invokeDatabricks(body, incomingHeaders);
     });
 
     // Record success metrics
@@ -2323,6 +2739,71 @@ async function invokeModel(body, options = {}) {
     healthTracker.recordFailure(initialProvider, err, err.status);
     getLatencyTracker().record(initialProvider, routingDecision?.model, failLatency);
 
+    // Tier-aware escalate-then-demote fallback (TIER_FALLBACK_ENABLED).
+    // On failure, try a MORE capable tier first (climb toward REASONING); only
+    // if every higher tier is unavailable do we fall downward to SIMPLE/local.
+    // Runs before the flat global fallback below and is never silent.
+    if (config.tierFallback?.enabled && !options._tierFallbackInner && routingDecision.tier) {
+      const { getFallbackChain } = require("../routing/tier-fallback");
+      const chain = getFallbackChain(routingDecision.tier);
+      for (const cand of chain) {
+        try {
+          logger.warn({
+            fromTier: routingDecision.tier,
+            fromProvider: initialProvider,
+            toTier: cand.tier,
+            toProvider: cand.provider,
+            toModel: cand.model,
+            direction: cand.direction,
+          }, "[TierFallback] Primary tier failed — attempting tier fallback");
+
+          const attempt = await invokeModel(
+            { ...body, _tierModel: cand.model },
+            {
+              forceProvider: cand.provider,
+              _tierFallbackInner: true,
+              disableFallback: true,
+              _cascadeInner: true,
+              workspace,
+              tenantPolicy,
+            }
+          );
+
+          metricsCollector.recordFallbackAttempt(initialProvider, cand.provider, "tier_fallback");
+          logger.warn({
+            servedTier: cand.tier,
+            servedProvider: cand.provider,
+            fromTier: routingDecision.tier,
+            direction: cand.direction,
+          }, "[TierFallback] Served by tier fallback");
+
+          return {
+            ...attempt,
+            actualProvider: cand.provider,
+            routingDecision: {
+              ...routingDecision,
+              provider: cand.provider,
+              model: cand.model,
+              servedTier: cand.tier,
+              fromTier: routingDecision.tier,
+              fallback: true,
+              fallbackDirection: cand.direction,
+              method: "tier_fallback",
+            },
+          };
+        } catch (innerErr) {
+          logger.warn(
+            { toProvider: cand.provider, error: innerErr.message },
+            "[TierFallback] Candidate failed, trying next"
+          );
+        }
+      }
+      logger.warn(
+        { fromTier: routingDecision.tier },
+        "[TierFallback] All tier candidates exhausted — falling through"
+      );
+    }
+
     // Check if we should fallback (any provider can fall back, not just ollama)
     const shouldFallback =
       isFallbackEnabled() &&
@@ -2390,23 +2871,23 @@ async function invokeModel(body, options = {}) {
       // Execute fallback
       const fallbackResult = await fallbackBreaker.execute(async () => {
         if (fallbackProvider === "azure-openai") {
-          return await invokeAzureOpenAI(body);
+          return await invokeAzureOpenAI(body, incomingHeaders);
         } else if (fallbackProvider === "azure-anthropic") {
-          return await invokeAzureAnthropic(body);
+          return await invokeAzureAnthropic(body, incomingHeaders);
         } else if (fallbackProvider === "openrouter") {
-          return await invokeOpenRouter(body);
+          return await invokeOpenRouter(body, incomingHeaders);
         } else if (fallbackProvider === "openai") {
-          return await invokeOpenAI(body);
+          return await invokeOpenAI(body, incomingHeaders);
         } else if (fallbackProvider === "llamacpp") {
-          return await invokeLlamaCpp(body);
+          return await invokeLlamaCpp(body, incomingHeaders);
         } else if (fallbackProvider === "zai") {
-          return await invokeZai(body);
+          return await invokeZai(body, incomingHeaders);
         } else if (fallbackProvider === "vertex") {
-          return await invokeVertex(body);
+          return await invokeVertex(body, incomingHeaders);
         } else if (fallbackProvider === "moonshot") {
-          return await invokeMoonshot(body);
+          return await invokeMoonshot(body, incomingHeaders);
         }
-        return await invokeDatabricks(body);
+        return await invokeDatabricks(body, incomingHeaders);
       });
 
       const fallbackLatency = Date.now() - fallbackStart;
@@ -2578,5 +3059,7 @@ function destroyHttpAgents() {
 
 module.exports = {
   invokeModel,
+  stripLynkrBadges,
   destroyHttpAgents,
+  normalizeBodyForConverse,
 };