@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/translator/formats.js

@@ -1,36 +0,0 @@
-// Format identifiers
-export const FORMATS = {
-  OPENAI: "openai",
-  OPENAI_RESPONSES: "openai-responses",
-  OPENAI_RESPONSE: "openai-response",
-  CLAUDE: "claude",
-  GEMINI: "gemini",
-  GEMINI_CLI: "gemini-cli",
-  VERTEX: "vertex",
-  CODEX: "codex",
-  ANTIGRAVITY: "antigravity",
-  KIRO: "kiro",
-  CURSOR: "cursor",
-  OLLAMA: "ollama",
-  COMMANDCODE: "commandcode"
-};
-
-/**
- * Detect source format from request URL pathname + body.
- * Returns null to fall back to body-based detection.
- */
-export function detectFormatByEndpoint(pathname, body) {
-  // /v1/responses is always openai-responses
-  if (pathname.includes("/v1/responses")) return FORMATS.OPENAI_RESPONSES;
-
-  // /v1/messages is always Claude
-  if (pathname.includes("/v1/messages")) return FORMATS.CLAUDE;
-
-  // /v1/chat/completions + input[] → treat as openai (Cursor CLI sends Responses body via chat endpoint)
-  if (pathname.includes("/v1/chat/completions") && Array.isArray(body?.input)) {
-    return FORMATS.OPENAI;
-  }
-
-  return null;
-}
-

package/open-sse/translator/helpers/claudeHelper.js

@@ -1,216 +0,0 @@
-// Claude helper functions for translator
-import { DEFAULT_THINKING_CLAUDE_SIGNATURE } from "../../config/defaultThinkingSignature.js";
-import { adjustMaxTokens } from "./maxTokensHelper.js";
-import { applyCloaking } from "../../utils/claudeCloaking.js";
-import { deriveSessionId } from "../../utils/sessionManager.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 === "text" && block.text?.trim()) ||
-      block.type === "tool_use" ||
-      block.type === "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 === "assistant" && Array.isArray(msg.content)) {
-      const hasToolUse = msg.content.some(b => b.type === "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 === "tool_use") {
-            foundToolUse = true;
-            newContent.push(block);
-          } else if (block.type === "thinking" || block.type === "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: "text", text: last.content }];
-      const msgContent = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
-
-      // Put tool_result first, then other content
-      const toolResults = [...lastContent.filter(b => b.type === "tool_result"), ...msgContent.filter(b => b.type === "tool_result")];
-      const otherContent = [...lastContent.filter(b => b.type !== "tool_result"), ...msgContent.filter(b => b.type !== "tool_result")];
-
-      last.content = [...toolResults, ...otherContent];
-    } else {
-      // Ensure content is array
-      const content = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
-      merged.push({ role: msg.role, content: [...content] });
-    }
-  }
-
-  return merged;
-}
-
-const CLAUDE_FORMAT_PROVIDERS_WITHOUT_OUTPUT_CONFIG = new Set(["minimax", "minimax-cn"]);
-
-// 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) {
-  // MiniMax exposes a Claude-compatible endpoint but rejects Anthropic's extended
-  // structured output parameter with a generic 400 "invalid params" response.
-  if (CLAUDE_FORMAT_PROVIDERS_WITHOUT_OUTPUT_CONFIG.has(provider)) {
-    delete body.output_config;
-  }
-
-  // 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 !== "thinking" && block.type !== "redacted_thinking") {
-              block.cache_control = { type: "ephemeral" };
-              break;
-            }
-          }
-          lastAssistantProcessed = true;
-        }
-
-        // Handle thinking blocks for Anthropic endpoint only
-        if (provider === "claude" || provider?.startsWith("anthropic-compatible")) {
-          let hasToolUse = false;
-          let hasThinking = false;
-
-          // Always replace signature for all thinking blocks
-          for (const block of msg.content) {
-            if (block.type === "thinking" || block.type === "redacted_thinking") {
-              block.signature = DEFAULT_THINKING_CLAUDE_SIGNATURE;
-              hasThinking = true;
-            }
-            if (block.type === "tool_use") hasToolUse = true;
-          }
-
-          // Add thinking block if thinking enabled + has tool_use but no thinking
-          if (thinkingEnabled && !hasThinking && hasToolUse) {
-            msg.content.unshift({
-              type: "thinking",
-              thinking: ".",
-              signature: DEFAULT_THINKING_CLAUDE_SIGNATURE
-            });
-          }
-        }
-      }
-    }
-  }
-
-  // 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) for providers that don't support them
-    if (provider !== "claude") {
-      body.tools = body.tools.filter(tool => !tool.type || tool.type === "function");
-    }
-
-    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 sessionId = connectionId ? deriveSessionId(connectionId) : null;
-    body = applyCloaking(body, apiKey, sessionId);
-  }
-
-  return body;
-}
-

