lynkr 9.14.1 → 9.14.3

package/src/clients/databricks.js

@@ -77,11 +77,26 @@ function _stripInternalFields(body) {
   return cleaned || body;
 }
 
-async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride, maxRetriesOverride }, providerLabel) {
+async function performJsonRequest(url, { headers = {}, body, retryableStatusesOverride, maxRetriesOverride, timeoutMs }, providerLabel) {
   const agent = url.startsWith('https:') ? httpsAgent : httpAgent;
   body = _stripInternalFields(body);
   const isStreaming = body.stream === true;
 
+  // Optional per-call abort timeout (opt-in via timeoutMs) — most callers
+  // omit it and keep the historical unbounded-fetch behavior. Added for
+  // llama.cpp (see invokeLlamaCpp): a dead upstream that accepts the TCP
+  // connection but never answers at the application layer hangs fetch()
+  // indefinitely — live-observed at ~75s, riding an incidental OS/tunnel
+  // socket timeout rather than any deliberate bound. This makes the
+  // already-configured (but previously unused) LLAMACPP_TIMEOUT_MS real.
+  // A fresh signal is created per attempt below (not hoisted here) —
+  // AbortSignal.timeout()'s clock starts at construction, so one signal
+  // shared across withRetry's attempts would leave later retries with a
+  // shrinking (or already-expired) budget instead of a full timeout each.
+  const makeSignal = () => (typeof timeoutMs === "number" && timeoutMs > 0
+    ? AbortSignal.timeout(timeoutMs)
+    : undefined);
+
   // Streaming requests can't be retried, so handle them directly
   if (isStreaming) {
     const response = await fetch(url, {
@@ -89,6 +104,7 @@ async function performJsonRequest(url, { headers = {}, body, retryableStatusesOv
       headers,
       body: JSON.stringify(body),
       agent,
+      signal: makeSignal(),
     });
 
     logger.debug({
@@ -122,6 +138,7 @@ async function performJsonRequest(url, { headers = {}, body, retryableStatusesOv
       headers,
       body: JSON.stringify(body),
       agent,
+      signal: makeSignal(),
     });
     const text = await response.text();
 
@@ -165,7 +182,7 @@ async function performJsonRequest(url, { headers = {}, body, retryableStatusesOv
   });
 }
 
-async function invokeDatabricks(body, incomingHeaders = {}) {
+async function invokeDatabricks(body, _incomingHeaders = {}) {
   if (!config.databricks?.url) {
     throw new Error("Databricks configuration is missing required URL.");
   }
@@ -423,12 +440,20 @@ function _liftLeakedThinkingBlocks(response) {
   const newContent = [];
   let lifted = 0;
   for (const block of payload.content) {
-    if (block?.type === "text" && typeof block.text === "string" && block.text.includes("<think>")) {
+    if (block?.type === "text" && typeof block.text === "string" &&
+        (block.text.includes("<think>") || 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();
+      let cleaned = block.text.replace(thinkRegex, "").trim();
+      // Orphan closing tag: GLM-family templates open <think> in the prompt,
+      // so the completion may carry reasoning terminated by a bare </think>.
+      const orphanIdx = cleaned.indexOf("</think>");
+      if (orphanIdx !== -1) {
+        thoughts.push(cleaned.slice(0, orphanIdx).trim());
+        cleaned = cleaned.slice(orphanIdx + "</think>".length).trim();
+      }
       const merged = thoughts.filter(Boolean).join("\n\n");
       if (merged) {
         newContent.push({ type: "thinking", thinking: merged });
@@ -489,7 +514,7 @@ async function _throwIfOllamaError(response, modelName) {
   return response;
 }
 
-async function invokeOllama(body, incomingHeaders = {}) {
+async function invokeOllama(body, _incomingHeaders = {}) {
   if (!config.ollama?.endpoint) {
     throw new Error("Ollama endpoint is not configured.");
   }
@@ -754,7 +779,7 @@ async function invokeOllama(body, incomingHeaders = {}) {
   );
 }
 
-async function invokeOpenRouter(body, incomingHeaders = {}) {
+async function invokeOpenRouter(body, _incomingHeaders = {}) {
   if (!config.openrouter?.endpoint || !config.openrouter?.apiKey) {
     throw new Error("OpenRouter endpoint or API key is not configured.");
   }
@@ -821,13 +846,27 @@ async function invokeOpenRouter(body, incomingHeaders = {}) {
     }, "Sending tools to OpenRouter");
   }
 
-  return performJsonRequest(endpoint, { headers, body: openRouterBody }, "OpenRouter");
+  // Same pre-return 429 check as invokeMoonshot/invokeBaidu — see the comment
+  // on invokeOpenAI's equivalent check for why this matters for streaming.
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: openRouterBody,
+    retryableStatusesOverride: [500, 502, 503, 504],
+  }, "OpenRouter");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`OpenRouter rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  return response;
 }
 
 // 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 = {}) {
+async function invokeEdenAI(body, _incomingHeaders = {}) {
   if (!config.edenai?.endpoint || !config.edenai?.apiKey) {
     throw new Error("Eden AI endpoint or API key is not configured.");
   }
@@ -912,7 +951,7 @@ function derivePromptCacheKey(body) {
   return "conv-" + crypto.createHash("sha1").update(text.slice(0, 4000)).digest("hex").slice(0, 32);
 }
 
-async function invokeAzureOpenAI(body, incomingHeaders = {}) {
+async function invokeAzureOpenAI(body, _incomingHeaders = {}) {
   if (!config.azureOpenAI?.endpoint || !config.azureOpenAI?.apiKey) {
     throw new Error("Azure OpenAI endpoint or API key is not configured.");
   }
@@ -1077,7 +1116,7 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         originalMessageCount: (body.messages || []).length,
         convertedMessageCount: azureBody.messages.length,
         messageRoles: (body.messages || []).map(m => m.role),
-      }, "=== CONTINUATION REQUEST DETECTED - using minimal system prompt to avoid Azure content filter ===");
+      }, "Continuation request — system prompt PRESERVED, system-reminder blocks stripped uniformly (the filter trigger was the reminders, not the prompt; see system-message handling below)");
     } else {
       logger.debug({
         hasToolResults: false,
@@ -1221,17 +1260,34 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
       // the conversation's first user message — stable across every turn of
       // the same task. Keep per-key traffic under ~15 req/min.
       ...(isGpt5 ? { prompt_cache_key: derivePromptCacheKey(body) } : {}),
-      stream: false
+      stream: body.stream ?? false
     };
     logger.debug({
       format: "responses",
       inputCount: responsesBody.input?.length,
       model: responsesBody.model,
-      hasTools: !!responsesBody.tools
+      hasTools: !!responsesBody.tools,
+      streaming: responsesBody.stream,
     }, "Using Responses API format");
 
     const result = await performJsonRequest(endpoint, { headers, body: responsesBody }, "Azure OpenAI Responses");
 
+    // Streaming: hand back a synthetic OpenAI-Chat-Completions-shaped SSE
+    // stream (see src/orchestrator/azure-responses-sse.js for why that shape
+    // rather than Anthropic SSE directly) so the orchestrator's existing
+    // sseTransform.openaiToAnthropicSSE call site — already wired for
+    // moonshot/baidu/openai's raw streams — handles this one identically,
+    // with zero changes needed there. Skips the whole buffered
+    // output-array/dedup/usage-remap conversion below entirely; that logic
+    // only makes sense for a complete, already-materialized response.
+    if (result.stream) {
+      const { azureResponsesToOpenAIChunks } = require("../orchestrator/azure-responses-sse");
+      return {
+        ...result,
+        stream: azureResponsesToOpenAIChunks(result.stream, { model: responsesBody.model }),
+      };
+    }
+
     // Convert Responses API response to Chat Completions format
     if (result.ok && result.json?.output) {
       const outputArray = result.json.output || [];
@@ -1298,6 +1354,8 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         toolCallNames: toolCalls.map(tc => tc.function.name)
       }, "Parsing Responses API output");
 
+      const _rawUsage = result.json.usage;
+
       result.json = {
         id: result.json.id,
         object: "chat.completion",
@@ -1314,15 +1372,15 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
         }],
         // 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)),
+        usage: _rawUsage ? {
+          prompt_tokens: _rawUsage.prompt_tokens ?? _rawUsage.input_tokens ?? 0,
+          completion_tokens: _rawUsage.completion_tokens ?? _rawUsage.output_tokens ?? 0,
+          total_tokens: _rawUsage.total_tokens
+            ?? ((_rawUsage.input_tokens ?? 0) + (_rawUsage.output_tokens ?? 0)),
           // Provider-side prompt-cache hits (Responses API: input_tokens_details,
           // Chat Completions: prompt_tokens_details) — telemetry reads this name.
-          cache_read_input_tokens: result.json.usage.input_tokens_details?.cached_tokens
-            ?? result.json.usage.prompt_tokens_details?.cached_tokens
+          cache_read_input_tokens: _rawUsage.input_tokens_details?.cached_tokens
+            ?? _rawUsage.prompt_tokens_details?.cached_tokens
             ?? null,
         } : undefined
       };
@@ -1357,7 +1415,7 @@ async function invokeAzureOpenAI(body, incomingHeaders = {}) {
 }
 
 
-async function invokeOpenAI(body, incomingHeaders = {}) {
+async function invokeOpenAI(body, _incomingHeaders = {}) {
   if (!config.openai?.apiKey) {
     throw new Error("OpenAI API key is not configured.");
   }
@@ -1429,7 +1487,23 @@ async function invokeOpenAI(body, incomingHeaders = {}) {
     max_tokens: openAIBody.max_tokens,
   }, "=== OPENAI REQUEST ===");
 
-  return performJsonRequest(endpoint, { headers, body: openAIBody }, "OpenAI");
+  // Same pre-return 429 check as invokeMoonshot/invokeBaidu: performJsonRequest's
+  // streaming branch never throws on a bad status (retry is skipped entirely for
+  // stream:true), so without this a 429 was silently handed back as a "successful"
+  // stream/response and tier-fallback never got a chance to climb.
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: openAIBody,
+    retryableStatusesOverride: [500, 502, 503, 504],
+  }, "OpenAI");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`OpenAI rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  return response;
 }
 
 async function invokeAtlas(body) {
@@ -1487,15 +1561,29 @@ async function invokeAtlas(body) {
 
   // Chat completions are billable POSTs, so Atlas requests are never replayed
   // automatically. Callers can retry explicitly with their own idempotency policy.
-  return performJsonRequest(endpoint, {
+  // maxRetriesOverride/retryableStatusesOverride stay at 0/[] — this does NOT
+  // retry the Atlas request itself, it only decides whether invokeModel's
+  // caller escalates to a DIFFERENT provider/tier on 429, same as
+  // invokeMoonshot/invokeBaidu/invokeOpenAI/invokeOpenRouter already do.
+  // Without this, a 429 here was silently handed back as a "successful"
+  // response and tier-fallback never got a chance to climb.
+  const response = await performJsonRequest(endpoint, {
     headers,
     body: atlasBody,
     maxRetriesOverride: 0,
     retryableStatusesOverride: [],
   }, "Atlas Cloud");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`Atlas Cloud rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  return response;
 }
 
-async function invokeLlamaCpp(body, incomingHeaders = {}) {
+async function invokeLlamaCpp(body, _incomingHeaders = {}) {
   if (!config.llamacpp?.endpoint) {
     throw new Error("llama.cpp endpoint is not configured.");
   }
@@ -1572,10 +1660,18 @@ async function invokeLlamaCpp(body, incomingHeaders = {}) {
     }, 'llama.cpp: Removed consecutive duplicate roles from message sequence');
   }
 
+  // max_tokens floor: reasoning-capable local models (live-confirmed on this
+  // deployment's GPT-OSS build) can spend their entire budget on
+  // `reasoning_content` before writing any visible answer — a caller-
+  // supplied tiny budget (e.g. the caveman probe's max_tokens:1 seen in
+  // production logs) then returns finish_reason:"length" with zero visible
+  // text. Same fix already shipped for Ollama as LYNKR_OLLAMA_MIN_MAX_TOKENS;
+  // mirrored here rather than inventing a different mechanism.
+  const llamacppMinMaxTokens = Number(process.env.LYNKR_LLAMACPP_MIN_MAX_TOKENS) || 1536;
   const llamacppBody = {
     messages: deduplicated,
     temperature: body.temperature ?? 0.7,
-    max_tokens: body.max_tokens ?? 16384,
+    max_tokens: Math.max(body.max_tokens ?? 16384, llamacppMinMaxTokens),
     top_p: body.top_p ?? 1.0,
     stream: body.stream ?? false
   };
@@ -1625,7 +1721,11 @@ async function invokeLlamaCpp(body, incomingHeaders = {}) {
     }))
   }, "=== LLAMA.CPP REQUEST ===");
 
-  const result = await performJsonRequest(endpoint, { headers, body: llamacppBody }, "llama.cpp");
+  const result = await performJsonRequest(
+    endpoint,
+    { headers, body: llamacppBody, timeoutMs: config.llamacpp.timeout },
+    "llama.cpp",
+  );
 
   // Context overflow is a CAPACITY error, not a request error: the local
   // model's slot is simply too small for this conversation (llama-server
@@ -1641,7 +1741,7 @@ async function invokeLlamaCpp(body, incomingHeaders = {}) {
   return result;
 }
 
-async function invokeLMStudio(body, incomingHeaders = {}) {
+async function invokeLMStudio(body, _incomingHeaders = {}) {
   if (!config.lmstudio?.endpoint) {
     throw new Error("LM Studio endpoint is not configured.");
   }
@@ -1768,7 +1868,7 @@ function normalizeBodyForConverse(body) {
   return normalized;
 }
 
-async function invokeBedrock(body, incomingHeaders = {}) {
+async function invokeBedrock(body, _incomingHeaders = {}) {
   if (!config.bedrock?.apiKey) {
     throw new Error(
       "AWS Bedrock requires AWS_BEDROCK_API_KEY (Bearer token). " +
@@ -1781,11 +1881,9 @@ async function invokeBedrock(body, incomingHeaders = {}) {
 
   // Inject standard tools if needed
   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,
@@ -1954,7 +2052,7 @@ async function invokeBedrock(body, incomingHeaders = {}) {
  * 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, incomingHeaders = {}) {
+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.");
   }
@@ -2057,11 +2155,23 @@ async function invokeZai(body, incomingHeaders = {}) {
     zaiBody = { ...body };
     zaiBody.model = mappedModel;
 
-    // Force buffered mode: with stream:true this endpoint returns ANTHROPIC
-    // SSE, but the downstream transformer parses OPENAI SSE — every chunk is
-    // unreadable and the client receives an empty completion. Buffered JSON
-    // converts correctly; the router synthesizes client-side SSE as usual.
-    zaiBody.stream = false;
+    // Honor body.stream as-is here. The ONLY caller that ever sets it true
+    // for this branch is passthrough-stream.js's handleNativeStream — zai
+    // isn't in sse-transformer.js's DEFAULT_OPENAI_SSE_PROVIDERS, so the
+    // normal buffered orchestrator (orchestrator/index.js) always sets
+    // cleanPayload.stream=false before invoking any provider not on that
+    // allowlist, and never reaches this branch with stream:true itself.
+    // Forcing false unconditionally (as this used to do) broke exactly that
+    // caller: _anthropicNative() advertises this endpoint as native-passthrough
+    // eligible, handleNativeStream sets stream:true and expects real
+    // Anthropic SSE bytes back, but got a buffered JSON body instead —
+    // handleNativeStream then saw no `.stream` field, silently gave up, and
+    // fell back to the buffered orchestrator path, which called zai AGAIN.
+    // Every native-passthrough request to this endpoint was double-invoking
+    // the real API. If a future caller other than handleNativeStream ever
+    // needs stream:true routed through the OpenAI-SSE transformer instead,
+    // that's a different bug — add zai to DEFAULT_OPENAI_SSE_PROVIDERS then,
+    // don't reintroduce this override.
 
     // Inject standard tools if client didn't send any (passthrough mode)
     if (!Array.isArray(zaiBody.tools) || zaiBody.tools.length === 0) {
@@ -2159,7 +2269,7 @@ async function invokeZai(body, incomingHeaders = {}) {
  * 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, incomingHeaders = {}) {
+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.");
   }
@@ -2216,12 +2326,18 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
   // Only the moonshot-v1-* models accept caller-supplied values.
   const isKimiPinned = /^kimi-k/i.test(mappedModel);
 
+  const { resolveThinkingParam } = require("./provider-capabilities");
   const moonshotBody = {
     model: mappedModel,
     messages,
     max_tokens: body.max_tokens || 16384,
     temperature: isKimiPinned ? 1 : (body.temperature ?? 0.7),
     top_p: isKimiPinned ? 0.95 : (body.top_p ?? 1.0),
+    // kimi-k3 emits verbose reasoning_content by default, sharing the same
+    // token budget as the answer — without this, reasoning alone can (and
+    // did, live-confirmed) consume the whole max_tokens before any answer
+    // is written. See resolveThinkingParam's doc comment for the full story.
+    thinking: resolveThinkingParam(body),
     // Streaming honored since the Phase-2b sse-transformer landed: the raw
     // OpenAI SSE stream is returned below and reshaped in flight by the
     // orchestrator (moonshot is in DEFAULT_OPENAI_SSE_PROVIDERS). Buffered
@@ -2321,7 +2437,7 @@ async function invokeMoonshot(body, incomingHeaders = {}) {
  * modelMap and pinned-params logic (see Moonshot's kimi-k* precedent) once
  * real traffic surfaces 400s.
  */
-async function invokeBaidu(body, incomingHeaders = {}) {
+async function invokeBaidu(body, _incomingHeaders = {}) {
   if (!config.baidu?.apiKey) {
     throw new Error("Baidu API key is not configured. Set BAIDU_API_KEY in your .env file.");
   }
@@ -2365,12 +2481,18 @@ async function invokeBaidu(body, incomingHeaders = {}) {
     messages.unshift({ role: "system", content: systemContent });
   }
 
+  const { resolveThinkingParam } = require("./provider-capabilities");
   const baiduBody = {
     model: mappedModel,
     messages,
     max_tokens: body.max_tokens || 16384,
     temperature: body.temperature ?? 0.7,
     top_p: body.top_p ?? 1.0,
+    // glm-5.2 emits verbose reasoning_content by default, sharing the same
+    // token budget as the answer — without this, reasoning alone can (and
+    // did, live-confirmed) consume the whole max_tokens before any answer
+    // is written. See resolveThinkingParam's doc comment for the full story.
+    thinking: resolveThinkingParam(body),
     // Streaming honored once "baidu" is added to DEFAULT_OPENAI_SSE_PROVIDERS
     // (sse-transformer.js) and confirmed to match OpenAI SSE shape. Buffered
     // requests use the Anthropic conversion path below regardless.
@@ -2430,6 +2552,147 @@ async function invokeBaidu(body, incomingHeaders = {}) {
   return response;
 }
 
+/**
+ * Fireworks AI Provider (serverless inference)
+ *
+ * Fireworks exposes an OpenAI-compatible Chat Completions API
+ * (https://api.fireworks.ai/inference/v1/chat/completions, bearer-token
+ * auth). Modeled on invokeBaidu: request side reuses the shared
+ * openrouter-utils converters, response is converted to Anthropic shape
+ * locally so the orchestrator branch is a plain passthrough.
+ *
+ * Model ids are long-form serverless paths
+ * (accounts/fireworks/models/<slug>, accounts/fireworks/routers/<slug>).
+ * The modelMap below covers bare Anthropic names; tier-selected Fireworks
+ * ids (e.g. TIER_COMPLEX=fireworks:accounts/fireworks/models/glm-5p2)
+ * reach the wire unchanged.
+ *
+ * NOTE (E2E-unverified as of this addition, same caveat Baidu shipped
+ * with): sampling quirks, reasoning_content emission on reasoning models,
+ * finish_reason shape on tool calls, and 429 retryability are best-effort
+ * from public docs, not yet probed against a live key. Revisit once real
+ * traffic surfaces 400s — see Moonshot's kimi-k* precedent for the shape
+ * such fixes take.
+ */
+async function invokeFireworks(body, _incomingHeaders = {}) {
+  if (!config.fireworks?.apiKey) {
+    throw new Error("Fireworks API key is not configured. Set FIREWORKS_API_KEY in your .env file.");
+  }
+
+  const {
+    convertAnthropicToolsToOpenRouter,
+    convertAnthropicMessagesToOpenRouter
+  } = require("./openrouter-utils");
+
+  const endpoint = config.fireworks.endpoint || "https://api.fireworks.ai/inference/v1/chat/completions";
+
+  // Model mapping: Anthropic names → Fireworks serverless ids.
+  const modelMap = {
+    "claude-sonnet-4-5-20250929": "accounts/fireworks/models/kimi-k2-instruct-0905",
+    "claude-sonnet-4-5": "accounts/fireworks/models/kimi-k2-instruct-0905",
+    "claude-sonnet-4.5": "accounts/fireworks/models/kimi-k2-instruct-0905",
+    "claude-3-5-sonnet": "accounts/fireworks/models/kimi-k2-instruct-0905",
+    "claude-opus-4-5": "accounts/fireworks/models/glm-5p2",
+    "claude-opus-4.5": "accounts/fireworks/models/glm-5p2",
+    "claude-3-opus": "accounts/fireworks/models/glm-5p2",
+    "claude-haiku-4-5-20251001": "accounts/fireworks/models/llama-3.1-8b-instruct",
+    "claude-haiku-4-5": "accounts/fireworks/models/llama-3.1-8b-instruct",
+    "claude-3-haiku": "accounts/fireworks/models/llama-3.1-8b-instruct",
+  };
+
+  const requestedModel = body._tierModel || body.model || config.fireworks.model;
+
+  // Honor tier-selected Fireworks ids instead of silently swapping in the
+  // .env default model. Accepts full serverless paths as well as well-known
+  // open-weight family slugs hosted on Fireworks.
+  const FIREWORKS_ID_RE = /^(accounts\/|kimi-|glm-|deepseek-|qwen|llama-|mistral-|mixtral-|phi-|gemma-|grok-|solar-|yi-|fireworks-)/i;
+  const mappedModel = modelMap[requestedModel]
+    || (FIREWORKS_ID_RE.test(requestedModel || "") ? requestedModel : null)
+    || config.fireworks.model
+    || "accounts/fireworks/models/kimi-k2-instruct-0905";
+
+  const messages = convertAnthropicMessagesToOpenRouter(body.messages || []);
+
+  // Fireworks supports the system role natively.
+  if (body.system) {
+    const systemContent = Array.isArray(body.system)
+      ? body.system.map(s => s.text || s).join("\n")
+      : body.system;
+    messages.unshift({ role: "system", content: systemContent });
+  }
+
+  const { resolveThinkingParam } = require("./provider-capabilities");
+  const fireworksBody = {
+    model: mappedModel,
+    messages,
+    max_tokens: body.max_tokens || 16384,
+    temperature: body.temperature ?? 0.7,
+    top_p: body.top_p ?? 1.0,
+    // Reasoning models (R1/GLM) share the answer budget with thinking output;
+    // the buffered path lifts reasoning_content into thinking blocks.
+    thinking: resolveThinkingParam(body),
+    // Streaming honored once "fireworks" joins DEFAULT_OPENAI_SSE_PROVIDERS
+    // (sse-transformer.js). Buffered requests use the Anthropic conversion
+    // path below regardless.
+    stream: body.stream ?? false,
+  };
+
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    fireworksBody.tools = convertAnthropicToolsToOpenRouter(body.tools);
+    fireworksBody.tool_choice = "auto";
+    fireworksBody.parallel_tool_calls = false;
+  }
+
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.fireworks.apiKey}`,
+  };
+
+  logger.debug({
+    endpoint,
+    model: fireworksBody.model,
+    originalModel: requestedModel,
+    messageCount: fireworksBody.messages?.length || 0,
+    hasTools: !!fireworksBody.tools,
+    toolCount: fireworksBody.tools?.length || 0,
+  }, "=== Fireworks REQUEST ===");
+
+  // No retryableStatusesOverride: Fireworks serverless 429s are standard
+  // per-minute rate limits (unlike Moonshot's persistent org quotas), so the
+  // default retry-with-backoff applies. A 429 that survives retries throws
+  // below with status set so tier-fallback climbs instead of hanging.
+  const response = await performJsonRequest(endpoint, {
+    headers,
+    body: fireworksBody,
+  }, "Fireworks");
+
+  if (!response.ok && response.status === 429) {
+    const err = new Error(`Fireworks rate-limited: ${String(response.json?.error?.message || '').slice(0, 120)}`);
+    err.status = 429;
+    throw err;
+  }
+
+  // Streaming request: hand the raw stream to the orchestrator's stream
+  // branch. The Anthropic conversion below is buffered-only.
+  if (response?.stream) {
+    return response;
+  }
+
+  if (response?.ok && response?.json) {
+    const anthropicJson = convertOpenAIToAnthropic(response.json);
+    return {
+      ok: response.ok,
+      status: response.status,
+      json: anthropicJson,
+      text: JSON.stringify(anthropicJson),
+      contentType: "application/json",
+      headers: response.headers,
+    };
+  }
+
+  return response;
+}
+
 /**
  * Convert OpenAI response to Anthropic format
  */
@@ -2457,12 +2720,34 @@ function convertOpenAIToAnthropic(response) {
   const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
 
   // Extract text content and reasoning from thinking models
-  const textContent = typeof message.content === 'string' ? message.content : '';
+  let textContent = typeof message.content === 'string' ? message.content : '';
   const reasoningContent = typeof message.reasoning_content === 'string' ? message.reasoning_content : '';
 
-  // Emit reasoning_content as a proper thinking block (not discarded)
-  if (reasoningContent) {
-    content.push({ type: "thinking", thinking: reasoningContent });
+  // GLM-family models leak reasoning into `content` in two shapes:
+  //   1. matched <think>...</think> pairs;
+  //   2. an ORPHAN closing </think> — GLM's chat template opens <think>
+  //      inside the prompt, so the completion starts mid-reasoning and only
+  //      emits the closer (observed live 2026-08-23, baidu/glm-5.2:
+  //      "Hi. What need?</think>Hi. What need?" reached the client verbatim).
+  let leakedThinking = '';
+  if (textContent.includes('</think>')) {
+    if (textContent.includes('<think>')) {
+      const thoughts = [];
+      textContent = textContent
+        .replace(/<think>([\s\S]*?)<\/think>/g, (_, t) => { thoughts.push(t.trim()); return ''; })
+        .trim();
+      leakedThinking = thoughts.filter(Boolean).join('\n\n');
+    } else {
+      const idx = textContent.indexOf('</think>');
+      leakedThinking = textContent.slice(0, idx).trim();
+      textContent = textContent.slice(idx + '</think>'.length).trim();
+    }
+  }
+
+  // Emit reasoning (side-channel and/or leaked) as a proper thinking block
+  const combinedThinking = [reasoningContent, leakedThinking].filter(Boolean).join('\n\n');
+  if (combinedThinking) {
+    content.push({ type: "thinking", thinking: combinedThinking });
   }
 
   if (textContent) {
@@ -2558,7 +2843,7 @@ function sanitizeSchemaForGemini(schema) {
  * (generativelanguage.googleapis.com), not Google Cloud Vertex AI.
  * Converts Anthropic format to Gemini format and back.
  */
-async function invokeVertex(body, incomingHeaders = {}) {
+async function invokeVertex(body, _incomingHeaders = {}) {
   const apiKey = config.vertex?.apiKey;
 
   if (!apiKey) {
@@ -2803,7 +3088,7 @@ function convertGeminiToAnthropic(response, requestedModel) {
   };
 }
 
-async function invokeCodex(body, incomingHeaders = {}) {
+async function invokeCodex(body, _incomingHeaders = {}) {
   const { getCodexProcess } = require("./codex-process");
   const { convertAnthropicToCodexPrompt, convertCodexResponseToAnthropic } = require("./codex-utils");
 
@@ -2927,7 +3212,6 @@ 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;
 
@@ -2938,7 +3222,6 @@ function stripLynkrBadges(messages) {
       if (!LYNKR_BADGE_PREFIX_RE.test(msg.content)) return msg;
       const stripped = msg.content.replace(LYNKR_BADGE_PREFIX_RE, '');
       mutated = true;
-      badgeCount++;
       // 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).
@@ -2957,7 +3240,6 @@ function stripLynkrBadges(messages) {
       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
@@ -3003,6 +3285,7 @@ const PROVIDER_INVOKERS = {
   moonshot: invokeMoonshot,
   codex: invokeCodex,
   baidu: invokeBaidu,
+  fireworks: invokeFireworks,
 };
 
 function invokeProvider(provider, body, incomingHeaders) {
@@ -3264,6 +3547,7 @@ async function invokeModel(body, options = {}) {
       base_tier: routingResult.base_tier ?? null,
       escalation_source: routingResult.escalation_source ?? null,
       propensity: routingResult.propensity ?? null,
+      context: routingResult._banditContext ?? null,
       candidates: routingResult.candidates ?? null,
       pinned: routingResult.pinned ? 1 : 0,
       switch_reason: routingResult.switch_reason ?? null,
@@ -3498,6 +3782,7 @@ async function invokeModel(body, options = {}) {
         base_tier: routingResult.base_tier ?? null,
         escalation_source: routingResult.escalation_source ?? null,
         propensity: routingResult.propensity ?? null,
+      context: routingResult._banditContext ?? null,
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
@@ -3610,6 +3895,7 @@ async function invokeModel(body, options = {}) {
           base_tier: routingResult.base_tier ?? null,
           escalation_source: routingResult.escalation_source ?? null,
           propensity: routingResult.propensity ?? null,
+      context: routingResult._banditContext ?? null,
           candidates: routingResult.candidates ?? null,
           pinned: routingResult.pinned ? 1 : 0,
           switch_reason: routingResult.switch_reason ?? null,
@@ -3706,6 +3992,7 @@ async function invokeModel(body, options = {}) {
         base_tier: routingResult.base_tier ?? null,
         escalation_source: routingResult.escalation_source ?? null,
         propensity: routingResult.propensity ?? null,
+      context: routingResult._banditContext ?? null,
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
@@ -3766,6 +4053,7 @@ async function invokeModel(body, options = {}) {
         base_tier: routingResult.base_tier ?? null,
         escalation_source: routingResult.escalation_source ?? null,
         propensity: routingResult.propensity ?? null,
+      context: routingResult._banditContext ?? null,
         candidates: routingResult.candidates ?? null,
         pinned: routingResult.pinned ? 1 : 0,
         switch_reason: routingResult.switch_reason ?? null,
@@ -3860,11 +4148,14 @@ function destroyHttpAgents() {
 
 module.exports = {
   invokeModel,
+  computeCostUsd,
+  convertOpenAIToAnthropic,
   invokeAzureAnthropic,
   invokeZai,
   invokeOllama,
   invokeMoonshot,
   invokeBaidu,
+  invokeFireworks,
   invokeAtlas,
   PROVIDER_INVOKERS,
   stripLynkrBadges,