lynkr 9.7.2 → 9.9.0

package/src/clients/databricks.js

@@ -13,10 +13,12 @@ const { convertAnthropicToolsToOpenRouter } = require("./openrouter-utils");
 const {
   detectModelFamily
 } = require("./bedrock-utils");
-const { getGPTSystemPromptAddendum } = require("./gpt-utils");
 const telemetry = require("../routing/telemetry");
 const { scoreResponseQuality } = require("../routing/quality-scorer");
 const { getLatencyTracker } = require("../routing/latency-tracker");
+// WS5.4 — feedback loop. `recordOutcome` runs on setImmediate and never
+// throws; every failure is captured into the degradation registry.
+const { recordOutcome: recordFeedbackOutcome } = require("../routing/feedback");
 
 
 
@@ -51,8 +53,33 @@ const httpsAgent = new https.Agent({
   keepAliveMsecs: 30000,
 });
 
+/**
+ * Strip Lynkr's internal underscore-prefixed fields from a body about to be
+ * sent upstream. Every provider validates its request body (Anthropic and
+ * Ollama Cloud both use Pydantic and reject unknown keys with "Extra inputs
+ * are not permitted"), so any leak of _sessionId / _forceProvider / _tierModel
+ * etc. into the outbound JSON hard-fails the request.
+ *
+ * This is a defense-in-depth strip at the last-hop chokepoint. Individual
+ * invoke functions already whitelist their outbound bodies, but doing this
+ * once here means no future codepath (or spread of `{...body}` in a new
+ * provider) can regress the invariant.
+ */
+function _stripInternalFields(body) {
+  if (!body || typeof body !== 'object') return body;
+  let cleaned = null;
+  for (const key of Object.keys(body)) {
+    if (key.startsWith('_')) {
+      if (!cleaned) cleaned = { ...body };
+      delete cleaned[key];
+    }
+  }
+  return cleaned || body;
+}
+
 async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride }, providerLabel) {
   const agent = url.startsWith('https:') ? httpsAgent : httpAgent;
+  body = _stripInternalFields(body);
   const isStreaming = body.stream === true;
 
   // Streaming requests can't be retried, so handle them directly
@@ -399,6 +426,49 @@ function _liftLeakedThinkingBlocks(response) {
   return response;
 }
 
+/**
+ * Ollama proxies cloud-provider errors as a JSON body that can arrive with
+ * HTTP 200 (e.g. quota exhaustion). Unthrown, that serves as an empty
+ * message and no fallback fires — so detect and throw, handing the request
+ * to invokeModel's tier-fallback catch. On streamed requests the daemon
+ * answers errors with JSON instead of SSE, so a json content-type on a
+ * streaming response IS the error case.
+ */
+async function _throwIfOllamaError(response, modelName) {
+  if (!response) return response;
+
+  // Streamed request answered with JSON → provider error, not a stream.
+  if (response.stream && /json/i.test(response.contentType || "")) {
+    let text = "";
+    try {
+      for await (const chunk of response.stream) text += chunk;
+    } catch { /* partial body is fine — we're throwing anyway */ }
+    let j = null;
+    try { j = JSON.parse(text); } catch { /* non-JSON error body */ }
+    // A JSON content-type that is actually a valid non-streamed Anthropic
+    // message would be unusual; treat anything without content blocks as error.
+    if (!Array.isArray(j?.content)) {
+      const msg = (typeof j?.error === "string" ? j.error : j?.error?.message) || text.slice(0, 200) || `HTTP ${response.status}`;
+      const err = new Error(`Ollama error for ${modelName}: ${msg}`);
+      err.status = Number(j?.StatusCode) >= 400 ? Number(j.StatusCode) : (response.ok ? 502 : response.status);
+      throw err;
+    }
+    // Valid message that happened to be JSON — reshape as non-streamed result.
+    return { ok: true, status: response.status, json: j, text, contentType: response.contentType, headers: response.headers };
+  }
+
+  const j = response.json;
+  const errMsg = typeof j?.error === "string" ? j.error
+    : typeof j?.error?.message === "string" ? j.error.message : null;
+  const embeddedStatus = Number(j?.StatusCode);
+  if (!response.ok || errMsg || (Number.isFinite(embeddedStatus) && embeddedStatus >= 400)) {
+    const err = new Error(`Ollama error for ${modelName}: ${errMsg || `HTTP ${response.status}`}`);
+    err.status = Number.isFinite(embeddedStatus) && embeddedStatus >= 400 ? embeddedStatus : response.status;
+    throw err;
+  }
+  return response;
+}
+
 async function invokeOllama(body, incomingHeaders = {}) {
   if (!config.ollama?.endpoint) {
     throw new Error("Ollama endpoint is not configured.");
@@ -415,7 +485,6 @@ async function invokeOllama(body, incomingHeaders = {}) {
   const supportsTools = await checkOllamaToolSupport(modelName);
   const injectToolsOllama = process.env.INJECT_TOOLS_OLLAMA !== "false";
 
-  // Determine tools to send
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
@@ -447,7 +516,7 @@ async function invokeOllama(body, incomingHeaders = {}) {
     toolCount,
     toolsInjected,
     supportsTools,
-    toolNames: (Array.isArray(toolsToSend) && toolsToSend.length > 0) ? toolsToSend.map(t => t.name) : []
+    toolNames: (Array.isArray(toolsToSend) && toolsToSend.length > 0) ? toolsToSend.map(t => t.name || t.function?.name) : []
   }, `=== Ollama STANDARD TOOLS INJECTION for ${config.ollama.model} === ${logMessage}`);
 
   // ---- Anthropic-native path (Ollama v0.14.0+) ----
@@ -458,12 +527,21 @@ async function invokeOllama(body, incomingHeaders = {}) {
       "anthropic-version": "2023-06-01",
     };
 
-    // Build body with only valid Anthropic Messages API fields
+    // Build body with only valid Anthropic Messages API fields.
+    // max_tokens floor: thinking models spend 200-400 tokens reasoning
+    // before any text; small client budgets die mid-think and return
+    // stop_reason=max_tokens with zero text.
+    const minMaxTokens = Number(process.env.LYNKR_OLLAMA_MIN_MAX_TOKENS) || 1536;
+    // Buffer ollama responses (opt out: LYNKR_OLLAMA_BUFFER_RESPONSES=false):
+    // thinking models stream reasoning deltas Claude Code renders as dead
+    // air. Buffered responses go through thinking-block cleanup + SSE
+    // synthesis, and become verifiable by the cascade (streams bypass it).
+    const bufferOllama = process.env.LYNKR_OLLAMA_BUFFER_RESPONSES !== "false";
     const ollamaBody = {
       model: modelName,
       messages: body.messages,
-      max_tokens: body.max_tokens || 16384,
-      stream: body.stream ?? false,
+      max_tokens: Math.max(body.max_tokens || 16384, minMaxTokens),
+      stream: bufferOllama ? false : (body.stream ?? false),
     };
 
     if (body.system) ollamaBody.system = body.system;
@@ -487,7 +565,10 @@ async function invokeOllama(body, incomingHeaders = {}) {
       logger.debug({ keepAlive: ollamaBody.keep_alive }, "Ollama keep_alive configured");
     }
 
-    const response = await performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama");
+    const response = await _throwIfOllamaError(
+      await performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama"),
+      modelName,
+    );
     // 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
@@ -636,7 +717,10 @@ async function invokeOllama(body, incomingHeaders = {}) {
     ollamaBody.tools = convertAnthropicToolsToOllama(toolsToSend);
   }
 
-  return performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama");
+  return _throwIfOllamaError(
+    await performJsonRequest(endpoint, { headers, body: ollamaBody }, "Ollama"),
+    modelName,
+  );
 }
 
 async function invokeOpenRouter(body, incomingHeaders = {}) {
@@ -657,7 +741,6 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
     "X-Title": "Claude-Ollama-Proxy"
   };
 
-  // Convert messages and handle system message
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
   // Anthropic uses separate 'system' field, OpenAI needs it as first message
@@ -682,7 +765,6 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
   let toolsInjected = false;
 
   if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
-    // Client didn't send tools (likely passthrough mode) - inject standard Claude Code tools
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -696,7 +778,7 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
     openRouterBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
     logger.debug({
       toolCount: toolsToSend.length,
-      toolNames: toolsToSend.map(t => t.name),
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "Sending tools to OpenRouter");
   }
@@ -704,6 +786,69 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
   return performJsonRequest(endpoint, { headers, body: openRouterBody }, "OpenRouter");
 }
 
+// Eden AI is an OpenAI-compatible gateway (provider/model naming, EU/GDPR).
+// It speaks the same wire format as OpenRouter, so this mirrors invokeOpenRouter
+// and reuses the shared Anthropic<->OpenAI converters.
+async function invokeEdenAI(body, incomingHeaders = {}) {
+  if (!config.edenai?.endpoint || !config.edenai?.apiKey) {
+    throw new Error("Eden AI endpoint or API key is not configured.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = config.edenai.endpoint;
+  const headers = {
+    "Authorization": `Bearer ${config.edenai.apiKey}`,
+    "Content-Type": "application/json"
+  };
+
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  if (body.system) {
+    messages.unshift({
+      role: "system",
+      content: body.system
+    });
+  }
+
+  const edenAIBody = {
+    model: body._suggestionModeModel || body._tierModel || config.edenai.model,
+    messages,
+    temperature: body.temperature ?? 0.7,
+    max_tokens: body.max_tokens ?? 16384,
+    top_p: body.top_p ?? 1.0,
+    stream: body.stream ?? false
+  };
+
+  // Add tools - inject standard tools if client didn't send any (passthrough mode)
+  let toolsToSend = body.tools;
+  let toolsInjected = false;
+
+  if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
+    toolsToSend = STANDARD_TOOLS;
+    toolsInjected = true;
+    logger.debug({
+      injectedToolCount: STANDARD_TOOLS.length,
+      injectedToolNames: STANDARD_TOOL_NAMES,
+      reason: "Client did not send tools (passthrough mode)"
+    }, "=== INJECTING STANDARD TOOLS (Eden AI) ===");
+  }
+
+  if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
+    edenAIBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
+    logger.debug({
+      toolCount: toolsToSend.length,
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
+      toolsInjected
+    }, "Sending tools to Eden AI");
+  }
+
+  return performJsonRequest(endpoint, { headers, body: edenAIBody }, "EdenAI");
+}
+
 function detectAzureFormat(url) {
   if (url.includes("/openai/responses")) return "responses";
   if (url.includes("/models/")) return "models";
@@ -722,7 +867,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
     convertAnthropicMessagesToOpenRouter
   } = require("./openrouter-utils");
 
-  // Azure OpenAI URL format
   const endpoint = config.azureOpenAI.endpoint;
   const format = detectAzureFormat(endpoint);
 
@@ -738,10 +882,8 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
     headers["api-key"] = config.azureOpenAI.apiKey;
   }
 
