n9router 0.4.44 → 0.4.45

package/app/open-sse/translator/concerns/usage.js

@@ -0,0 +1,69 @@
+// Build OpenAI usage object. Caller computes prompt/completion/total (provider math).
+// Optional details added only when > 0 (matches existing claude/gemini/codex behavior).
+export function buildUsage({ promptTokens, completionTokens, totalTokens, cachedTokens = 0, cacheCreationTokens = 0, reasoningTokens = 0 }) {
+  const usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: totalTokens };
+  if (cachedTokens > 0 || cacheCreationTokens > 0) {
+    usage.prompt_tokens_details = {};
+    if (cachedTokens > 0) usage.prompt_tokens_details.cached_tokens = cachedTokens;
+    if (cacheCreationTokens > 0) usage.prompt_tokens_details.cache_creation_tokens = cacheCreationTokens;
+  }
+  if (reasoningTokens > 0) {
+    usage.completion_tokens_details = { reasoning_tokens: reasoningTokens };
+  }
+  return usage;
+}
+
+const n = (v) => (typeof v === "number" ? v : 0);
+
+// Per-provider raw token field-map + math. Returns buildUsage() args (NOT the usage object).
+// Keeps each provider's exact semantics: claude/gemini fold cache+reasoning, others don't.
+const USAGE_EXTRACTORS = {
+  claude(raw) {
+    const input = n(raw.input_tokens), output = n(raw.output_tokens);
+    const cacheRead = n(raw.cache_read_input_tokens), cacheCreate = n(raw.cache_creation_input_tokens);
+    const prompt = input + cacheRead + cacheCreate;
+    return { promptTokens: prompt, completionTokens: output, totalTokens: prompt + output, cachedTokens: cacheRead, cacheCreationTokens: cacheCreate };
+  },
+  gemini(raw) {
+    const cached = n(raw.cachedContentTokenCount);
+    const prompt = n(raw.promptTokenCount);
+    const thoughts = n(raw.thoughtsTokenCount);
+    const total = n(raw.totalTokenCount);
+    let candidates = n(raw.candidatesTokenCount);
+    // Fallback: derive candidates from total when upstream omits it
+    if (candidates === 0 && total > 0) {
+      candidates = total - prompt - thoughts;
+      if (candidates < 0) candidates = 0;
+    }
+    return { promptTokens: prompt, completionTokens: candidates + thoughts, totalTokens: total, cachedTokens: cached, reasoningTokens: thoughts };
+  },
+  kiro(raw) {
+    const input = n(raw.inputTokens), output = n(raw.outputTokens);
+    // ponytail: Amazon Q (Kiro upstream) does not expose cache fields today,
+    // but pass through any cache_read/cache_creation/cached_tokens if the
+    // event shape grows them later so cost tracking keeps working without
+    // a second pass.
+    const cached = n(raw.cache_read_input_tokens) || n(raw.cachedTokens) || n(raw.cached_tokens);
+    const cacheCreation = n(raw.cache_creation_input_tokens);
+    const out = { promptTokens: input, completionTokens: output, totalTokens: input + output };
+    if (cached > 0) out.cachedTokens = cached;
+    if (cacheCreation > 0) out.cacheCreationTokens = cacheCreation;
+    return out;
+  },
+  ollama(raw) {
+    const input = n(raw.prompt_eval_count), output = n(raw.eval_count);
+    return { promptTokens: input, completionTokens: output, totalTokens: input + output };
+  },
+  commandcode(raw) {
+    const input = n(raw.inputTokens), output = n(raw.outputTokens);
+    const total = typeof raw.totalTokens === "number" ? raw.totalTokens : input + output;
+    return { promptTokens: input, completionTokens: output, totalTokens: total };
+  },
+};
+
+// Convert provider-native usage object → OpenAI usage. Returns null if no extractor/raw.
+export function toOpenAIUsage(raw, kind) {
+  const extract = USAGE_EXTRACTORS[kind];
+  if (!extract || !raw || typeof raw !== "object") return null;
+  return buildUsage(extract(raw));
+}

