n9router 0.4.43 → 0.4.45

package/app/open-sse/translator/request/gemini-to-openai.js

@@ -1,6 +1,9 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { collapseTextParts } from "../concerns/message.js";
+import { ROLE, GEMINI_ROLE, OPENAI_BLOCK } from "../schema/index.js";
 
 // Convert Gemini request to OpenAI format
 export function geminiToOpenAIRequest(model, body, stream) {
@@ -30,7 +33,7 @@ export function geminiToOpenAIRequest(model, body, stream) {
     const systemText = extractGeminiText(body.systemInstruction);
     if (systemText) {
       result.messages.push({
-        role: "system",
+        role: ROLE.SYSTEM,
         content: systemText
       });
     }
@@ -53,7 +56,7 @@ export function geminiToOpenAIRequest(model, body, stream) {
       if (tool.functionDeclarations) {
         for (const func of tool.functionDeclarations) {
           result.tools.push({
-            type: "function",
+            type: OPENAI_BLOCK.FUNCTION,
             function: {
               name: func.name,
               description: func.description || "",
@@ -70,7 +73,7 @@ export function geminiToOpenAIRequest(model, body, stream) {
 
 // Convert Gemini content to OpenAI message
 function convertGeminiContent(content) {
-  const role = content.role === "user" ? "user" : "assistant";
+  const role = content.role === GEMINI_ROLE.USER ? ROLE.USER : ROLE.ASSISTANT;
   
   if (!content.parts || !Array.isArray(content.parts)) {
     return null;
@@ -81,22 +84,24 @@ function convertGeminiContent(content) {
 
   for (const part of content.parts) {
     if (part.text !== undefined) {
-      parts.push({ type: "text", text: part.text });
+      parts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
     }
 
     if (part.inlineData) {
       parts.push({
-        type: "image_url",
+        type: OPENAI_BLOCK.IMAGE_URL,
         image_url: {
-          url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
+          url: encodeDataUri(part.inlineData.mimeType, part.inlineData.data)
         }
       });
     }
 
     if (part.functionCall) {
+      // Gemini lacks a native call id; derive a deterministic one from the name so the
+      // matching functionResponse maps to the same tool_call_id (providers require pairing).
       toolCalls.push({
-        id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-        type: "function",
+        id: part.functionCall.id || `call_${part.functionCall.name}`,
+        type: OPENAI_BLOCK.FUNCTION,
         function: {
           name: part.functionCall.name,
           arguments: JSON.stringify(part.functionCall.args || {})
@@ -106,15 +111,15 @@ function convertGeminiContent(content) {
 
     if (part.functionResponse) {
       return {
-        role: "tool",
-        tool_call_id: part.functionResponse.id || part.functionResponse.name,
+        role: ROLE.TOOL,
+        tool_call_id: part.functionResponse.id || `call_${part.functionResponse.name}`,
         content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
       };
     }
   }
 
   if (toolCalls.length > 0) {
-    const result = { role: "assistant" };
+    const result = { role: ROLE.ASSISTANT };
     if (parts.length > 0) {
       result.content = parts.length === 1 ? parts[0].text : parts;
     }
@@ -125,7 +130,7 @@ function convertGeminiContent(content) {
   if (parts.length > 0) {
     return {
       role,
-      content: parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts
+      content: collapseTextParts(parts)
     };
   }
 

package/app/open-sse/translator/request/openai-responses.js

@@ -6,7 +6,8 @@
  */
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-import { normalizeResponsesInput } from "../helpers/responsesApiHelper.js";
+import { normalizeResponsesInput } from "../formats/responsesApi.js";
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM } from "../schema/index.js";
 
 // Responses API enforces max 64 chars on call_id (#393)
 const MAX_CALL_ID_LEN = 64;
@@ -23,7 +24,7 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
 
   // Convert instructions to system message
   if (body.instructions) {
-    result.messages.push({ role: "system", content: body.instructions });
+    result.messages.push({ role: ROLE.SYSTEM, content: body.instructions });
   }
 
   // Group items by conversation turn
@@ -50,9 +51,9 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
   for (const item of inputItems) {
     // Determine item type - Droid CLI sends role-based items without 'type' field
     // Fallback: if no type but has role property, treat as message
-    const itemType = item.type || (item.role ? "message" : null);
+    const itemType = item.type || (item.role ? RESPONSES_ITEM.MESSAGE : null);
 
-    if (itemType === "message") {
+    if (itemType === RESPONSES_ITEM.MESSAGE) {
       // Flush any pending assistant message with tool calls
       if (currentAssistantMsg) {
         result.messages.push(currentAssistantMsg);
@@ -69,28 +70,28 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       // Convert content: input_text → text, output_text → text, input_image → image_url
       const content = Array.isArray(item.content)
         ? item.content.map(c => {
-          if (c.type === "input_text") return { type: "text", text: c.text };
-          if (c.type === "output_text") return { type: "text", text: c.text };
-          if (c.type === "input_image") {
+          if (c.type === RESPONSES_ITEM.INPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.OUTPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.INPUT_IMAGE) {
             const url = c.image_url || c.file_id || "";
-            return { type: "image_url", image_url: { url, detail: c.detail || "auto" } };
+            return { type: OPENAI_BLOCK.IMAGE_URL, image_url: { url, detail: c.detail || "auto" } };
           }
           return c;
         })
         : item.content;
       const msg = { role: item.role, content };
       // Attach buffered reasoning to assistant turn (required by xiaomi-mimo thinking mode)
-      if (item.role === "assistant" && pendingReasoning) {
+      if (item.role === ROLE.ASSISTANT && pendingReasoning) {
         msg.reasoning_content = pendingReasoning;
       }
       pendingReasoning = "";
       result.messages.push(msg);
     }
-    else if (itemType === "function_call") {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL) {
       // Start or append to assistant message with tool_calls
       if (!currentAssistantMsg) {
         currentAssistantMsg = {
-          role: "assistant",
+          role: ROLE.ASSISTANT,
           content: null,
           tool_calls: []
         };
@@ -103,14 +104,14 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
       currentAssistantMsg.tool_calls.push({
         id: item.call_id,
-        type: "function",
+        type: OPENAI_BLOCK.FUNCTION,
         function: {
           name: item.name,
           arguments: item.arguments
         }
       });
     }
-    else if (itemType === "function_call_output") {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT) {
       // Flush assistant message first if exists
       if (currentAssistantMsg) {
         result.messages.push(currentAssistantMsg);
@@ -125,12 +126,12 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
       }
       // Add tool result immediately
       result.messages.push({
-        role: "tool",
+        role: ROLE.TOOL,
         tool_call_id: item.call_id,
         content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
       });
     }
-    else if (itemType === "reasoning") {
+    else if (itemType === RESPONSES_ITEM.REASONING) {
       // Buffer reasoning text; attached to next assistant message/function_call
       const txt = extractReasoningText(item);
       if (txt) pendingReasoning = pendingReasoning ? `${pendingReasoning}\n${txt}` : txt;
@@ -163,7 +164,7 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
         const name = tool.name;
         if (!name || typeof name !== "string" || name.trim() === "") return null;
         return {
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: {
             name,
             description: String(tool.description || ""),
@@ -176,6 +177,12 @@ export function openaiResponsesToOpenAIRequest(model, body, stream, credentials)
   }
 
   // Cleanup Responses API specific fields
+  // Map Responses-only max_output_tokens to Chat max_tokens (avoid leaking unknown field upstream)
+  if (result.max_output_tokens !== undefined) {
+    if (result.max_tokens === undefined) result.max_tokens = result.max_output_tokens;
+    delete result.max_output_tokens;
+  }
+
   delete result.input;
   delete result.instructions;
   delete result.include;
@@ -214,7 +221,7 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
   const messages = body.messages || [];
 
   for (const msg of messages) {
-    if (msg.role === "system") {
+    if (msg.role === ROLE.SYSTEM) {
       // Use first system message as instructions
       if (!hasSystemMessage) {
         result.instructions = typeof msg.content === "string" ? msg.content : "";
@@ -224,21 +231,21 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
     }
 
     // Convert user/assistant messages to input items
-    if (msg.role === "user" || msg.role === "assistant") {
-      const contentType = msg.role === "user" ? "input_text" : "output_text";
+    if (msg.role === ROLE.USER || msg.role === ROLE.ASSISTANT) {
+      const contentType = msg.role === ROLE.USER ? RESPONSES_ITEM.INPUT_TEXT : RESPONSES_ITEM.OUTPUT_TEXT;
       const content = typeof msg.content === "string"
         ? [{ type: contentType, text: msg.content }]
         : Array.isArray(msg.content)
           ? msg.content.map(c => {
-            if (c.type === "text") return { type: contentType, text: c.text };
+            if (c.type === OPENAI_BLOCK.TEXT) return { type: contentType, text: c.text };
             // Convert Chat Completions image_url → Responses API input_image
             // Responses API expects: { type: "input_image", image_url: "<url string>" }
             // Chat Completions sends: { type: "image_url", image_url: { url: "...", detail: "..." } }
-            if (c.type === "image_url") {
+            if (c.type === OPENAI_BLOCK.IMAGE_URL) {
               const url = typeof c.image_url === "string" ? c.image_url : c.image_url?.url;
-              return { type: "input_image", image_url: url, detail: c.image_url?.detail || "auto" };
+              return { type: RESPONSES_ITEM.INPUT_IMAGE, image_url: url, detail: c.image_url?.detail || "auto" };
             }
-            if (c.type === "input_image") return c;
+            if (c.type === RESPONSES_ITEM.INPUT_IMAGE) return c;
             // Serialize any unknown type (tool_use, tool_result, thinking, etc.) as text
             const text = c.text || c.content || JSON.stringify(c);
             return { type: contentType, text: typeof text === "string" ? text : JSON.stringify(text) };
@@ -250,7 +257,7 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
       // message block in that case; the tool_calls are pushed separately below.
       if (content.length > 0) {
         result.input.push({
-          type: "message",
+          type: RESPONSES_ITEM.MESSAGE,
           role: msg.role,
           content
         });
@@ -258,10 +265,10 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
     }
 
     // Convert tool calls
-    if (msg.role === "assistant" && msg.tool_calls) {
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
       for (const tc of msg.tool_calls) {
         result.input.push({
-          type: "function_call",
+          type: RESPONSES_ITEM.FUNCTION_CALL,
           call_id: clampCallId(tc.id),
           name: tc.function?.name || "_unknown",
           arguments: tc.function?.arguments || "{}"
@@ -270,14 +277,14 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
     }
 
     // Convert tool results - output must be a string for Responses API
-    if (msg.role === "tool") {
+    if (msg.role === ROLE.TOOL) {
       const output = typeof msg.content === "string"
         ? msg.content
         : Array.isArray(msg.content)
           ? msg.content.map(c => c.text || JSON.stringify(c)).join("")
           : JSON.stringify(msg.content);
       result.input.push({
-        type: "function_call_output",
+        type: RESPONSES_ITEM.FUNCTION_CALL_OUTPUT,
         call_id: clampCallId(msg.tool_call_id),
         output
       });
@@ -292,9 +299,9 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
   // Convert tools format
   if (body.tools && Array.isArray(body.tools)) {
     result.tools = body.tools.map(tool => {
-      if (tool.type === "function") {
+      if (tool.type === OPENAI_BLOCK.FUNCTION) {
         return {
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           name: tool.function.name,
           description: String(tool.function.description || ""),
           parameters: normalizeToolParameters(tool.function.parameters),
@@ -309,6 +316,8 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
   if (body.temperature !== undefined) result.temperature = body.temperature;
   if (body.max_tokens !== undefined) result.max_tokens = body.max_tokens;
   if (body.top_p !== undefined) result.top_p = body.top_p;
+  if (body.reasoning !== undefined) result.reasoning = body.reasoning;
+  if (body.reasoning_effort !== undefined) result.reasoning = { effort: body.reasoning_effort, summary: "auto" };
 
   return result;
 }

package/app/open-sse/translator/request/openai-to-claude.js

@@ -1,7 +1,11 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
 import { CLAUDE_SYSTEM_PROMPT } from "../../config/appConstants.js";
-import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { safeParseJSON } from "../concerns/json.js";
+import { parseDataUri } from "../concerns/image.js";
+import { extractTextContent } from "../formats/gemini.js";
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
 
 // Empty prefix matches real Claude Code behavior (no tool name prefix).
 // Previously "proxy_" was used but this is a detectable fingerprint difference.
@@ -29,13 +33,13 @@ export function openaiToClaudeRequest(model, body, stream) {
   if (body.messages && Array.isArray(body.messages)) {
     // Extract system messages
     for (const msg of body.messages) {
-      if (msg.role === "system") {
-        systemParts.push(typeof msg.content === "string" ? msg.content : extractTextContent(msg.content));
+      if (msg.role === ROLE.SYSTEM) {
+        systemParts.push(typeof msg.content === "string" ? msg.content : extractTextContent(msg.content, "\n"));
       }
     }
 
     // Filter out system messages for separate processing
-    const nonSystemMessages = body.messages.filter(m => m.role !== "system");
+    const nonSystemMessages = body.messages.filter(m => m.role !== ROLE.SYSTEM);
 
     // Process messages with merging logic
     // CRITICAL: tool_result must be in separate message immediately after tool_use
@@ -50,20 +54,20 @@ export function openaiToClaudeRequest(model, body, stream) {
     };
 
     for (const msg of nonSystemMessages) {
-      const newRole = (msg.role === "user" || msg.role === "tool") ? "user" : "assistant";
+      const newRole = (msg.role === ROLE.USER || msg.role === ROLE.TOOL) ? ROLE.USER : ROLE.ASSISTANT;
       const blocks = getContentBlocksFromMessage(msg, toolNameMap);
-      const hasToolUse = blocks.some(b => b.type === "tool_use");
-      const hasToolResult = blocks.some(b => b.type === "tool_result");
+      const hasToolUse = blocks.some(b => b.type === CLAUDE_BLOCK.TOOL_USE);
+      const hasToolResult = blocks.some(b => b.type === CLAUDE_BLOCK.TOOL_RESULT);
 
       // Separate tool_result from other content
       if (hasToolResult) {
-        const toolResultBlocks = blocks.filter(b => b.type === "tool_result");
-        const otherBlocks = blocks.filter(b => b.type !== "tool_result");
+        const toolResultBlocks = blocks.filter(b => b.type === CLAUDE_BLOCK.TOOL_RESULT);
+        const otherBlocks = blocks.filter(b => b.type !== CLAUDE_BLOCK.TOOL_RESULT);
 
         flushCurrentMessage();
 
         if (toolResultBlocks.length > 0) {
-          result.messages.push({ role: "user", content: toolResultBlocks });
+          result.messages.push({ role: ROLE.USER, content: toolResultBlocks });
         }
 
         if (otherBlocks.length > 0) {
@@ -90,9 +94,9 @@ export function openaiToClaudeRequest(model, body, stream) {
     // Add cache_control to last assistant message
     for (let i = result.messages.length - 1; i >= 0; i--) {
       const message = result.messages[i];
-      if (message.role === "assistant" && Array.isArray(message.content) && message.content.length > 0) {
+      if (message.role === ROLE.ASSISTANT && Array.isArray(message.content) && message.content.length > 0) {
         // Find the last block that can have cache_control (not thinking blocks)
-        const validBlockTypes = ["text", "tool_use", "tool_result", "image"];
+        const validBlockTypes = [CLAUDE_BLOCK.TEXT, CLAUDE_BLOCK.TOOL_USE, CLAUDE_BLOCK.TOOL_RESULT, CLAUDE_BLOCK.IMAGE];
         for (let j = message.content.length - 1; j >= 0; j--) {
           const block = message.content[j];
           if (validBlockTypes.includes(block.type)) {
@@ -121,13 +125,13 @@ Respond ONLY with the JSON object, no other text.`);
   }
 
   // System with Claude Code prompt and cache_control
-  const claudeCodePrompt = { type: "text", text: CLAUDE_SYSTEM_PROMPT };
+  const claudeCodePrompt = { type: CLAUDE_BLOCK.TEXT, text: CLAUDE_SYSTEM_PROMPT };
 
   if (systemParts.length > 0) {
     const systemText = systemParts.join("\n");
     result.system = [
       claudeCodePrompt,
-      { type: "text", text: systemText, cache_control: { type: "ephemeral", ttl: "1h" } }
+      { type: CLAUDE_BLOCK.TEXT, text: systemText, cache_control: { type: "ephemeral", ttl: "1h" } }
     ];
   } else {
     result.system = [claudeCodePrompt];
@@ -139,12 +143,12 @@ Respond ONLY with the JSON object, no other text.`);
     for (const tool of body.tools) {
       // Pass-through built-in tools (e.g. web_search_20250305) without prefix or conversion
       const toolType = tool.type;
-      if (toolType && toolType !== "function") {
+      if (toolType && toolType !== OPENAI_BLOCK.FUNCTION) {
         result.tools.push(tool);
         continue;
       }
 
-      const toolData = toolType === "function" && tool.function ? tool.function : tool;
+      const toolData = toolType === OPENAI_BLOCK.FUNCTION && tool.function ? tool.function : tool;
       const originalName = toolData.name;
 
       // Claude OAuth requires prefixed tool names to avoid conflicts
@@ -170,33 +174,7 @@ Respond ONLY with the JSON object, no other text.`);
     result.tool_choice = convertOpenAIToolChoice(body.tool_choice);
   }
 
-  // Thinking configuration
-  if (body.thinking) {
-    result.thinking = {
-      type: body.thinking.type || "enabled",
-      ...(body.thinking.budget_tokens && { budget_tokens: body.thinking.budget_tokens }),
-      ...(body.thinking.max_tokens && { max_tokens: body.thinking.max_tokens })
-    };
-  }
-
-  // Map OpenAI reasoning_effort → Claude thinking.budget_tokens
-  // When client sends reasoning_effort (OpenAI format) but no explicit thinking block,
-  // translate to Claude's native format.
-  if (body.reasoning_effort && !result.thinking) {
-    const effortToBudget = {
-      none:   0,
-      low:    4096,
-      medium: 8192,
-      high:   16384,
-      xhigh:  32768,
-    };
-    const budget = effortToBudget[body.reasoning_effort.toLowerCase()];
-    if (budget === 0) {
-      // none → no thinking
-    } else if (budget) {
-      result.thinking = { type: "enabled", budget_tokens: budget };
-    }
-  }
+  // Thinking is normalized centrally by applyThinking (thinkingUnified.js) after translation.
 
   // Attach toolNameMap to result for response translation
   if (toolNameMap.size > 0) {
@@ -210,78 +188,88 @@ Respond ONLY with the JSON object, no other text.`);
 function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
   const blocks = [];
 
-  if (msg.role === "tool") {
+  if (msg.role === ROLE.TOOL) {
     blocks.push({
-      type: "tool_result",
+      type: CLAUDE_BLOCK.TOOL_RESULT,
       tool_use_id: msg.tool_call_id,
       content: msg.content
     });
-  } else if (msg.role === "user") {
+  } else if (msg.role === ROLE.USER) {
     if (typeof msg.content === "string") {
       if (msg.content) {
-        blocks.push({ type: "text", text: msg.content });
+        blocks.push({ type: CLAUDE_BLOCK.TEXT, text: msg.content });
       }
     } else if (Array.isArray(msg.content)) {
       for (const part of msg.content) {
-        if (part.type === "text" && part.text) {
-          blocks.push({ type: "text", text: part.text });
-        } else if (part.type === "tool_result") {
+        if (part.type === OPENAI_BLOCK.TEXT && part.text) {
+          blocks.push({ type: CLAUDE_BLOCK.TEXT, text: part.text });
+        } else if (part.type === CLAUDE_BLOCK.TOOL_RESULT) {
           blocks.push({
-            type: "tool_result",
+            type: CLAUDE_BLOCK.TOOL_RESULT,
             tool_use_id: part.tool_use_id,
             content: part.content,
             ...(part.is_error && { is_error: part.is_error })
           });
-        } else if (part.type === "image_url") {
+        } else if (part.type === OPENAI_BLOCK.IMAGE_URL) {
           const url = part.image_url.url;
-          const match = url.match(/^data:([^;]+);base64,(.+)$/);
-          if (match) {
+          const parsed = parseDataUri(url);
+          if (parsed) {
             blocks.push({
-              type: "image",
-              source: { type: "base64", media_type: match[1], data: match[2] }
+              type: CLAUDE_BLOCK.IMAGE,
+              source: { type: "base64", media_type: parsed.mimeType, data: parsed.base64 }
             });
           } else if (url.startsWith("http://") || url.startsWith("https://")) {
             blocks.push({
-              type: "image",
+              type: CLAUDE_BLOCK.IMAGE,
               source: { type: "url", url }
             });
           }
-        } else if (part.type === "image" && part.source) {
-          blocks.push({ type: "image", source: part.source });
+        } else if (part.type === OPENAI_BLOCK.IMAGE && part.source) {
+          blocks.push({ type: CLAUDE_BLOCK.IMAGE, source: part.source });
+        } else if (part.type === OPENAI_BLOCK.FILE && part.file) {
+          // OpenAI file block -> Claude document (PDF only; Claude rejects other mimes).
+          const fileData = part.file.file_data;
+          const parsed = parseDataUri(fileData);
+          if (parsed && parsed.mimeType === "application/pdf") {
+            blocks.push({
+              type: CLAUDE_BLOCK.DOCUMENT,
+              source: { type: "base64", media_type: parsed.mimeType, data: parsed.base64 }
+            });
+          }
         }
       }
     }
-  } else if (msg.role === "assistant") {
+  } else if (msg.role === ROLE.ASSISTANT) {
     if (Array.isArray(msg.content)) {
       for (const part of msg.content) {
-        if (part.type === "text" && part.text) {
-          blocks.push({ type: "text", text: part.text });
-        } else if (part.type === "tool_use") {
+        if (part.type === OPENAI_BLOCK.TEXT && part.text) {
+          blocks.push({ type: CLAUDE_BLOCK.TEXT, text: part.text });
+        } else if (part.type === CLAUDE_BLOCK.TOOL_USE) {
           // Tool name already has prefix from tool declarations, keep as-is
-          blocks.push({ type: "tool_use", id: part.id, name: part.name, input: part.input });
-        } else if (part.type === "thinking") {
+          blocks.push({ type: CLAUDE_BLOCK.TOOL_USE, id: part.id, name: part.name, input: part.input });
+        } else if (part.type === CLAUDE_BLOCK.THINKING) {
           // Include thinking block but strip cache_control (not allowed on thinking blocks)
           const { cache_control, ...thinkingBlock } = part;
           blocks.push(thinkingBlock);
         }
       }
     } else if (msg.content) {
-      const text = typeof msg.content === "string" ? msg.content : extractTextContent(msg.content);
+      const text = typeof msg.content === "string" ? msg.content : extractTextContent(msg.content, "\n");
       if (text) {
-        blocks.push({ type: "text", text });
+        blocks.push({ type: CLAUDE_BLOCK.TEXT, text });
       }
     }
 
     if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
       for (const tc of msg.tool_calls) {
-        if (tc.type === "function") {
+        if (tc.type === OPENAI_BLOCK.FUNCTION) {
           // Apply prefix to tool name
           const toolName = CLAUDE_OAUTH_TOOL_PREFIX + tc.function.name;
           blocks.push({
-            type: "tool_use",
+            type: CLAUDE_BLOCK.TOOL_USE,
             id: tc.id,
             name: toolName,
-            input: tryParseJSON(tc.function.arguments)
+            input: safeParseJSON(tc.function.arguments, tc.function.arguments)
           });
         }
       }
@@ -291,35 +279,36 @@ function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
   return blocks;
 }
 
-// Convert OpenAI tool choice to Claude format
+// Convert OpenAI tool choice to Claude format.
+// Claude only accepts tool_choice.type of "auto" | "any" | "tool" | "none";
+// anything else (e.g. OpenAI's "function") triggers a 400, so we never pass an
+// unrecognized type through.
+const CLAUDE_TOOL_CHOICE_TYPES = new Set(["auto", "any", "tool", "none"]);
+
 function convertOpenAIToolChoice(choice) {
   if (!choice) return { type: "auto" };
-  if (typeof choice === "object" && choice.type) return choice;
-  if (choice === "auto" || choice === "none") return { type: "auto" };
-  if (choice === "required") return { type: "any" };
-  if (typeof choice === "object" && choice.function) {
-    return { type: "tool", name: choice.function.name };
-  }
-  return { type: "auto" };
-}
 
-// Extract text from content
-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("\n");
+  // OpenAI string forms: "auto" | "none" | "required"
+  if (typeof choice === "string") {
+    if (choice === "required") return { type: "any" };
+    return { type: "auto" }; // "auto", "none", or anything unexpected
   }
-  return "";
-}
 
-// Try parse JSON
-function tryParseJSON(str) {
-  if (typeof str !== "string") return str;
-  try {
-    return JSON.parse(str);
-  } catch {
-    return str;
+  if (typeof choice === "object") {
+    // OpenAI forced tool: { type: "function", function: { name } }.
+    // Checked before the native pass-through below, because the OpenAI shape
+    // also carries a `.type` ("function") that Claude rejects.
+    if (choice.function?.name) {
+      return { type: "tool", name: choice.function.name };
+    }
+    // Already Claude-native — only pass through types Claude actually accepts,
+    // so a malformed or unknown type can never leak into the upstream request.
+    if (CLAUDE_TOOL_CHOICE_TYPES.has(choice.type)) {
+      return choice;
+    }
   }
+
+  return { type: "auto" };
 }
 
 // OpenAI -> Claude format for Antigravity (without system prompt modifications)
@@ -357,7 +346,7 @@ function openaiToClaudeRequestForAntigravity(model, body, stream) {
       }
 
       const updatedContent = msg.content.map(block => {
-        if (block.type === "tool_use" && block.name && block.name.startsWith(CLAUDE_OAUTH_TOOL_PREFIX)) {
+        if (block.type === CLAUDE_BLOCK.TOOL_USE && block.name && block.name.startsWith(CLAUDE_OAUTH_TOOL_PREFIX)) {
           return {
             ...block,
             name: block.name.slice(CLAUDE_OAUTH_TOOL_PREFIX.length)