n9router 0.4.43 → 0.4.45

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

@@ -0,0 +1,466 @@
+/**
+ * Claude → Kiro Request Translator (DIRECT route, no OpenAI pivot)
+ *
+ * Converts Anthropic Messages API requests straight to Kiro / AWS
+ * CodeWhisperer `GenerateAssistantResponse` payloads. This is the function the
+ * direct `claude:kiro` route in ../index.js uses; it is NOT reached through the
+ * claude→openai→kiro pivot.
+ *
+ * It reproduces the two 400-guards that live in openai-to-kiro.js so that a
+ * Claude client which omits the `tools` array on a follow-up turn (typical
+ * after client-side compaction) does not trip Kiro's schema validator and get
+ * "Improperly formed request" (HTTP 400):
+ *
+ *   1. flattenClaudeToolInteractions — when the client sent NO tools, collapse
+ *      every tool_use / tool_result block to plain text so no structured tool
+ *      reference survives to trigger the "tools required" rule.
+ *   2. reconcileOrphanedToolResults — when tools ARE present, fold any
+ *      tool_result whose tool_use_id has no matching tool_use back into the
+ *      user text instead of leaving a dangling structured reference.
+ *
+ * It also handles the 9router-synthetic `-agentic` / `-thinking` suffixes and
+ * the `<thinking_mode>enabled</thinking_mode>` reasoning trigger, matching
+ * buildKiroPayload.
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { v4 as uuidv4 } from "uuid";
+import {
+  resolveKiroModel,
+  resolveKiroThinkingBudget,
+  buildThinkingSystemPrefix,
+  KIRO_AGENTIC_SYSTEM_PROMPT,
+  resolveDefaultProfileArn,
+} from "../../config/kiroConstants.js";
+import { DEFAULT_IMAGE_MIME } from "../schema/index.js";
+import { ROLE, CLAUDE_BLOCK } from "../schema/index.js";
+
+/** Stringify a tool_use input as a readable line. */
+function toolUseToText(name, input) {
+  let argStr;
+  try {
+    argStr = typeof input === "string" ? input : JSON.stringify(input ?? {});
+  } catch {
+    argStr = "{}";
+  }
+  return `[Tool call: ${name || "unknown"}(${argStr})]`;
+}
+
+/** Render a Claude tool_result block's content as a readable line. */
+function toolResultBlockToText(content) {
+  let text = "";
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content
+      .map((c) => (typeof c === "string" ? c : c?.text || ""))
+      .filter(Boolean)
+      .join("\n");
+  } else if (content) {
+    try {
+      text = JSON.stringify(content);
+    } catch {
+      text = "";
+    }
+  }
+  return `[Tool result: ${text}]`;
+}
+
+/**
+ * When the client sent no tools, rewrite every tool_use (assistant) and
+ * tool_result (user) content block into plain text. Keeps text + images.
+ * Returns a new messages array; never mutates the input.
+ */
+function flattenClaudeToolInteractions(messages) {
+  const out = [];
+  for (const msg of messages) {
+    if (!msg) continue;
+
+    if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === CLAUDE_BLOCK.TEXT && block.text) {
+          parts.push(block.text);
+        } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
+          parts.push(toolUseToText(block.name, block.input));
+        }
+      }
+      out.push({ ...msg, content: parts.join("\n") });
+      continue;
+    }
+
+    if (msg.role === ROLE.USER && Array.isArray(msg.content)) {
+      const newContent = msg.content.map((block) =>
+        block.type === CLAUDE_BLOCK.TOOL_RESULT
+          ? { type: CLAUDE_BLOCK.TEXT, text: toolResultBlockToText(block.content) }
+          : block
+      );
+      out.push({ ...msg, content: newContent });
+      continue;
+    }
+
+    out.push(msg);
+  }
+  return out;
+}
+
+/**
+ * Convert Claude messages to Kiro history + currentMessage.
+ * Kiro requires alternating user/assistant turns; consecutive same-role
+ * messages are merged.
+ */
+function convertClaudeMessagesToKiro(messages, tools, model) {
+  const history = [];
+  let currentMessage = null;
+
+  let pendingUserContent = [];
+  let pendingAssistantContent = [];
+  let pendingToolResults = [];
+  let pendingImages = [];
+  let currentRole = null;
+  let toolsInjected = false;
+
+  const clientProvidedTools = Array.isArray(tools) && tools.length > 0;
+
+  const buildToolSpecs = () =>
+    tools.map((t) => {
+      const name = t.name;
+      const description = t.description || `Tool: ${name}`;
+      const schema = t.input_schema || {};
+      const normalizedSchema =
+        Object.keys(schema).length === 0
+          ? { type: "object", properties: {}, required: [] }
+          : { ...schema, required: schema.required ?? [] };
+      return {
+        toolSpecification: {
+          name,
+          description,
+          inputSchema: { json: normalizedSchema },
+        },
+      };
+    });
+
+  const flushPending = () => {
+    if (currentRole === ROLE.USER) {
+      const content = pendingUserContent.join("\n\n").trim() || "continue";
+      const userMsg = { userInputMessage: { content, modelId: model } };
+
+      if (pendingImages.length > 0) {
+        userMsg.userInputMessage.images = pendingImages;
+      }
+      if (pendingToolResults.length > 0) {
+        userMsg.userInputMessage.userInputMessageContext = {
+          toolResults: pendingToolResults,
+        };
+      }
+      // Attach tools to the first user turn only.
+      if (clientProvidedTools && !toolsInjected) {
+        if (!userMsg.userInputMessage.userInputMessageContext) {
+          userMsg.userInputMessage.userInputMessageContext = {};
+        }
+        userMsg.userInputMessage.userInputMessageContext.tools = buildToolSpecs();
+        toolsInjected = true;
+      }
+
+      history.push(userMsg);
+      currentMessage = userMsg;
+      pendingUserContent = [];
+      pendingToolResults = [];
+      pendingImages = [];
+    } else if (currentRole === ROLE.ASSISTANT) {
+      const content = pendingAssistantContent.join("\n\n").trim() || "...";
+      history.push({ assistantResponseMessage: { content } });
+      pendingAssistantContent = [];
+    }
+  };
+
+  for (const msg of messages) {
+    const role = msg.role;
+    if (role !== currentRole && currentRole !== null) flushPending();
+    currentRole = role;
+
+    if (role === ROLE.USER) {
+      if (typeof msg.content === "string") {
+        pendingUserContent.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === CLAUDE_BLOCK.TEXT) {
+            pendingUserContent.push(block.text);
+          } else if (block.type === CLAUDE_BLOCK.IMAGE && block.source?.type === "base64") {
+            const mediaType = block.source.media_type || DEFAULT_IMAGE_MIME;
+            const format = mediaType.split("/")[1] || mediaType;
+            pendingImages.push({ format, source: { bytes: block.source.data } });
+          } else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
+            let resultContent = "";
+            if (typeof block.content === "string") {
+              resultContent = block.content;
+            } else if (Array.isArray(block.content)) {
+              resultContent =
+                block.content
+                  .filter((c) => c.type === CLAUDE_BLOCK.TEXT)
+                  .map((c) => c.text)
+                  .join("\n") || JSON.stringify(block.content);
+            } else if (block.content) {
+              resultContent = JSON.stringify(block.content);
+            }
+            pendingToolResults.push({
+              toolUseId: block.tool_use_id,
+              status: "success",
+              content: [{ text: resultContent }],
+            });
+          }
+        }
+      }
+    } else if (role === ROLE.ASSISTANT) {
+      let textContent = "";
+      const toolUses = [];
+      if (typeof msg.content === "string") {
+        textContent = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === CLAUDE_BLOCK.TEXT) {
+            textContent += block.text;
+          } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
+            toolUses.push({
+              toolUseId: block.id,
+              name: block.name,
+              input: block.input || {},
+            });
+          }
+        }
+      }
+      if (textContent) pendingAssistantContent.push(textContent);
+
+      if (toolUses.length > 0) {
+        flushPending();
+        const lastMsg = history[history.length - 1];
+        if (lastMsg?.assistantResponseMessage) {
+          lastMsg.assistantResponseMessage.toolUses = toolUses;
+        }
+        currentRole = null;
+      }
+    }
+  }
+
+  if (currentRole !== null) flushPending();
+
+  // Pop the last user turn as currentMessage (skip trailing assistant turns).
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (history[i].userInputMessage) {
+      currentMessage = history.splice(i, 1)[0];
+      break;
+    }
+  }
+
+  // Grab tools from the first history user turn before cleanup strips them.
+  const firstHistoryTools =
+    history[0]?.userInputMessage?.userInputMessageContext?.tools;
+
+  history.forEach((item) => {
+    if (item.userInputMessage?.userInputMessageContext?.tools) {
+      delete item.userInputMessage.userInputMessageContext.tools;
+    }
+    if (
+      item.userInputMessage?.userInputMessageContext &&
+      Object.keys(item.userInputMessage.userInputMessageContext).length === 0
+    ) {
+      delete item.userInputMessage.userInputMessageContext;
+    }
+    if (item.userInputMessage && !item.userInputMessage.modelId) {
+      item.userInputMessage.modelId = model;
+    }
+  });
+
+  // Merge consecutive user turns (Kiro requires alternating roles).
+  const mergedHistory = [];
+  for (const current of history) {
+    const prev = mergedHistory[mergedHistory.length - 1];
+    if (current.userInputMessage && prev?.userInputMessage) {
+      prev.userInputMessage.content += "\n\n" + current.userInputMessage.content;
+      const prevCtx = prev.userInputMessage.userInputMessageContext;
+      const curCtx = current.userInputMessage.userInputMessageContext;
+      if (curCtx) {
+        if (!prevCtx) {
+          prev.userInputMessage.userInputMessageContext = curCtx;
+        } else {
+          if (curCtx.toolResults?.length > 0) {
+            prevCtx.toolResults = [
+              ...(prevCtx.toolResults || []),
+              ...curCtx.toolResults,
+            ];
+          }
+          if (curCtx.tools?.length > 0) {
+            prevCtx.tools = [...(prevCtx.tools || []), ...curCtx.tools];
+          }
+        }
+      }
+    } else {
+      mergedHistory.push(current);
+    }
+  }
+
+  if (!currentMessage) {
+    currentMessage = { userInputMessage: { content: "", modelId: model } };
+  }
+
+  // Inject tools into currentMessage after cleanup if not already present.
+  if (
+    firstHistoryTools?.length > 0 &&
+    !currentMessage.userInputMessage.userInputMessageContext?.tools
+  ) {
+    if (!currentMessage.userInputMessage.userInputMessageContext) {
+      currentMessage.userInputMessage.userInputMessageContext = {};
+    }
+    currentMessage.userInputMessage.userInputMessageContext.tools =
+      firstHistoryTools;
+  }
+
+  return { history: mergedHistory, currentMessage };
+}
+
+/**
+ * Fold orphaned toolResults (those whose toolUseId has no matching toolUse in
+ * any assistant turn) back into the user text, removing the dangling
+ * structured reference that makes Kiro 400.
+ */
+function reconcileOrphanedToolResults(history, currentMessage) {
+  const validIds = new Set();
+  for (const h of history) {
+    const arm = h.assistantResponseMessage;
+    if (!arm) continue;
+    for (const tu of arm.toolUses || []) {
+      if (tu.toolUseId) validIds.add(tu.toolUseId);
+    }
+  }
+
+  const carriers = currentMessage ? [...history, currentMessage] : history;
+  for (const item of carriers) {
+    const uim = item.userInputMessage;
+    const ctx = uim?.userInputMessageContext;
+    if (!ctx?.toolResults?.length) continue;
+
+    const kept = [];
+    const salvaged = [];
+    for (const tr of ctx.toolResults) {
+      if (validIds.has(tr.toolUseId)) {
+        kept.push(tr);
+      } else {
+        const text = Array.isArray(tr.content)
+          ? tr.content.map((c) => c?.text || "").join("\n")
+          : "";
+        salvaged.push(`[Tool result: ${text}]`);
+      }
+    }
+
+    if (salvaged.length === 0) continue;
+
+    const extra = salvaged.join("\n");
+    uim.content = uim.content ? `${uim.content}\n\n${extra}` : extra;
+    ctx.toolResults = kept;
+    if (kept.length === 0 && !ctx.tools?.length) {
+      delete uim.userInputMessageContext;
+    }
+  }
+}
+
+/**
+ * Build a Kiro payload directly from a Claude Messages API request body.
+ */
+export function claudeToKiroRequest(model, body, stream, credentials) {
+  let messages = Array.isArray(body.messages) ? body.messages : [];
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  const clientProvidedTools = tools.length > 0;
+  const maxTokens = body.max_tokens || 32000;
+  const temperature = body.temperature;
+  const topP = body.top_p;
+
+  const { upstream: upstreamModel, agentic } = resolveKiroModel(model);
+  const thinkingBudget = resolveKiroThinkingBudget(body, credentials?.rawHeaders, model);
+
+  // Guard 1: no client tools → flatten all tool interactions to text.
+  if (!clientProvidedTools) {
+    messages = flattenClaudeToolInteractions(messages);
+  }
+
+  const { history, currentMessage } = convertClaudeMessagesToKiro(
+    messages,
+    tools,
+    upstreamModel
+  );
+
+  // Guard 2: tools present → reconcile dangling tool_results.
+  if (clientProvidedTools) {
+    reconcileOrphanedToolResults(history, currentMessage);
+  }
+
+  // api_key / idc / external_idp must never use the shared default ARN (belongs
+  // to another account → 403 "bearer token invalid"); OAuth/social fall back to it.
+  const authMethod = credentials?.providerSpecificData?.authMethod;
+  const accountBoundAuth =
+    authMethod === "api_key" || authMethod === "idc" || authMethod === "external_idp";
+  const profileArn = accountBoundAuth
+    ? (credentials?.providerSpecificData?.profileArn || "")
+    : (credentials?.providerSpecificData?.profileArn || resolveDefaultProfileArn(authMethod));
+
+  let finalContent = currentMessage?.userInputMessage?.content || "";
+
+  // System prompt → prepend to the user content.
+  if (body.system) {
+    let systemText = "";
+    if (typeof body.system === "string") {
+      systemText = body.system;
+    } else if (Array.isArray(body.system)) {
+      systemText = body.system.map((s) => s.text || "").join("\n");
+    }
+    if (systemText) finalContent = `${systemText}\n\n${finalContent}`;
+  }
+
+  // Prefix order: thinking_mode tag, timestamp marker, then agentic prompt.
+  const timestamp = new Date().toISOString();
+  const prefixParts = [];
+  if (thinkingBudget !== null) prefixParts.push(buildThinkingSystemPrefix(thinkingBudget));
+  prefixParts.push(`[Context: Current time is ${timestamp}]`);
+  if (agentic) prefixParts.push(KIRO_AGENTIC_SYSTEM_PROMPT);
+  finalContent = `${prefixParts.join("\n\n")}\n\n${finalContent}`;
+
+  const payload = {
+    conversationState: {
+      chatTriggerType: "MANUAL",
+      conversationId: uuidv4(),
+      currentMessage: {
+        userInputMessage: {
+          content: finalContent,
+          modelId: upstreamModel,
+          origin: "AI_EDITOR",
+          ...(currentMessage?.userInputMessage?.userInputMessageContext && {
+            userInputMessageContext:
+              currentMessage.userInputMessage.userInputMessageContext,
+          }),
+          ...(currentMessage?.userInputMessage?.images && {
+            images: currentMessage.userInputMessage.images,
+          }),
+        },
+      },
+      history,
+    },
+  };
+
+  if (profileArn) payload.profileArn = profileArn;
+
+  if (maxTokens || temperature !== undefined || topP !== undefined) {
+    payload.inferenceConfig = {};
+    if (maxTokens) payload.inferenceConfig.maxTokens = maxTokens;
+    if (temperature !== undefined) payload.inferenceConfig.temperature = temperature;
+    if (topP !== undefined) payload.inferenceConfig.topP = topP;
+  }
+
+  // Non-enumerable hint so the executor can route the upstream model id.
+  Object.defineProperty(payload, "_kiroUpstreamModel", {
+    value: upstreamModel,
+    enumerable: false,
+  });
+
+  return payload;
+}
+
+register(FORMATS.CLAUDE, FORMATS.KIRO, claudeToKiroRequest, null);

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