package/app/open-sse/translator/formats/claude.js

@@ -0,0 +1,351 @@
+// Claude helper functions for translator
+import { DEFAULT_THINKING_CLAUDE_SIGNATURE } from "../../config/defaultThinkingSignature.js";
+import { ROLE, CLAUDE_BLOCK } from "../schema/index.js";
+import { adjustMaxTokens } from "./maxTokens.js";
+import { applyCloaking } from "../../utils/claudeCloaking.js";
+import { resolveSessionId } from "../../utils/sessionManager.js";
+import { isValidClaudeSignature } from "../../utils/claudeSignature.js";
+import { PROVIDERS } from "../../providers/index.js";
+import { getCapabilitiesForModel } from "../../providers/capabilities.js";
+import { DEFAULT_MAX_TOKENS } from "../../config/runtimeConfig.js";
+
+// Check if message has valid non-empty content
+export function hasValidContent(msg) {
+  if (typeof msg.content === "string" && msg.content.trim()) return true;
+  if (Array.isArray(msg.content)) {
+    return msg.content.some(block =>
+      (block.type === CLAUDE_BLOCK.TEXT && block.text?.trim()) ||
+      block.type === CLAUDE_BLOCK.TOOL_USE ||
+      block.type === CLAUDE_BLOCK.TOOL_RESULT
+    );
+  }
+  return false;
+}
+
+// Fix tool_use/tool_result ordering for Claude API
+// 1. Assistant message with tool_use: remove text AFTER tool_use (Claude doesn't allow)
+// 2. Merge consecutive same-role messages
+export function fixToolUseOrdering(messages) {
+  if (messages.length <= 1) return messages;
+
+  // Pass 1: Fix assistant messages with tool_use - remove text after tool_use
+  for (const msg of messages) {
+    if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
+      const hasToolUse = msg.content.some(b => b.type === CLAUDE_BLOCK.TOOL_USE);
+      if (hasToolUse) {
+        // Keep only: thinking blocks + tool_use blocks (remove text blocks after tool_use)
+        const newContent = [];
+        let foundToolUse = false;
+
+        for (const block of msg.content) {
+          if (block.type === CLAUDE_BLOCK.TOOL_USE) {
+            foundToolUse = true;
+            newContent.push(block);
+          } else if (block.type === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING) {
+            newContent.push(block);
+          } else if (!foundToolUse) {
+            // Keep text blocks BEFORE tool_use
+            newContent.push(block);
+          }
+          // Skip text blocks AFTER tool_use
+        }
+
+        msg.content = newContent;
+      }
+    }
+  }
+
+  // Pass 2: Merge consecutive same-role messages
+  const merged = [];
+
+  for (const msg of messages) {
+    const last = merged[merged.length - 1];
+
+    if (last && last.role === msg.role) {
+      // Merge content arrays
+      const lastContent = Array.isArray(last.content) ? last.content : [{ type: CLAUDE_BLOCK.TEXT, text: last.content }];
+      const msgContent = Array.isArray(msg.content) ? msg.content : [{ type: CLAUDE_BLOCK.TEXT, text: msg.content }];
+
+      // Put tool_result first, then other content
+      const toolResults = [...lastContent.filter(b => b.type === CLAUDE_BLOCK.TOOL_RESULT), ...msgContent.filter(b => b.type === CLAUDE_BLOCK.TOOL_RESULT)];
+      const otherContent = [...lastContent.filter(b => b.type !== CLAUDE_BLOCK.TOOL_RESULT), ...msgContent.filter(b => b.type !== CLAUDE_BLOCK.TOOL_RESULT)];
+
+      last.content = [...toolResults, ...otherContent];
+    } else {
+      // Ensure content is array
+      const content = Array.isArray(msg.content) ? msg.content : [{ type: CLAUDE_BLOCK.TEXT, text: msg.content }];
+      merged.push({ role: msg.role, content: [...content] });
+    }
+  }
+
+  return merged;
+}
+
+// Models that reject thinking.type "adaptive" + output_config.effort (Opus 4.5+/Sonnet 4.6+ only)
+const ADAPTIVE_THINKING_UNSUPPORTED = /haiku/i;
+
+function handlesThinkingBlocks(provider) {
+  return provider === "claude" || provider?.startsWith("anthropic-compatible") || provider === "deepseek";
+}
+
+function buildThinkingPlaceholder(provider) {
+  const block = {
+    type: CLAUDE_BLOCK.THINKING,
+    thinking: ".",
+  };
+
+  // DeepSeek's Anthropic-compatible endpoint requires a thinking block in
+  // thinking mode, but it does not need Anthropic's signed-thinking fallback.
+  if (provider !== "deepseek") {
+    block.signature = DEFAULT_THINKING_CLAUDE_SIGNATURE;
+  }
+
+  return block;
+}
+
+// Normalize a native Claude passthrough body to match Anthropic Messages API spec.
+// Newer Cowork/Claude Code clients emit beta-only shapes that OAuth endpoints reject:
+// 1. thinking.type "adaptive" → unsupported on Haiku
+// 2. output_config.effort → unsupported on Haiku
+// 3. role "system" messages (mid-conversation-system beta) → only top-level system is allowed
+export function normalizeClaudePassthrough(body, model = "") {
+  if (!body || typeof body !== "object") return body;
+
+  // 1. Downgrade adaptive thinking for models that don't support it
+  if (body.thinking?.type === "adaptive" && ADAPTIVE_THINKING_UNSUPPORTED.test(model)) {
+    body.thinking = { type: "enabled", budget_tokens: 10000 };
+  }
+
+  // 2. Strip effort param for models that don't support it (keep other output_config fields)
+  if (ADAPTIVE_THINKING_UNSUPPORTED.test(model) && body.output_config?.effort != null) {
+    delete body.output_config.effort;
+    if (Object.keys(body.output_config).length === 0) delete body.output_config;
+  }
+
+  // 2. Hoist mid-conversation system messages into the top-level system field
+  if (Array.isArray(body.messages)) {
+    const systemBlocks = [];
+    const messages = [];
+    for (const msg of body.messages) {
+      if (msg.role === ROLE.SYSTEM) {
+        const text = typeof msg.content === "string"
+          ? msg.content
+          : Array.isArray(msg.content)
+            ? msg.content.map(b => (typeof b === "string" ? b : b?.text || "")).join("\n")
+            : "";
+        if (text.trim()) systemBlocks.push({ type: CLAUDE_BLOCK.TEXT, text });
+        continue;
+      }
+      messages.push(msg);
+    }
+
+    if (systemBlocks.length > 0) {
+      const existing = Array.isArray(body.system)
+        ? body.system
+        : typeof body.system === "string" && body.system.trim()
+          ? [{ type: "text", text: body.system }]
+          : [];
+      body.system = [...existing, ...systemBlocks];
+      body.messages = messages;
+    }
+  }
+
+  // 3. Drop thinking blocks whose signature is not Claude's (combo mixes models,
+  // so foreign signatures leak into history and Anthropic rejects them).
+  const thinkingEnabled = body.thinking?.type === "enabled";
+  if (Array.isArray(body.messages)) {
+    for (const msg of body.messages) {
+      if (msg.role !== ROLE.ASSISTANT || !Array.isArray(msg.content)) continue;
+      let hasToolUse = false;
+      let hasKeptThinking = false;
+      const kept = [];
+      for (const block of msg.content) {
+        if (block.type === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING) {
+          if (isValidClaudeSignature(block.signature)) {
+            hasKeptThinking = true;
+            kept.push(block);
+          }
+          continue;
+        }
+        if (block.type === CLAUDE_BLOCK.TOOL_USE) hasToolUse = true;
+        kept.push(block);
+      }
+      msg.content = kept;
+      if (thinkingEnabled && !hasKeptThinking && hasToolUse) {
+        msg.content.unshift(buildThinkingPlaceholder("claude"));
+      }
+    }
+  }
+
+  return body;
+}
+
+// Prepare request for Claude format endpoints
+// - Cleanup cache_control
+// - Filter empty messages
+// - Add thinking block for Anthropic endpoint (provider === "claude")
+// - Fix tool_use/tool_result ordering
+// - Apply cloaking (billing header + fake user ID) for OAuth tokens
+export function prepareClaudeRequest(body, provider = null, apiKey = null, connectionId = null, rawHeaders = null, sessionId = null) {
+  // quirk: MiniMax's Claude-compatible endpoint rejects Anthropic's output_config (400 invalid params)
+  if (PROVIDERS[provider]?.quirks?.dropOutputConfig) {
+    delete body.output_config;
+  }
+
+  // Clamp max_tokens to the model output ceiling (never above DEFAULT_MAX_TOKENS)
+  if (body.max_tokens) {
+    const ceiling = Math.min(getCapabilitiesForModel(provider, body.model).maxOutput, DEFAULT_MAX_TOKENS);
+    if (body.max_tokens > ceiling) body.max_tokens = ceiling;
+  }
+
+  // 1. System: remove all cache_control, add only to last block with ttl 1h
+  if (body.system && Array.isArray(body.system)) {
+    body.system = body.system.map((block, i) => {
+      const { cache_control, ...rest } = block;
+      if (i === body.system.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+  }
+
+  // 2. Messages: process in optimized passes
+  if (body.messages && Array.isArray(body.messages)) {
+    const len = body.messages.length;
+    let filtered = [];
+
+    // Pass 1: remove cache_control + filter empty messages
+    for (let i = 0; i < len; i++) {
+      const msg = body.messages[i];
+
+      // Remove cache_control from content blocks
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          delete block.cache_control;
+        }
+      }
+
+      // Keep final assistant even if empty, otherwise check valid content
+      const isFinalAssistant = i === len - 1 && msg.role === "assistant";
+      if (isFinalAssistant || hasValidContent(msg)) {
+        filtered.push(msg);
+      }
+    }
+
+    // Pass 1.5: Fix tool_use/tool_result ordering
+    // Each tool_use must have tool_result in the NEXT message (not same message with other content)
+    filtered = fixToolUseOrdering(filtered);
+
+    body.messages = filtered;
+
+    // Check if thinking is enabled AND last message is from user
+    const lastMessage = filtered[filtered.length - 1];
+    const lastMessageIsUser = lastMessage?.role === "user";
+    const thinkingEnabled = body.thinking?.type === "enabled" && lastMessageIsUser;
+
+    // Pass 2 (reverse): add cache_control to last assistant + handle thinking for Anthropic
+    let lastAssistantProcessed = false;
+    for (let i = filtered.length - 1; i >= 0; i--) {
+      const msg = filtered[i];
+
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        // Add cache_control to last non-thinking block of first (from end) assistant with content
+        // thinking/redacted_thinking blocks do not support cache_control
+        if (!lastAssistantProcessed && msg.content.length > 0) {
+          for (let j = msg.content.length - 1; j >= 0; j--) {
+            const block = msg.content[j];
+            if (block.type !== CLAUDE_BLOCK.THINKING && block.type !== CLAUDE_BLOCK.REDACTED_THINKING) {
+              block.cache_control = { type: "ephemeral" };
+              break;
+            }
+          }
+          lastAssistantProcessed = true;
+        }
+
+        // Handle thinking blocks for Anthropic-compatible endpoints.
+        if (handlesThinkingBlocks(provider)) {
+          let hasToolUse = false;
+          let hasKeptThinking = false;
+
+          // Claude native: preserve valid signatures, drop invalid blocks.
+          // anthropic-compatible: replace with default (safe fallback for lenient upstreams).
+          // DeepSeek: keep existing thinking as-is; add an unsigned placeholder only if missing.
+          const isClaudeNative = provider === "claude";
+          const isDeepSeek = provider === "deepseek";
+          const kept = [];
+          for (const block of msg.content) {
+            const isThinking = block.type === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING;
+            if (isThinking) {
+              if (isClaudeNative) {
+                if (isValidClaudeSignature(block.signature)) {
+                  hasKeptThinking = true;
+                  kept.push(block);
+                }
+              } else if (isDeepSeek) {
+                hasKeptThinking = true;
+                kept.push(block);
+              } else {
+                block.signature = DEFAULT_THINKING_CLAUDE_SIGNATURE;
+                hasKeptThinking = true;
+                kept.push(block);
+              }
+              continue;
+            }
+            if (block.type === CLAUDE_BLOCK.TOOL_USE) hasToolUse = true;
+            kept.push(block);
+          }
+          msg.content = kept;
+
+          // Add thinking block if thinking enabled + has tool_use but no thinking
+          if (thinkingEnabled && !hasKeptThinking && hasToolUse) {
+            msg.content.unshift(buildThinkingPlaceholder(provider));
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Tools: filter built-in tools for non-Anthropic providers, then handle cache_control
+  if (body.tools && Array.isArray(body.tools)) {
+    // Strip built-in tools (e.g. web_search_20250305) and normalize to Anthropic-native shape
+    // (drop `type` field, fold `function.{name,description,parameters}`) for non-Anthropic providers
+    if (provider !== "claude") {
+      body.tools = body.tools
+        .filter(tool => !tool.type || tool.type === "function")
+        .map(tool => {
+          if (tool.function) {
+            return {
+              name: tool.function.name,
+              description: tool.function.description,
+              input_schema: tool.function.parameters,
+            };
+          }
+          const { type, ...rest } = tool;
+          return rest;
+        });
+    }
+
+    body.tools = body.tools.map((tool, i) => {
+      const { cache_control, ...rest } = tool;
+      if (i === body.tools.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+
+    // Remove tools array and tool_choice if empty after filtering
+    if (body.tools.length === 0) {
+      delete body.tools;
+      delete body.tool_choice;
+    }
+  }
+
+  // Apply cloaking for OAuth tokens (billing header + fake user ID)
+  // session_id in user_id must match X-Claude-Code-Session-Id for fingerprint consistency
+  if ((provider === "claude" || provider?.startsWith("anthropic-compatible")) && apiKey) {
+    const sid = sessionId || resolveSessionId({ headers: rawHeaders, body, connectionId, scope: "claude" });
+    body = applyCloaking(body, apiKey, sid);
+  }
+
+  return body;
+}

package/app/open-sse/translator/{helpers/geminiHelper.js → formats/gemini.js}

@@ -1,14 +1,19 @@
 // Gemini helper functions for translator
 
+import { safeParseJSON } from "../concerns/json.js";
+import { OPENAI_BLOCK } from "../schema/index.js";
+
 // Unsupported JSON Schema constraints that should be removed for Antigravity
 export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
   // Basic constraints (not supported by Gemini API)
   "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
-  "pattern", "minItems", "maxItems", "format",
+  "minItems", "maxItems", "format",
   // Claude rejects these in VALIDATED mode
   "default", "examples",
   // JSON Schema meta keywords
   "$schema", "$defs", "definitions", "const", "$ref", "$comment",
+  // Annotation keywords (rejected by Gemini/Antigravity - e.g. MCP tool schemas set these)
+  "deprecated", "readOnly", "writeOnly",
   // Object validation keywords (not supported)
   "additionalProperties", "propertyNames", "patternProperties", "enumDescriptions",
   // Complex schema keywords (handled by flattenAnyOfOneOf/mergeAllOf)
@@ -16,7 +21,7 @@ export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
   // Dependency keywords (not supported)
   "dependencies", "dependentSchemas", "dependentRequired",
   // Other unsupported keywords
-  "title", "if", "then", "else", "contentMediaType", "contentEncoding",
+  "title", "optional", "deprecated", "if", "then", "else", "contentMediaType", "contentEncoding",
   // UI/Styling properties (from Cursor tools - NOT JSON Schema standard)
   "cornerRadius", "fillColor", "fontFamily", "fontSize", "fontWeight",
   "gap", "padding", "strokeColor", "strokeThickness", "textColor"
@@ -39,9 +44,9 @@ export function convertOpenAIContentToParts(content) {
     parts.push({ text: content });
   } else if (Array.isArray(content)) {
     for (const item of content) {
-      if (item.type === "text") {
+      if (item.type === OPENAI_BLOCK.TEXT) {
         parts.push({ text: item.text });
-      } else if (item.type === "image_url" && item.image_url?.url?.startsWith("data:")) {
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url?.startsWith("data:")) {
         const url = item.image_url.url;
         const commaIndex = url.indexOf(",");
         if (commaIndex !== -1) {
@@ -53,17 +58,17 @@ export function convertOpenAIContentToParts(content) {
             inlineData: { mime_type: mimeType, data: data }
           });
         }
-      } else if (item.type === "image_url" && item.image_url?.url && (item.image_url.url.startsWith("http://") || item.image_url.url.startsWith("https://"))) {
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url && (item.image_url.url.startsWith("http://") || item.image_url.url.startsWith("https://"))) {
         parts.push({
           fileData: { fileUri: item.image_url.url, mimeType: "image/*" }
         });
-      } else if (item.type === "input_audio" && item.input_audio?.data) {
+      } else if (item.type === OPENAI_BLOCK.INPUT_AUDIO && item.input_audio?.data) {
         const format = item.input_audio.format || "wav";
         const mimeType = format === "mp3" ? "audio/mpeg" : `audio/${format}`;
         parts.push({
           inlineData: { mime_type: mimeType, data: item.input_audio.data }
         });
-      } else if (item.type === "audio_url" && item.audio_url?.url?.startsWith("data:")) {
+      } else if (item.type === OPENAI_BLOCK.AUDIO_URL && item.audio_url?.url?.startsWith("data:")) {
         const url = item.audio_url.url;
         const commaIndex = url.indexOf(",");
         if (commaIndex !== -1) {
@@ -74,6 +79,14 @@ export function convertOpenAIContentToParts(content) {
             inlineData: { mime_type: mimeType, data: data }
           });
         }
+      } else if (item.type === OPENAI_BLOCK.FILE && item.file?.file_data?.startsWith("data:")) {
+        const url = item.file.file_data;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimeType = url.substring(5, commaIndex).split(";")[0];
+          const data = url.substring(commaIndex + 1);
+          parts.push({ inlineData: { mime_type: mimeType, data: data } });
+        }
       }
     }
   }
@@ -82,22 +95,17 @@ export function convertOpenAIContentToParts(content) {
 }
 
 // Extract text content from OpenAI content
-export function extractTextContent(content) {
+export function extractTextContent(content, separator = "") {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
-    return content.filter(c => c.type === "text").map(c => c.text).join("");
+    return content.filter(c => c.type === OPENAI_BLOCK.TEXT).map(c => c.text).join(separator);
   }
   return "";
 }
 
-// Try parse JSON safely
+// Try parse JSON safely (null fallback on parse error; re-export keeps legacy API)
 export function tryParseJSON(str) {
-  if (typeof str !== "string") return str;
-  try {
-    return JSON.parse(str);
-  } catch {
-    return null;
-  }
+  return safeParseJSON(str, null);
 }
 
 // Generate request ID

package/app/open-sse/translator/{helpers/maxTokensHelper.js → formats/maxTokens.js}

@@ -8,7 +8,7 @@ import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConf
 export function adjustMaxTokens(body) {
   let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
 
-  // Auto-increase for tool calling to prevent truncated arguments
+  // Auto-increase for tool calling to prevent truncated arguments (min never above max)
   if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
     if (maxTokens < DEFAULT_MIN_TOKENS) {
       maxTokens = DEFAULT_MIN_TOKENS;
@@ -22,6 +22,9 @@ export function adjustMaxTokens(body) {
     maxTokens = body.thinking.budget_tokens + 1024;
   }
 
+  // Never exceed the global ceiling
+  if (maxTokens > DEFAULT_MAX_TOKENS) maxTokens = DEFAULT_MAX_TOKENS;
+
   return maxTokens;
 }