-  // Convert messages and handle system message
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
-  // Anthropic uses separate 'system' field, OpenAI needs it as first message
   if (body.system) {
     messages.unshift({
       role: "system",
@@ -749,9 +891,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
     });
   }
 
-  // System prompt injection disabled - breaks model response
-  // Tool guidance now provided via tool descriptions instead
-
   const azureDeployment = body._suggestionModeModel || body._tierModel || config.azureOpenAI.deployment || "";
   const isGpt5 = /gpt-5/i.test(azureDeployment);
   const maxTokensKey = isGpt5 ? "max_completion_tokens" : "max_tokens";
@@ -777,7 +916,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
   let toolsInjected = false;
 
   if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
-    // Client didn't send tools (likely passthrough mode) - inject standard Claude Code tools
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -789,11 +927,11 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
 
   if (Array.isArray(toolsToSend) && toolsToSend.length > 0) {
     azureBody.tools = convertAnthropicToolsToOpenRouter(toolsToSend);
-    azureBody.parallel_tool_calls = true;  // Enable parallel tool calls
+    azureBody.parallel_tool_calls = true;
     azureBody.tool_choice = "auto";  // Explicitly enable tool use (helps GPT models understand they should use tools)
     logger.debug({
       toolCount: toolsToSend.length,
-      toolNames: toolsToSend.map(t => t.name),
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected,
       hasSystemMessage: !!body.system,
       messageCount: messages.length,
@@ -891,7 +1029,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
       let cleaned = content.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, '');
       // Remove the continuation marker that orchestrator adds
       cleaned = cleaned.replace(/---\s*IMPORTANT:\s*Focus on and respond ONLY to my most recent request[^\n]*/gi, '');
-      // Trim whitespace
       return cleaned.trim();
     };
 
@@ -918,8 +1055,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         if (Array.isArray(msg.content)) {
           for (const block of msg.content) {
             if (block.type === "tool_result") {
-              // Convert tool_result to function_call_output
-              // Use tool_use_id if available, otherwise pop from pending call IDs
               const callId = block.tool_use_id || pendingCallIds.shift() || `call_${Date.now()}`;
               responsesInput.push({
                 type: "function_call_output",
@@ -998,7 +1133,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         }
       } else if (msg.role === "tool") {
         // Tool results become function_call_output
-        // Use tool_call_id if available, otherwise pop from pending call IDs
         const callId = msg.tool_call_id || pendingCallIds.shift() || `call_${Date.now()}`;
         responsesInput.push({
           type: "function_call_output",
@@ -1029,9 +1163,25 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
     if (result.ok && result.json?.output) {
       const outputArray = result.json.output || [];
 
-      // Find message output (contains text content)
-      const messageOutput = outputArray.find(o => o.type === "message");
-      const textContent = messageOutput?.content?.find(c => c.type === "output_text")?.text || "";
+      // Extract text across ALL message outputs and content-item shapes
+      // ("output_text", "text", string content) — a single-shape find
+      // silently returns "" and the whole answer vanishes.
+      const messageOutputs = outputArray.filter(o => o.type === "message");
+      const messageOutput = messageOutputs[0];
+      const textContent = messageOutputs.map(mo => {
+        if (typeof mo.content === "string") return mo.content;
+        if (!Array.isArray(mo.content)) return "";
+        return mo.content
+          .filter(c => (c.type === "output_text" || c.type === "text") && typeof c.text === "string")
+          .map(c => c.text)
+          .join("");
+      }).join("\n").trim() || "";
+      if (!textContent && messageOutputs.length > 0) {
+        logger.warn({
+          contentShapes: messageOutputs.map(mo =>
+            Array.isArray(mo.content) ? mo.content.map(c => c.type) : typeof mo.content),
+        }, "[AzureResponses] Message output present but no text extracted — unknown content shape");
+      }
 
       // Find function_call outputs (tool calls are separate items in output array)
       const rawToolCalls = outputArray
@@ -1075,7 +1225,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         toolCallNames: toolCalls.map(tc => tc.function.name)
       }, "Parsing Responses API output");
 
-      // Convert to Chat Completions format
       result.json = {
         id: result.json.id,
         object: "chat.completion",
@@ -1090,7 +1239,14 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
           },
           finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
         }],
-        usage: result.json.usage
+        // Responses API usage is {input,output}_tokens; downstream reads
+        // Chat Completions' {prompt,completion}_tokens.
+        usage: result.json.usage ? {
+          prompt_tokens: result.json.usage.prompt_tokens ?? result.json.usage.input_tokens ?? 0,
+          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)),
+        } : undefined
       };
 
       logger.debug({
@@ -1099,7 +1255,6 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         toolCallCount: toolCalls.length
       }, "Converted Responses API to Chat Completions format");
 
-      // Now convert from Chat Completions format to Anthropic format
       const anthropicJson = convertOpenAIToAnthropic(result.json);
       logger.debug({
         anthropicContentTypes: anthropicJson.content?.map(c => c.type),
@@ -1140,15 +1295,12 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
     "Content-Type": "application/json",
   };
 
-  // Add organization header if configured
   if (config.openai.organization) {
     headers["OpenAI-Organization"] = config.openai.organization;
   }
 
-  // Convert messages and handle system message
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
-  // Anthropic uses separate 'system' field, OpenAI needs it as first message
   if (body.system) {
     messages.unshift({
       role: "system",
@@ -1156,8 +1308,6 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
     });
   }
 
-  // System prompt injection disabled - breaks model response
-
   const openAIBody = {
     model: body._suggestionModeModel || body._tierModel || config.openai.model || "gpt-4o",
     messages,
@@ -1172,7 +1322,6 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
   let toolsInjected = false;
 
   if (!Array.isArray(toolsToSend) || toolsToSend.length === 0) {
-    // Client didn't send tools (likely passthrough mode) - inject standard Claude Code tools
     toolsToSend = STANDARD_TOOLS;
     toolsInjected = true;
     logger.debug({
@@ -1188,7 +1337,7 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
     openAIBody.tool_choice = "auto";  // Let the model decide when to use tools
     logger.debug({
       toolCount: toolsToSend.length,
-      toolNames: toolsToSend.map(t => t.name),
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "=== SENDING TOOLS TO OPENAI ===");
   }
@@ -1225,10 +1374,8 @@ async function invokeLlamaCpp(body, incomingHeaders = {}) {
     headers["Authorization"] = `Bearer ${config.llamacpp.apiKey}`;
   }
 
-  // Convert messages to OpenAI format
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
-  // Handle system message
   if (body.system) {
     messages.unshift({ role: "system", content: body.system });
   }
@@ -1290,7 +1437,7 @@ async function invokeLlamaCpp(body, incomingHeaders = {}) {
     llamacppBody.tool_choice = "auto";
     logger.debug({
       toolCount: toolsToSend.length,
-      toolNames: toolsToSend.map(t => t.name),
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "=== SENDING TOOLS TO LLAMA.CPP ===");
   }
@@ -1336,10 +1483,8 @@ async function invokeLMStudio(body, incomingHeaders = {}) {
     headers["Authorization"] = `Bearer ${config.lmstudio.apiKey}`;
   }
 
-  // Convert messages to OpenAI format
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
-  // Handle system message
   if (body.system) {
     messages.unshift({ role: "system", content: body.system });
   }
@@ -1371,7 +1516,7 @@ async function invokeLMStudio(body, incomingHeaders = {}) {
     lmstudioBody.tool_choice = "auto";
     logger.debug({
       toolCount: toolsToSend.length,
-      toolNames: toolsToSend.map(t => t.name),
+      toolNames: toolsToSend.map(t => t.name || t.function?.name),
       toolsInjected
     }, "=== SENDING TOOLS TO LM STUDIO ===");
   }
@@ -1446,7 +1591,6 @@ function normalizeBodyForConverse(body) {
 }
 
 async function invokeBedrock(body, incomingHeaders = {}) {
-  // 1. Validate Bearer token
   if (!config.bedrock?.apiKey) {
     throw new Error(
       "AWS Bedrock requires AWS_BEDROCK_API_KEY (Bearer token). " +
@@ -1457,7 +1601,7 @@ async function invokeBedrock(body, incomingHeaders = {}) {
   const bearerToken = config.bedrock.apiKey;
   logger.debug({ authMethod: "Bearer Token" }, "=== BEDROCK AUTH ===");
 
-  // 2. Inject standard tools if needed
+  // Inject standard tools if needed
   let toolsToSend = body.tools;
   let toolsInjected = false;
 
@@ -1476,7 +1620,6 @@ async function invokeBedrock(body, incomingHeaders = {}) {
   // 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;
   const modelFamily = detectModelFamily(modelId);
 
@@ -1488,7 +1631,7 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     streaming: body.stream || false,
   }, "=== BEDROCK REQUEST (FETCH) ===");
 
-  // 5. Convert to Bedrock Converse API format (simpler, more universal)
+  // Convert to Bedrock Converse API format (simpler, more universal)
   // Bedrock Converse API only allows 'user' and 'assistant' roles in messages array
 
   // Extract system messages from messages array (if any)
@@ -1496,7 +1639,7 @@ async function invokeBedrock(body, incomingHeaders = {}) {
 
   const converseBody = {
     messages: bedrockBody.messages
-      .filter(msg => msg.role !== 'system') // Filter out system messages
+      .filter(msg => msg.role !== 'system')
       .map(msg => ({
         role: msg.role,
         content: Array.isArray(msg.content)
@@ -1516,7 +1659,6 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     converseBody.system = [{ text: systemContent }];
   }
 
-  // Add inference config
   if (bedrockBody.max_tokens) {
     converseBody.inferenceConfig = {
       maxTokens: bedrockBody.max_tokens,
@@ -1525,7 +1667,6 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     };
   }
 
-  // Add tools if present
   if (bedrockBody.tools && bedrockBody.tools.length > 0) {
     converseBody.toolConfig = {
       tools: bedrockBody.tools.map(tool => ({
@@ -1540,7 +1681,6 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     };
   }
 
-  // 6. Construct Bedrock Converse API endpoint
   const path = `/model/${modelId}/converse`;
   const host = `bedrock-runtime.${config.bedrock.region}.amazonaws.com`;
   const endpoint = `https://${host}${path}`;
@@ -1553,21 +1693,19 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     messageCount: converseBody.messages.length
   }, "=== BEDROCK CONVERSE API REQUEST ===");
 
-  // 7. Prepare request headers with Bearer token
   const requestHeaders = {
     "Content-Type": "application/json",
     "Authorization": `Bearer ${bearerToken}`
   };
 
-  // 8. Make the Converse API request
   try {
     const response = await performJsonRequest(endpoint, {
       headers: requestHeaders,
-      body: converseBody  // Pass object, performJsonRequest will stringify it
-    }, "Bedrock");  // Add provider label for logging
+      body: converseBody
+    }, "Bedrock");
 
     if (!response.ok) {
-      const errorText = response.text;  // Use property, not method
+      const errorText = response.text;
       logger.error({
         status: response.status,
         error: errorText
@@ -1576,7 +1714,7 @@ async function invokeBedrock(body, incomingHeaders = {}) {
     }
 
     // Parse Converse API response (already parsed by performJsonRequest)
-    const converseResponse = response.json;  // Use property, not method
+    const converseResponse = response.json;
 
     logger.debug({
       stopReason: converseResponse.stopReason,
@@ -1585,7 +1723,6 @@ async function invokeBedrock(body, incomingHeaders = {}) {
       hasToolUse: !!converseResponse.output?.message?.content?.some(c => c.toolUse)
     }, "=== BEDROCK CONVERSE API RESPONSE ===");
 
-    // Convert Converse API response to Anthropic format
     const message = converseResponse.output.message;
     const anthropicResponse = {
       id: `bedrock-${Date.now()}`,
@@ -1671,7 +1808,6 @@ async function invokeZai(body, incomingHeaders = {}) {
       convertAnthropicMessagesToOpenRouter
     } = require("./openrouter-utils");
 
-    // Convert messages using existing utility
     let messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
     // Extract system content from body.system OR from system messages in the array
@@ -1687,7 +1823,6 @@ async function invokeZai(body, incomingHeaders = {}) {
     const filteredMessages = [];
     for (const msg of messages) {
       if (msg.role === "system") {
-        // Append system message content to systemContent
         if (msg.content) {
           systemContent = systemContent ? `${systemContent}\n${msg.content}` : msg.content;
         }
@@ -1714,7 +1849,6 @@ async function invokeZai(body, incomingHeaders = {}) {
       messages.push({ role: "user", content: systemContent });
     }
 
-    // Convert tools if present
     let tools = undefined;
     if (Array.isArray(body.tools) && body.tools.length > 0) {
       tools = convertAnthropicToolsToOpenRouter(body.tools);
@@ -1728,14 +1862,12 @@ async function invokeZai(body, incomingHeaders = {}) {
       stream: body.stream,
     };
 
-    // Only add tools if present
     if (tools && tools.length > 0) {
       zaiBody.tools = tools;
       // Use "auto" to let the model decide when to use tools
       // "required" was forcing tools even for simple greetings
       zaiBody.tool_choice = "auto";
-      // Also enable parallel tool calls
-      zaiBody.parallel_tool_calls = false;  // Disable parallel tool calls - GPT often makes duplicate calls
+      zaiBody.parallel_tool_calls = false;  // Disabled: duplicate-call risk
     }
 
     headers = {
@@ -1800,7 +1932,6 @@ async function invokeZai(body, incomingHeaders = {}) {
       isOpenAIFormat,
     }, "=== Z.AI RAW RESPONSE ===");
 
-    // Convert OpenAI response back to Anthropic format if needed
     if (isOpenAIFormat && response?.ok && response?.json) {
       const anthropicJson = convertOpenAIToAnthropic(response.json);
       logger.debug({
@@ -1861,7 +1992,6 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
   // Guard against the deprecated auto model arriving via config too.
   if (mappedModel === "moonshot-v1-auto") mappedModel = "moonshot-v1-128k";
 
-  // Convert messages using existing utility
   const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
 
   // Moonshot natively supports system role — add as system message
@@ -1887,7 +2017,6 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
     stream: false,  // Force non-streaming - OpenAI SSE to Anthropic SSE conversion not implemented
   };
 
-  // Convert and add tools if present
   if (Array.isArray(body.tools) && body.tools.length > 0) {
     moonshotBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
     moonshotBody.tool_choice = "auto";
@@ -1908,7 +2037,20 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
     toolCount: moonshotBody.tools?.length || 0,
   }, "=== Moonshot REQUEST ===");
 
-  const response = await performJsonRequest(endpoint, { headers, body: moonshotBody }, "Moonshot");
+  // 429 is NOT retryable here: Moonshot's org-level limits persist for
+  // minutes-hours, so retry backoff holds requests hostage. Fail fast and
+  // let tier-fallback climb instead.
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: moonshotBody,
+    retryableStatusesOverride: [500, 502, 503, 504],
+  }, "Moonshot");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`Moonshot rate-limited (org quota): ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
 
   const rawMsg = response?.json?.choices?.[0]?.message;
   logger.debug({
@@ -1925,7 +2067,6 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
     fullRawResponse: String(JSON.stringify(response?.json) || '').substring(0, 800),
   }, "=== Moonshot RAW RESPONSE ===");
 
-  // Convert OpenAI response back to Anthropic format
   if (response?.ok && response?.json) {
     const anthropicJson = convertOpenAIToAnthropic(response.json);
     logger.debug({
@@ -1970,7 +2111,6 @@ function convertOpenAIToAnthropic(response) {
     }
   }
 
-  // Add text content from message.content
   // Don't add placeholder text if there are tool_calls - tools are the actual response
   const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
 
@@ -1985,11 +2125,8 @@ function convertOpenAIToAnthropic(response) {
 
   if (textContent) {
     content.push({ type: "text", text: textContent });
-  } else if (!reasoningContent) {
-    // No content and no reasoning — will be handled by the empty check below
   }
 
-  // Convert tool calls
   if (Array.isArray(message.tool_calls)) {
     for (const toolCall of message.tool_calls) {
       content.push({
@@ -2001,7 +2138,6 @@ function convertOpenAIToAnthropic(response) {
     }
   }
 
-  // Ensure there's at least some content
   if (content.length === 0) {
     content.push({ type: "text", text: "" });
   }
@@ -2043,13 +2179,11 @@ function sanitizeSchemaForGemini(schema) {
 
   const sanitized = { ...schema };
 
-  // Remove unsupported properties
   delete sanitized.additionalProperties;
   delete sanitized.$schema;
   delete sanitized.definitions;
   delete sanitized.$ref;
 
-  // Recursively sanitize nested properties
   if (sanitized.properties && typeof sanitized.properties === 'object') {
     const cleanProps = {};
     for (const [key, value] of Object.entries(sanitized.properties)) {
@@ -2058,12 +2192,10 @@ function sanitizeSchemaForGemini(schema) {
     sanitized.properties = cleanProps;
   }
 
-  // Sanitize items in arrays
   if (sanitized.items) {
     sanitized.items = sanitizeSchemaForGemini(sanitized.items);
   }
 
-  // Sanitize anyOf, oneOf, allOf
   for (const key of ['anyOf', 'oneOf', 'allOf']) {
     if (Array.isArray(sanitized[key])) {
       sanitized[key] = sanitized[key].map(item => sanitizeSchemaForGemini(item));
@@ -2074,9 +2206,10 @@ function sanitizeSchemaForGemini(schema) {
 }
 
 /**
- * Vertex AI (Google Cloud) Provider - Gemini Models
+ * Vertex AI Provider - Gemini Models
  *
- * Supports Google Gemini models through Vertex AI.
+ * Despite the name, this calls the Gemini API directly
+ * (generativelanguage.googleapis.com), not Google Cloud Vertex AI.
  * Converts Anthropic format to Gemini format and back.
  */
 async function invokeVertex(body, incomingHeaders = {}) {
@@ -2099,17 +2232,13 @@ async function invokeVertex(body, incomingHeaders = {}) {
     "claude-opus-4-5": "gemini-2.5-pro",
   };
 
-  // Map model name
   const requestedModel = body._tierModel || body.model || config.vertex.model;
   const geminiModel = modelMap[requestedModel] || config.vertex.model || "gemini-2.0-flash";
 
-  // Construct Gemini API endpoint
   const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:generateContent?key=${apiKey}`;
 
-  // Convert Anthropic messages to Gemini format
   const contents = convertAnthropicToGemini(body.messages || [], body.system);
 
-  // Convert tools to Gemini format
   let tools = undefined;
   if (Array.isArray(body.tools) && body.tools.length > 0) {
     tools = [{
@@ -2121,7 +2250,6 @@ async function invokeVertex(body, incomingHeaders = {}) {
     }];
   }
 
-  // Build Gemini request body
   const geminiBody = {
     contents,
     generationConfig: {
@@ -2131,10 +2259,8 @@ async function invokeVertex(body, incomingHeaders = {}) {
     }
   };
 
-  // Add tools if present
   if (tools) {
     geminiBody.tools = tools;
-    // Tell Gemini to use AUTO function calling mode
     geminiBody.toolConfig = {
       functionCallingConfig: {
         mode: "AUTO"
@@ -2157,7 +2283,6 @@ async function invokeVertex(body, incomingHeaders = {}) {
 
   const response = await performJsonRequest(endpoint, { headers, body: geminiBody }, "Vertex AI");
 
-  // Log error details if request failed
   if (!response?.ok) {
     logger.error({
       status: response?.status,
@@ -2172,7 +2297,6 @@ async function invokeVertex(body, incomingHeaders = {}) {
     throw err;
   }
 
-  // Convert Gemini response to Anthropic format
   if (response?.json) {
     const anthropicJson = convertGeminiToAnthropic(response.json, requestedModel);
     logger.debug({
@@ -2307,12 +2431,10 @@ function convertGeminiToAnthropic(response, requestedModel) {
     }
   }
 
-  // Ensure at least empty text if no content
   if (content.length === 0) {
     content.push({ type: "text", text: "" });
   }
 
-  // Determine stop reason
   let stopReason = "end_turn";
   if (content.some(c => c.type === "tool_use")) {
     stopReason = "tool_use";
@@ -2349,7 +2471,6 @@ async function invokeCodex(body, incomingHeaders = {}) {
     throw new Error("Codex: no prompt content to send");
   }
 
-  // Start a new thread
   const threadParams = { model };
   if (systemContext) {
     threadParams.instructions = systemContext;
@@ -2363,7 +2484,6 @@ async function invokeCodex(body, incomingHeaders = {}) {
 
   logger.debug({ threadId, model, promptLength: prompt.length }, "[Codex] Thread started");
 
-  // Send the turn and collect response
   const turnResult = await codex.sendTurn(threadId, prompt, model);
 
   logger.debug({
@@ -2371,7 +2491,6 @@ async function invokeCodex(body, incomingHeaders = {}) {
     responseLength: turnResult.text?.length || 0,
   }, "[Codex] Turn completed");
 
-  // Convert to Anthropic format
   const anthropicJson = convertCodexResponseToAnthropic(turnResult, model);
 
   return {
@@ -2474,22 +2593,39 @@ function stripLynkrBadges(messages) {
       const stripped = msg.content.replace(LYNKR_BADGE_PREFIX_RE, '');
       mutated = true;
       badgeCount++;
-      return { ...msg, content: stripped };
+      // Badge-only content must not become an empty string — Anthropic
+      // rejects empty assistant content (this is the interrupted-response
+      // continuation case, where the partial text WAS just the badge).
+      return { ...msg, content: stripped.trim() ? stripped : '…' };
     }
 
     // Array content variant — Anthropic-format responses keep content as an
-    // array of blocks.
+    // array of blocks. Strip the badge PREFIX from matching blocks rather
+    // than dropping whole blocks: clients that merge text blocks on replay
+    // produce "badge + real answer" in ONE block, and dropping it would
+    // silently delete the model's actual reply from history. A block that
+    // was badge-only disappears entirely.
     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;
+      let changed = false;
+      const rebuilt = [];
+      for (const b of msg.content) {
+        if (b?.type === 'text' && typeof b.text === 'string' && LYNKR_BADGE_PREFIX_RE.test(b.text)) {
+          changed = true;
+          badgeCount++;
+          const strippedText = b.text.replace(LYNKR_BADGE_PREFIX_RE, '');
+          if (strippedText.trim()) rebuilt.push({ ...b, text: strippedText });
+          // badge-only block → drop
+        } else {
+          rebuilt.push(b);
+        }
+      }
+      if (!changed) 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: '' }] };
+      // Anthropic rejects BOTH empty content[] and empty-string text blocks
+      // (min length 1) — the previous `text: ''` placeholder 400'd upstream
+      // on interrupted-response continuations where the partial assistant
+      // text was just the badge. Use a visible-but-benign ellipsis.
+      return { ...msg, content: rebuilt.length ? rebuilt : [{ type: 'text', text: '…' }] };
     }
 
     return msg;
@@ -2518,7 +2654,32 @@ async function invokeModel(body, options = {}) {
   const workspace = body._workspace || options.workspace || null;
   const tenantPolicy = body._tenantPolicy || options.tenantPolicy || null;
   const routingResult = options.forceProvider
-    ? { provider: options.forceProvider, model: null, method: 'forced' }
+    ? {
+        // Forced path (OAuth intent + subscription): the actual decision was
+        // made upstream in api/router.js. Reconstitute the shape from
+        // req.body so WS0 telemetry columns (tier, base_tier,
+        // escalation_source, pinned, switch_reason) survive the hop.
+        provider: options.forceProvider,
+        model: body._tierModel ?? null,
+        tier: body._tierName ?? null,
+        method: body._forcedMethod || 'forced',
+        base_tier: body._baseTier ?? null,
+        escalation_source: body._escalationSource ?? null,
+        pinned: body._pinnedRoute ? true : false,
+        switch_reason: body._switchReason ?? null,
+        // WS4 — off-policy evaluation from telemetry alone requires
+        // propensity + candidates on every row. Deterministic default is
+        // 1.0 with a single-entry candidate list matching the served pair.
+        propensity: body._propensity ?? 1.0,
+        candidates: body._candidates ?? [{ provider: options.forceProvider, model: body._tierModel ?? null }],
+        // WS5 — feedback loop. Forward the bandit context vector so
+        // bandit.update fires with the same features the arm was scored on,
+        // and the query embedding so conclusive-quality outcomes grow the
+        // kNN index without paying for a second embedding call.
+        _banditContext: body._banditContext ?? null,
+        _queryEmbedding: body._queryEmbedding ?? null,
+        _queryText: body._queryText ?? null,
+      }
     : await determineProviderSmart(body, { workspace, tenantPolicy });
   const initialProvider = routingResult.provider;
   const tierSelectedModel = routingResult.model;
@@ -2609,7 +2770,6 @@ async function invokeModel(body, options = {}) {
 
   metricsCollector.recordProviderRouting(initialProvider);
 
-  // Get circuit breaker for initial provider
   const breaker = registry.get(initialProvider, {
     failureThreshold: 5,
     successThreshold: 2,
@@ -2619,11 +2779,9 @@ async function invokeModel(body, options = {}) {
   let retries = 0;
   const startTime = Date.now();
 
-  // Record request start for health tracking
   healthTracker.recordRequestStart(initialProvider);
 
   try {
-    // Try initial provider with circuit breaker
     const result = await breaker.execute(async () => {
       if (initialProvider === "azure-openai") {
         return await invokeAzureOpenAI(body, incomingHeaders);
@@ -2633,6 +2791,8 @@ async function invokeModel(body, options = {}) {
         return await invokeOllama(body, incomingHeaders);
       } else if (initialProvider === "openrouter") {
         return await invokeOpenRouter(body, incomingHeaders);
+      } else if (initialProvider === "edenai") {
+        return await invokeEdenAI(body, incomingHeaders);
       } else if (initialProvider === "openai") {
         return await invokeOpenAI(body, incomingHeaders);
       } else if (initialProvider === "llamacpp") {
@@ -2653,7 +2813,6 @@ async function invokeModel(body, options = {}) {
       return await invokeDatabricks(body, incomingHeaders);
     });
 
-    // Record success metrics
     const latency = Date.now() - startTime;
     metricsCollector.recordProviderSuccess(initialProvider, latency);
     metricsCollector.recordDatabricksRequest(true, retries);
@@ -2662,26 +2821,22 @@ async function invokeModel(body, options = {}) {
     // Record latency for routing intelligence
     getLatencyTracker().record(initialProvider, latency);
 
-    // Record tokens and cost savings
     const outputTokens = result.json?.usage?.output_tokens || result.json?.usage?.completion_tokens || 0;
     const inputTokens = result.json?.usage?.input_tokens || result.json?.usage?.prompt_tokens || 0;
     if (result.json?.usage) {
       metricsCollector.recordTokens(inputTokens, outputTokens);
 
-      // Estimate cost savings if Ollama was used
       if (initialProvider === "ollama") {
         const savings = estimateCostSavings(inputTokens, outputTokens);
         metricsCollector.recordCostSavings(savings);
       }
     }
 
-    // Count tool calls in response
     const toolCallsMade = result.json?.content?.filter?.(
       (b) => b.type === "tool_use"
     )?.length || 0;
 
-    // Compute quality score
-    const qualityScore = scoreResponseQuality(
+    let qualityScore = scoreResponseQuality(
       { tier: routingDecision.tier, hasTools: Array.isArray(body?.tools) && body.tools.length > 0 },
       null,
       {
@@ -2695,6 +2850,25 @@ async function invokeModel(body, options = {}) {
       }
     );
 
+    // WS6 — cascade verification. Only cheap-tier answers are judged, only
+    // on top-level calls (never re-verify an escalated attempt), only when
+    // opted in. A verify-fail overrides the heuristic quality score so the
+    // telemetry row and the WS5 feedback loop record the attempt as the
+    // hard negative it is (kNN learns "questions like this outgrow the
+    // cheap tier"), then the request escalates below.
+    let cascadeVerify = null;
+    if (
+      process.env.LYNKR_CASCADE_VERIFY === 'true' &&
+      !options._cascadeVerifyInner &&
+      (routingDecision.tier === 'SIMPLE' || routingDecision.tier === 'MEDIUM')
+    ) {
+      const { verify } = require('../routing/verifier');
+      cascadeVerify = verify({ payload: body, responseBody: result.json });
+      if (cascadeVerify.verdict === 'fail') {
+        qualityScore = Math.min(qualityScore ?? 100, 20);
+      }
+    }
+
     // Record routing telemetry (non-blocking)
     telemetry.record({
       request_id: crypto.randomUUID(),
@@ -2708,7 +2882,7 @@ async function invokeModel(body, options = {}) {
       message_count: Array.isArray(body?.messages) ? body.messages.length : 0,
       request_type: routingResult.analysis?.requestType || null,
       provider: initialProvider,
-      model: routingDecision.model,
+      model: routingDecision.model ?? body._tierModel ?? null,
       routing_method: routingDecision.method,
       was_fallback: false,
       output_tokens: outputTokens || null,
@@ -2723,9 +2897,81 @@ async function invokeModel(body, options = {}) {
       cost_usd: computeCostUsd(routingDecision.model || body._tierModel, inputTokens, outputTokens),
       request_text: captureRequestText(body),
       response_text: captureResponseText(result.json),
+      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,
     });
 
-    // Return result with provider info and routing decision for headers
+    // WS5.4 — feedback loop (success path).
+    recordFeedbackOutcome({
+      routingResult,
+      body,
+      outcome: {
+        qualityScore,
+        costUsd: computeCostUsd(routingDecision.model || body._tierModel, inputTokens, outputTokens),
+        latencyMs: latency,
+        statusCode: 200,
+        errorType: null,
+        wasFallback: false,
+      },
+    });
+
+    // WS6 — cascade escalation: the cheap answer failed verification, so
+    // discard it and climb the tier ladder (upward candidates only). If
+    // every escalation attempt fails, serve the original cheap answer —
+    // the cascade must never make things worse than no cascade.
+    if (cascadeVerify?.verdict === 'fail') {
+      logger.info({
+        tier: routingDecision.tier,
+        model: routingDecision.model,
+        reasons: cascadeVerify.reasons,
+      }, '[Cascade] Cheap-tier answer failed verification — escalating');
+      try {
+        const { getFallbackChain } = require('../routing/tier-fallback');
+        const upward = getFallbackChain(routingDecision.tier).filter((c) => c.direction === 'up');
+        for (const cand of upward) {
+          try {
+            const attempt = await invokeModel(
+              { ...body, _tierModel: cand.model },
+              {
+                forceProvider: cand.provider,
+                _cascadeVerifyInner: true,
+                _cascadeInner: true,
+                disableFallback: true,
+                workspace,
+                tenantPolicy,
+                headers: incomingHeaders,
+              }
+            );
+            logger.info({
+              from: `${routingDecision.tier}:${routingDecision.model}`,
+              to: `${cand.tier}:${cand.model}`,
+            }, '[Cascade] Escalated answer served');
+            return {
+              ...attempt,
+              actualProvider: cand.provider,
+              routingDecision: {
+                ...routingDecision,
+                provider: cand.provider,
+                model: cand.model,
+                servedTier: cand.tier,
+                method: (routingDecision.method || '') + '+verify_escalated',
+                cascade: { failedTier: routingDecision.tier, reasons: cascadeVerify.reasons },
+              },
+            };
+          } catch (innerErr) {
+            logger.warn({ to: cand.provider, error: innerErr.message }, '[Cascade] Escalation candidate failed, trying next');
+          }
+        }
+      } catch (err) {
+        logger.debug({ err: err.message }, '[Cascade] Escalation setup failed — serving original answer');
+      }
+      // All escalations failed → fall through to the original cheap answer.
+    }
+
     return {
       ...result,
       actualProvider: initialProvider,
@@ -2733,7 +2979,6 @@ async function invokeModel(body, options = {}) {
     };
 
   } catch (err) {
-    // Record failure
     const failLatency = Date.now() - startTime;
     metricsCollector.recordProviderFailure(initialProvider);
     healthTracker.recordFailure(initialProvider, err, err.status);
@@ -2813,7 +3058,12 @@ async function invokeModel(body, options = {}) {
     if (!shouldFallback) {
       metricsCollector.recordDatabricksRequest(false, retries);
 
-      // Record failed telemetry
+      const failQualityScore = scoreResponseQuality(
+        { tier: routingDecision.tier, hasTools: Array.isArray(body?.tools) && body.tools.length > 0 },
+        null,
+        { error_type: err.code || err.name, was_fallback: false, retry_count: retries, latency_ms: failLatency }
+      );
+
       telemetry.record({
         request_id: crypto.randomUUID(),
         session_id: body._sessionId || null,
@@ -2826,23 +3076,41 @@ async function invokeModel(body, options = {}) {
         message_count: Array.isArray(body?.messages) ? body.messages.length : 0,
         request_type: routingResult.analysis?.requestType || null,
         provider: initialProvider,
-        model: routingDecision.model,
+        model: routingDecision.model ?? body._tierModel ?? null,
         routing_method: routingDecision.method,
         was_fallback: false,
         latency_ms: failLatency,
         status_code: err.status || null,
         error_type: err.code || err.name || "unknown",
-        quality_score: scoreResponseQuality(
-          { tier: routingDecision.tier, hasTools: Array.isArray(body?.tools) && body.tools.length > 0 },
-          null,
-          { error_type: err.code || err.name, was_fallback: false, retry_count: retries, latency_ms: failLatency }
-        ),
+        quality_score: failQualityScore,
+        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,
+      });
+
+      // WS5.4 — feedback loop (primary-failed, no fallback). Low quality
+      // scores are signal too: the bandit's reward drops, and if the
+      // outcome is conclusive-negative (≤40) the kNN index learns to
+      // steer away from this (query → model) pairing.
+      recordFeedbackOutcome({
+        routingResult,
+        body,
+        outcome: {
+          qualityScore: failQualityScore,
+          costUsd: null,
+          latencyMs: failLatency,
+          statusCode: err.status || null,
+          errorType: err.code || err.name || "unknown",
+          wasFallback: false,
+        },
       });
 
       throw err;
     }
 
-    // Determine failure reason
     const reason = categorizeFailure(err);
     const fallbackProvider = getFallbackProvider();
 
@@ -2855,11 +3123,9 @@ async function invokeModel(body, options = {}) {
 
     metricsCollector.recordFallbackAttempt(initialProvider, fallbackProvider, reason);
 
-    // Record fallback request start for health tracking
     healthTracker.recordRequestStart(fallbackProvider);
 
     try {
-      // Get circuit breaker for fallback provider
       const fallbackBreaker = registry.get(fallbackProvider, {
         failureThreshold: 5,
         successThreshold: 2,
@@ -2868,7 +3134,6 @@ async function invokeModel(body, options = {}) {
 
       const fallbackStart = Date.now();
 
-      // Execute fallback
       const fallbackResult = await fallbackBreaker.execute(async () => {
         if (fallbackProvider === "azure-openai") {
           return await invokeAzureOpenAI(body, incomingHeaders);
@@ -2876,6 +3141,8 @@ async function invokeModel(body, options = {}) {
           return await invokeAzureAnthropic(body, incomingHeaders);
         } else if (fallbackProvider === "openrouter") {
           return await invokeOpenRouter(body, incomingHeaders);
+        } else if (fallbackProvider === "edenai") {
+          return await invokeEdenAI(body, incomingHeaders);
         } else if (fallbackProvider === "openai") {
           return await invokeOpenAI(body, incomingHeaders);
         } else if (fallbackProvider === "llamacpp") {
@@ -2892,12 +3159,10 @@ async function invokeModel(body, options = {}) {
 
       const fallbackLatency = Date.now() - fallbackStart;
 
-      // Record fallback success
       metricsCollector.recordFallbackSuccess(fallbackLatency);
       metricsCollector.recordDatabricksRequest(true, retries);
       healthTracker.recordSuccess(fallbackProvider, fallbackLatency);
 
-      // Record token usage
       if (fallbackResult.json?.usage) {
         metricsCollector.recordTokens(
           fallbackResult.json.usage.input_tokens || fallbackResult.json.usage.prompt_tokens || 0,
@@ -2912,16 +3177,22 @@ async function invokeModel(body, options = {}) {
         totalLatency: Date.now() - startTime,
       }, "Fallback to cloud provider succeeded");
 
-      // Record latency for fallback provider
       getLatencyTracker().record(fallbackProvider, routingDecision?.model, fallbackLatency);
 
-      // Capture fallback telemetry
       const fbOutputTokens = fallbackResult.json?.usage?.output_tokens || fallbackResult.json?.usage?.completion_tokens || 0;
       const fbInputTokens = fallbackResult.json?.usage?.input_tokens || fallbackResult.json?.usage?.prompt_tokens || 0;
       const fbToolCalls = fallbackResult.json?.content?.filter?.(
         (b) => b.type === "tool_use"
       )?.length || 0;
 
+      const fbTotalLatency = Date.now() - startTime;
+      const fbQualityScore = scoreResponseQuality(
+        { tier: routingDecision.tier, hasTools: Array.isArray(body?.tools) && body.tools.length > 0 },
+        null,
+        { status_code: 200, output_tokens: fbOutputTokens, tool_calls_made: fbToolCalls, was_fallback: true, retry_count: 0, latency_ms: fbTotalLatency }
+      );
+      const fbCostUsd = computeCostUsd(routingDecision.model || body._tierModel, fbInputTokens, fbOutputTokens);
+
       telemetry.record({
         request_id: crypto.randomUUID(),
         session_id: body._sessionId || null,
@@ -2934,27 +3205,45 @@ async function invokeModel(body, options = {}) {
         message_count: Array.isArray(body?.messages) ? body.messages.length : 0,
         request_type: routingResult.analysis?.requestType || null,
         provider: fallbackProvider,
-        model: routingDecision.model,
+        model: routingDecision.model ?? body._tierModel ?? null,
         routing_method: "fallback",
         was_fallback: true,
         output_tokens: fbOutputTokens || null,
-        latency_ms: Date.now() - startTime,
+        latency_ms: fbTotalLatency,
         status_code: 200,
         error_type: null,
         tool_calls_made: fbToolCalls,
         retry_count: 0,
-        quality_score: scoreResponseQuality(
-          { tier: routingDecision.tier, hasTools: Array.isArray(body?.tools) && body.tools.length > 0 },
-          null,
-          { status_code: 200, output_tokens: fbOutputTokens, tool_calls_made: fbToolCalls, was_fallback: true, retry_count: 0, latency_ms: Date.now() - startTime }
-        ),
+        quality_score: fbQualityScore,
         tokens_per_second: fbOutputTokens && fallbackLatency > 0 ? fbOutputTokens / (fallbackLatency / 1000) : null,
-        cost_usd: computeCostUsd(routingDecision.model || body._tierModel, fbInputTokens, fbOutputTokens),
+        cost_usd: fbCostUsd,
         request_text: captureRequestText(body),
         response_text: captureResponseText(fallbackResult.json),
+        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,
+      });
+
+      // WS5.4 — feedback loop (fallback success). The served provider
+      // isn't the one the router picked, so the bandit reward records the
+      // fallback outcome under the original arm — which is the honest
+      // signal for future picks of that arm.
+      recordFeedbackOutcome({
+        routingResult,
+        body,
+        outcome: {
+          qualityScore: fbQualityScore,
+          costUsd: fbCostUsd,
+          latencyMs: fbTotalLatency,
+          statusCode: 200,
+          errorType: null,
+          wasFallback: true,
+        },
       });
 
-      // Return result with actual provider used (fallback provider) and routing decision
       return {
         ...fallbackResult,
         actualProvider: fallbackProvider,
@@ -2967,12 +3256,12 @@ async function invokeModel(body, options = {}) {
       };
 
     } catch (fallbackErr) {
-      // Both providers failed
       metricsCollector.recordFallbackFailure();
       metricsCollector.recordDatabricksRequest(false, retries);
       healthTracker.recordFailure(fallbackProvider, fallbackErr, fallbackErr.status);
 
-      // Record double-failure telemetry
+      const dfLatencyMs = Date.now() - startTime;
+
       telemetry.record({
         request_id: crypto.randomUUID(),
         session_id: body._sessionId || null,
@@ -2980,13 +3269,35 @@ async function invokeModel(body, options = {}) {
         complexity_score: routingResult.score ?? null,
         tier: routingDecision.tier,
         provider: fallbackProvider,
-        model: routingDecision.model,
+        model: routingDecision.model ?? body._tierModel ?? null,
         routing_method: "fallback",
         was_fallback: true,
-        latency_ms: Date.now() - startTime,
+        latency_ms: dfLatencyMs,
         status_code: fallbackErr.status || null,
         error_type: fallbackErr.code || fallbackErr.name || "double_failure",
         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,
+      });
+
+      // WS5.4 — feedback loop (double failure). quality=0 is a hard
+      // negative exemplar; the kNN index will learn to steer away from
+      // this arm for similar queries.
+      recordFeedbackOutcome({
+        routingResult,
+        body,
+        outcome: {
+          qualityScore: 0,
+          costUsd: null,
+          latencyMs: dfLatencyMs,
+          statusCode: fallbackErr.status || null,
+          errorType: fallbackErr.code || fallbackErr.name || "double_failure",
+          wasFallback: true,
+        },
       });
 
       logger.error({
@@ -3062,4 +3373,6 @@ module.exports = {
   stripLynkrBadges,
   destroyHttpAgents,
   normalizeBodyForConverse,
+  _stripInternalFields,
+  _throwIfOllamaError,
 };