@@ -1,6 +1,14 @@
 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 { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
+import { collapseTextParts } from "../concerns/message.js";
+
+function stripAnthropicBillingHeader(text) {
+  if (typeof text !== "string") return "";
+  return text.replace(/^x-anthropic-billing-header:[^\n]*(?:\r?\n)?/i, "");
+}
 
 // Convert Claude request to OpenAI format
 export function claudeToOpenAIRequest(model, body, stream) {
@@ -23,12 +31,12 @@ export function claudeToOpenAIRequest(model, body, stream) {
   // System message
   if (body.system) {
     const systemContent = Array.isArray(body.system)
-      ? body.system.map(s => s.text || "").join("\n")
-      : body.system;
+      ? body.system.map(s => stripAnthropicBillingHeader(s.text || "")).filter(Boolean).join("\n")
+      : stripAnthropicBillingHeader(body.system);
     
     if (systemContent) {
       result.messages.push({
-        role: "system",
+        role: ROLE.SYSTEM,
         content: systemContent
       });
     }
@@ -50,13 +58,15 @@ export function claudeToOpenAIRequest(model, body, stream) {
     }
   }
 
-  // Fix missing tool responses - OpenAI requires every tool_call to have a response
-  fixMissingToolResponses(result.messages);
+  // Fix missing tool responses - OpenAI requires every tool_call to have a response.
+  // Local variant: scans contiguous tool replies + inserts "[No response received]"
+  // (distinct from the global immediate-next check in concerns/toolCall, runs on the openai leg).
+  fixMissingToolResponsesOpenAI(result.messages);
 
   // Tools
   if (body.tools && Array.isArray(body.tools)) {
     result.tools = body.tools.map(tool => ({
-      type: "function",
+      type: OPENAI_BLOCK.FUNCTION,
       function: {
         name: tool.name,
         description: String(tool.description || ""),
@@ -70,14 +80,24 @@ export function claudeToOpenAIRequest(model, body, stream) {
     result.tool_choice = convertToolChoice(body.tool_choice);
   }
 
+  if (body.reasoning_effort !== undefined) {
+    result.reasoning_effort = body.reasoning_effort;
+  } else if (body.reasoning?.effort !== undefined) {
+    result.reasoning_effort = body.reasoning.effort;
+  }
+
+  if (body.reasoning !== undefined) {
+    result.reasoning = body.reasoning;
+  }
+
   return result;
 }
 
 // Fix missing tool responses - add empty responses for tool_calls without responses
-function fixMissingToolResponses(messages) {
+function fixMissingToolResponsesOpenAI(messages) {
   for (let i = 0; i < messages.length; i++) {
     const msg = messages[i];
-    if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls && msg.tool_calls.length > 0) {
       const toolCallIds = msg.tool_calls.map(tc => tc.id);
       
       // Collect all tool response IDs that IMMEDIATELY follow this assistant message
@@ -85,7 +105,7 @@ function fixMissingToolResponses(messages) {
       let insertPosition = i + 1;
       for (let j = i + 1; j < messages.length; j++) {
         const nextMsg = messages[j];
-        if (nextMsg.role === "tool" && nextMsg.tool_call_id) {
+        if (nextMsg.role === ROLE.TOOL && nextMsg.tool_call_id) {
           respondedIds.add(nextMsg.tool_call_id);
           insertPosition = j + 1;
         } else {
@@ -98,7 +118,7 @@ function fixMissingToolResponses(messages) {
       
       if (missingIds.length > 0) {
         const missingResponses = missingIds.map(id => ({
-          role: "tool",
+          role: ROLE.TOOL,
           tool_call_id: id,
           content: "[No response received]"
         }));
@@ -109,17 +129,25 @@ function fixMissingToolResponses(messages) {
   }
 }
 
-function openAIContentFromParts(parts) {
-  if (parts.length === 0) return "";
-  if (parts.every((part) => part.type === "text")) {
-    return parts.map((part) => part.text || "").join("\n");
-  }
-  return parts;
+// Wrap mid-conversation system text so it ends as a user turn (avoids Anthropic prefill 400)
+function systemReminderText(content) {
+  const parts = Array.isArray(content)
+    ? content.filter(c => c?.type === CLAUDE_BLOCK.TEXT).map(c => c.text || "")
+    : [typeof content === "string" ? content : ""];
+  const text = parts.filter(Boolean).join("\n");
+  if (!text.trim()) return "";
+  return `<system-reminder>\n${text}\n</system-reminder>`;
 }
 
 // Convert single Claude message - returns single message or array of messages
 function convertClaudeMessage(msg) {
-  const role = msg.role === "user" || msg.role === "tool" ? "user" : "assistant";
+  // Mid-conversation system message -> user (per Anthropic placement rules)
+  if (msg.role === ROLE.SYSTEM) {
+    const text = systemReminderText(msg.content);
+    return text ? { role: ROLE.USER, content: text } : null;
+  }
+
+  const role = msg.role === ROLE.USER || msg.role === ROLE.TOOL ? ROLE.USER : ROLE.ASSISTANT;
   
   // Simple string content
   if (typeof msg.content === "string") {
@@ -134,25 +162,25 @@ function convertClaudeMessage(msg) {
 
     for (const block of msg.content) {
       switch (block.type) {
-        case "text":
-          parts.push({ type: "text", text: block.text });
+        case CLAUDE_BLOCK.TEXT:
+          parts.push({ type: OPENAI_BLOCK.TEXT, text: block.text });
           break;
 
-        case "image":
+        case CLAUDE_BLOCK.IMAGE:
           if (block.source?.type === "base64") {
             parts.push({
-              type: "image_url",
+              type: OPENAI_BLOCK.IMAGE_URL,
               image_url: {
-                url: `data:${block.source.media_type};base64,${block.source.data}`
+                url: encodeDataUri(block.source.media_type, block.source.data)
               }
             });
           }
           break;
 
-        case "tool_use":
+        case CLAUDE_BLOCK.TOOL_USE:
           toolCalls.push({
             id: block.id,
-            type: "function",
+            type: OPENAI_BLOCK.FUNCTION,
             function: {
               name: block.name,
               arguments: JSON.stringify(block.input || {})
@@ -160,13 +188,13 @@ function convertClaudeMessage(msg) {
           });
           break;
 
-        case "tool_result":
+        case CLAUDE_BLOCK.TOOL_RESULT:
           let resultContent = "";
           if (typeof block.content === "string") {
             resultContent = block.content;
           } else if (Array.isArray(block.content)) {
             resultContent = block.content
-              .filter(c => c.type === "text")
+              .filter(c => c.type === CLAUDE_BLOCK.TEXT)
               .map(c => c.text)
               .join("\n") || JSON.stringify(block.content);
           } else if (block.content) {
@@ -174,7 +202,7 @@ function convertClaudeMessage(msg) {
           }
           
           toolResults.push({
-            role: "tool",
+            role: ROLE.TOOL,
             tool_call_id: block.tool_use_id,
             content: resultContent
           });
@@ -185,16 +213,16 @@ function convertClaudeMessage(msg) {
     // If has tool results, return array of tool messages
     if (toolResults.length > 0) {
       if (parts.length > 0) {
-        return [...toolResults, { role: "user", content: openAIContentFromParts(parts) }];
+        return [...toolResults, { role: ROLE.USER, content: collapseTextParts(parts) }];
       }
       return toolResults;
     }
 
     // If has tool calls, return assistant message with tool_calls
     if (toolCalls.length > 0) {
-      const result = { role: "assistant" };
+      const result = { role: ROLE.ASSISTANT };
       if (parts.length > 0) {
-        result.content = openAIContentFromParts(parts);
+        result.content = collapseTextParts(parts);
       }
       result.tool_calls = toolCalls;
       return result;
@@ -204,7 +232,7 @@ function convertClaudeMessage(msg) {
     if (parts.length > 0) {
       return {
         role,
-        content: openAIContentFromParts(parts)
+        content: collapseTextParts(parts)
       };
     }
     
@@ -225,7 +253,7 @@ function convertToolChoice(choice) {
   switch (choice.type) {
     case "auto": return "auto";
     case "any": return "required";
-    case "tool": return { type: "function", function: { name: choice.name } };
+    case "tool": return { type: OPENAI_BLOCK.FUNCTION, function: { name: choice.name } };
     default: return "auto";
   }
 }