package/open-sse/translator/helpers/geminiHelper.js

@@ -1,372 +0,0 @@
-// Gemini helper functions for translator
-
-// 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",
-  // Claude rejects these in VALIDATED mode
-  "default", "examples",
-  // JSON Schema meta keywords
-  "$schema", "$defs", "definitions", "const", "$ref", "$comment",
-  // Object validation keywords (not supported)
-  "additionalProperties", "propertyNames", "patternProperties", "enumDescriptions",
-  // Complex schema keywords (handled by flattenAnyOfOneOf/mergeAllOf)
-  "anyOf", "oneOf", "allOf", "not",
-  // Dependency keywords (not supported)
-  "dependencies", "dependentSchemas", "dependentRequired",
-  // Other unsupported keywords
-  "title", "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"
-];
-
-// Default safety settings
-export const DEFAULT_SAFETY_SETTINGS = [
-  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
-  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
-  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
-  { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
-  { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
-];
-
-// Convert OpenAI content to Gemini parts
-export function convertOpenAIContentToParts(content) {
-  const parts = [];
-
-  if (typeof content === "string") {
-    parts.push({ text: content });
-  } else if (Array.isArray(content)) {
-    for (const item of content) {
-      if (item.type === "text") {
-        parts.push({ text: item.text });
-      } else if (item.type === "image_url" && item.image_url?.url?.startsWith("data:")) {
-        const url = item.image_url.url;
-        const commaIndex = url.indexOf(",");
-        if (commaIndex !== -1) {
-          const mimePart = url.substring(5, commaIndex); // skip "data:"
-          const data = url.substring(commaIndex + 1);
-          const mimeType = mimePart.split(";")[0];
-
-          parts.push({
-            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://"))) {
-        parts.push({
-          fileData: { fileUri: item.image_url.url, mimeType: "image/*" }
-        });
-      } else if (item.type === "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:")) {
-        const url = item.audio_url.url;
-        const commaIndex = url.indexOf(",");
-        if (commaIndex !== -1) {
-          const mimePart = url.substring(5, commaIndex);
-          const data = url.substring(commaIndex + 1);
-          const mimeType = mimePart.split(";")[0];
-          parts.push({
-            inlineData: { mime_type: mimeType, data: data }
-          });
-        }
-      }
-    }
-  }
-
-  return parts;
-}
-
-// Extract text content from OpenAI content
-export function extractTextContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.filter(c => c.type === "text").map(c => c.text).join("");
-  }
-  return "";
-}
-
-// Try parse JSON safely
-export function tryParseJSON(str) {
-  if (typeof str !== "string") return str;
-  try {
-    return JSON.parse(str);
-  } catch {
-    return null;
-  }
-}
-
-// Generate request ID
-export function generateRequestId() {
-  return `agent-${crypto.randomUUID()}`;
-}
-
-// Generate session ID (binary-compatible format: UUID + timestamp)
-export function generateSessionId() {
-  return crypto.randomUUID() + Date.now().toString();
-}
-
-// Generate project ID
-export function generateProjectId() {
-  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
-  const nouns = ["fuze", "wave", "spark", "flow", "core"];
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
-  return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
-}
-
-// Helper: Remove unsupported keywords recursively from object/array
-// Also strips all vendor extension fields (x- prefixed) not supported by Gemini
-function removeUnsupportedKeywords(obj, keywords) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (Array.isArray(obj)) {
-    for (const item of obj) {
-      removeUnsupportedKeywords(item, keywords);
-    }
-    return;
-  }
-
-  for (const key of Object.keys(obj)) {
-    if (keywords.includes(key) || key.startsWith("x-")) {
-      delete obj[key];
-      continue;
-    }
-
-    const value = obj[key];
-    if (value && typeof value === "object") {
-      removeUnsupportedKeywords(value, keywords);
-    }
-  }
-}
-
-// Convert const to enum
-function convertConstToEnum(obj) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (obj.const !== undefined && !obj.enum) {
-    obj.enum = [obj.const];
-    delete obj.const;
-  }
-
-  for (const value of Object.values(obj)) {
-    if (value && typeof value === "object") {
-      convertConstToEnum(value);
-    }
-  }
-}
-
-// Convert enum values to strings (Gemini requires string enum values + explicit type:"string")
-function convertEnumValuesToStrings(obj) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (obj.enum && Array.isArray(obj.enum)) {
-    obj.enum = obj.enum.map(v => String(v));
-    // Gemini API requires type:"string" when enum is present — without it returns 400
-    if (!obj.type) {
-      obj.type = "string";
-    }
-  }
-
-  for (const value of Object.values(obj)) {
-    if (value && typeof value === "object") {
-      convertEnumValuesToStrings(value);
-    }
-  }
-}
-
-// Merge allOf schemas
-function mergeAllOf(obj) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (obj.allOf && Array.isArray(obj.allOf)) {
-    const merged = {};
-
-    for (const item of obj.allOf) {
-      if (item.properties) {
-        if (!merged.properties) merged.properties = {};
-        Object.assign(merged.properties, item.properties);
-      }
-      if (item.required && Array.isArray(item.required)) {
-        if (!merged.required) merged.required = [];
-        for (const req of item.required) {
-          if (!merged.required.includes(req)) {
-            merged.required.push(req);
-          }
-        }
-      }
-    }
-
-    delete obj.allOf;
-    if (merged.properties) obj.properties = { ...obj.properties, ...merged.properties };
-    if (merged.required) obj.required = [...(obj.required || []), ...merged.required];
-  }
-
-  for (const value of Object.values(obj)) {
-    if (value && typeof value === "object") {
-      mergeAllOf(value);
-    }
-  }
-}
-
-// Select best schema from anyOf/oneOf
-function selectBest(items) {
-  let bestIdx = 0;
-  let bestScore = -1;
-
-  for (let i = 0; i < items.length; i++) {
-    const item = items[i];
-    let score = 0;
-    const type = item.type;
-
-    if (type === "object" || item.properties) {
-      score = 3;
-    } else if (type === "array" || item.items) {
-      score = 2;
-    } else if (type && type !== "null") {
-      score = 1;
-    }
-
-    if (score > bestScore) {
-      bestScore = score;
-      bestIdx = i;
-    }
-  }
-
-  return bestIdx;
-}
-
-// Flatten anyOf/oneOf
-function flattenAnyOfOneOf(obj) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (obj.anyOf && Array.isArray(obj.anyOf) && obj.anyOf.length > 0) {
-    const nonNullSchemas = obj.anyOf.filter(s => s && s.type !== "null");
-    if (nonNullSchemas.length > 0) {
-      const bestIdx = selectBest(nonNullSchemas);
-      const selected = nonNullSchemas[bestIdx];
-      delete obj.anyOf;
-      Object.assign(obj, selected);
-    }
-  }
-
-  if (obj.oneOf && Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
-    const nonNullSchemas = obj.oneOf.filter(s => s && s.type !== "null");
-    if (nonNullSchemas.length > 0) {
-      const bestIdx = selectBest(nonNullSchemas);
-      const selected = nonNullSchemas[bestIdx];
-      delete obj.oneOf;
-      Object.assign(obj, selected);
-    }
-  }
-
-  for (const value of Object.values(obj)) {
-    if (value && typeof value === "object") {
-      flattenAnyOfOneOf(value);
-    }
-  }
-}
-
-// Flatten type arrays
-function flattenTypeArrays(obj) {
-  if (!obj || typeof obj !== "object") return;
-
-  if (obj.type && Array.isArray(obj.type)) {
-    const nonNullTypes = obj.type.filter(t => t !== "null");
-    obj.type = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
-  }
-
-  for (const value of Object.values(obj)) {
-    if (value && typeof value === "object") {
-      flattenTypeArrays(value);
-    }
-  }
-}
-
-// Infer missing type=object when properties exist (Gemini requires explicit type)
-function ensureObjectType(obj) {
-  if (!obj || typeof obj !== "object") return;
-  if (obj.properties && !obj.type) obj.type = "object";
-  for (const v of Object.values(obj)) if (v && typeof v === "object") ensureObjectType(v);
-}
-
-// Clean JSON Schema for Antigravity API compatibility - removes unsupported keywords recursively
-export function cleanJSONSchemaForAntigravity(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-
-  // Mutate directly (schema is only used once per request)
-  let cleaned = schema;
-
-  // Phase 1: Convert and prepare
-  convertConstToEnum(cleaned);
-  convertEnumValuesToStrings(cleaned);
-
-  // Phase 2: Flatten complex structures
-  mergeAllOf(cleaned);
-  flattenAnyOfOneOf(cleaned);
-  flattenTypeArrays(cleaned);
-
-  // Phase 2.5: Infer missing type=object when properties exist (Gemini requirement)
-  ensureObjectType(cleaned);
-
-  // Phase 3: Remove all unsupported keywords at ALL levels (including inside arrays)
-  removeUnsupportedKeywords(cleaned, UNSUPPORTED_SCHEMA_CONSTRAINTS);
-
-  // Phase 4: Cleanup required fields recursively
-  function cleanupRequired(obj) {
-    if (!obj || typeof obj !== "object") return;
-
-    if (obj.required && Array.isArray(obj.required) && obj.properties) {
-      const validRequired = obj.required.filter(field =>
-        Object.prototype.hasOwnProperty.call(obj.properties, field)
-      );
-      if (validRequired.length === 0) {
-        delete obj.required;
-      } else {
-        obj.required = validRequired;
-      }
-    }
-
-    // Recurse into nested objects
-    for (const value of Object.values(obj)) {
-      if (value && typeof value === "object") {
-        cleanupRequired(value);
-      }
-    }
-  }
-
-  cleanupRequired(cleaned);
-
-  // Phase 5: Add placeholder for empty object schemas (Antigravity requirement)
-  function addPlaceholders(obj) {
-    if (!obj || typeof obj !== "object") return;
-
-    if (obj.type === "object") {
-      if (!obj.properties || Object.keys(obj.properties).length === 0) {
-        obj.properties = {
-          reason: {
-            type: "string",
-            description: "Brief explanation of why you are calling this tool"
-          }
-        };
-        obj.required = ["reason"];
-      }
-    }
-
-    // Recurse into nested objects
-    for (const value of Object.values(obj)) {
-      if (value && typeof value === "object") {
-        addPlaceholders(value);
-      }
-    }
-  }
-
-  addPlaceholders(cleaned);
-
-  return cleaned;
-}
-

package/open-sse/translator/helpers/imageHelper.js

@@ -1,34 +0,0 @@
-/**
- * Fetch a remote image URL and return it as a base64 data URI.
- * Used when upstream providers (Codex, etc.) require inline base64 images
- * instead of remote URLs they cannot fetch.
- * Returns null if fetch fails.
- *
- * @param {string} imageUrl - HTTP(S) URL of the image
- * @param {object} options - { signal, timeoutMs }
- * @returns {Promise<{url: string, mimeType: string}|null>}
- */
-export async function fetchImageAsBase64(imageUrl, options = {}) {
-  const { signal, timeoutMs = 10000 } = options;
-  if (!imageUrl || (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://"))) {
-    return null;
-  }
-
-  const controller = new AbortController();
-  const timeout = signal ? null : setTimeout(() => controller.abort(), timeoutMs);
-  const fetchSignal = signal || controller.signal;
-
-  try {
-    const response = await fetch(imageUrl, { signal: fetchSignal });
-    if (!response.ok) return null;
-
-    const mimeType = response.headers.get("Content-Type") || "image/jpeg";
-    const arrayBuffer = await response.arrayBuffer();
-    const base64 = Buffer.from(arrayBuffer).toString("base64");
-    return { url: `data:${mimeType};base64,${base64}`, mimeType };
-  } catch {
-    return null;
-  } finally {
-    if (timeout) clearTimeout(timeout);
-  }
-}

package/open-sse/translator/helpers/maxTokensHelper.js

@@ -1,27 +0,0 @@
-import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
-
-/**
- * Adjust max_tokens based on request context
- * @param {object} body - Request body
- * @returns {number} Adjusted max_tokens
- */
-export function adjustMaxTokens(body) {
-  let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
-
-  // Auto-increase for tool calling to prevent truncated arguments
-  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
-    if (maxTokens < DEFAULT_MIN_TOKENS) {
-      maxTokens = DEFAULT_MIN_TOKENS;
-    }
-  }
-
-  // Ensure max_tokens > thinking.budget_tokens (Claude API requirement)
-  // Claude API requires strictly greater, so add buffer instead of using DEFAULT_MAX_TOKENS
-  // which could equal budget_tokens when budget_tokens >= 64000
-  if (body.thinking?.budget_tokens && maxTokens <= body.thinking.budget_tokens) {
-    maxTokens = body.thinking.budget_tokens + 1024;
-  }
-
-  return maxTokens;
-}
-