@khanglvm/llm-router 1.3.1 → 2.0.0-beta.0

package/src/translator/request/openai-to-claude.js

@@ -30,7 +30,7 @@ function normalizeTextContent(content) {
     const text = [];
     for (const part of content) {
       if (!part || typeof part !== "object") continue;
-      if ((part.type === "text" || part.type === "input_text") && typeof part.text === "string") {
+      if ((part.type === "text" || part.type === "input_text" || part.type === "output_text") && typeof part.text === "string") {
         text.push(part.text);
       }
     }
@@ -104,6 +104,179 @@ function convertOpenAIContentToClaudeBlocks(content) {
   return blocks;
 }
 
+function appendClaudeMessage(messages, role, blocks) {
+  if (!Array.isArray(blocks) || blocks.length === 0) return;
+  const normalizedRole = role === "assistant" ? "assistant" : "user";
+  const lastMessage = messages[messages.length - 1];
+  if (lastMessage?.role === normalizedRole && Array.isArray(lastMessage.content)) {
+    lastMessage.content.push(...blocks);
+    return;
+  }
+  messages.push({
+    role: normalizedRole,
+    content: blocks
+  });
+}
+
+function convertResponsesMessageContentToClaudeBlocks(content) {
+  if (typeof content === "string") {
+    return content ? [{ type: "text", text: content }] : [];
+  }
+
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  const blocks = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+
+    if ((part.type === "text" || part.type === "input_text" || part.type === "output_text") && typeof part.text === "string") {
+      const cacheControl = cloneCacheControl(part.cache_control);
+      blocks.push({
+        type: "text",
+        text: part.text,
+        ...(cacheControl ? { cache_control: cacheControl } : {})
+      });
+      continue;
+    }
+
+    const rawImageUrl = typeof part.image_url === "string"
+      ? part.image_url
+      : part.image_url?.url;
+    if ((part.type === "image_url" || part.type === "input_image") && typeof rawImageUrl === "string" && rawImageUrl.trim()) {
+      const parsed = parseDataUrl(rawImageUrl.trim());
+      const cacheControl = cloneCacheControl(part.cache_control);
+      if (parsed) {
+        blocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: parsed.mediaType,
+            data: parsed.data
+          },
+          ...(cacheControl ? { cache_control: cacheControl } : {})
+        });
+      } else {
+        blocks.push({
+          type: "text",
+          text: `[image_url:${rawImageUrl.trim()}]`,
+          ...(cacheControl ? { cache_control: cacheControl } : {})
+        });
+      }
+      continue;
+    }
+
+    const rawFileUrl = typeof part.file_url === "string"
+      ? part.file_url
+      : (typeof part.url === "string" ? part.url : "");
+    if (part.type === "input_file" && rawFileUrl.trim()) {
+      const cacheControl = cloneCacheControl(part.cache_control);
+      blocks.push({
+        type: "text",
+        text: `[input_file:${rawFileUrl.trim()}]`,
+        ...(cacheControl ? { cache_control: cacheControl } : {})
+      });
+    }
+  }
+
+  return blocks;
+}
+
+function normalizeResponseInputArray(input) {
+  if (Array.isArray(input)) return input;
+  if (typeof input === "string" && input.trim()) {
+    return [{
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: input.trim() }]
+    }];
+  }
+  return [];
+}
+
+function extractResponsesSystem(body) {
+  const blocks = [];
+  const pushText = (text) => {
+    if (typeof text !== "string" || !text.trim()) return;
+    blocks.push({ type: "text", text: text.trim() });
+  };
+
+  if (typeof body?.instructions === "string" && body.instructions.trim()) {
+    pushText(body.instructions);
+  }
+
+  const explicitSystem = body?.system;
+  if (typeof explicitSystem === "string" && explicitSystem.trim()) {
+    pushText(explicitSystem);
+  } else if (Array.isArray(explicitSystem)) {
+    for (const item of explicitSystem) {
+      if ((item?.type === "text" || item?.type === "input_text" || item?.type === "output_text") && typeof item.text === "string") {
+        pushText(item.text);
+      }
+    }
+  }
+
+  for (const item of normalizeResponseInputArray(body?.input)) {
+    if (!item || typeof item !== "object") continue;
+    const role = String(item.role || "").trim().toLowerCase();
+    if (role !== "system" && role !== "developer") continue;
+    const text = normalizeTextContent(item.content);
+    if (text) pushText(text);
+  }
+
+  if (blocks.length === 0) return "";
+  return blocks.map((block) => block.text).join("\n").trim();
+}
+
+function convertOpenAIResponsesInput(input) {
+  const messages = [];
+  const items = normalizeResponseInputArray(input);
+  let generatedToolIndex = 0;
+
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+
+    const itemType = String(item.type || (item.role ? "message" : "")).trim().toLowerCase();
+    if (itemType === "message") {
+      const role = String(item.role || "user").trim().toLowerCase();
+      if (role === "system" || role === "developer") {
+        continue;
+      }
+      const blocks = convertResponsesMessageContentToClaudeBlocks(item.content);
+      if (blocks.length > 0) {
+        appendClaudeMessage(messages, role === "assistant" ? "assistant" : "user", blocks);
+      }
+      continue;
+    }
+
+    if (itemType === "function_call") {
+      const callId = String(item.call_id || item.id || `tool_call_${generatedToolIndex += 1}`).trim();
+      const name = String(item.name || "tool").trim() || "tool";
+      appendClaudeMessage(messages, "assistant", [{
+        type: "tool_use",
+        id: callId,
+        name,
+        input: safeJsonParse(item.arguments, {})
+      }]);
+      continue;
+    }
+
+    if (itemType === "function_call_output") {
+      const toolUseId = String(item.call_id || item.tool_call_id || item.id || "").trim();
+      if (!toolUseId) continue;
+      const content = normalizeTextContent(item.output ?? item.content);
+      appendClaudeMessage(messages, "user", [{
+        type: "tool_result",
+        tool_use_id: toolUseId,
+        content
+      }]);
+    }
+  }
+
+  return messages;
+}
+
 function mapToolChoice(choice) {
   if (!choice) return undefined;
   if (typeof choice === "string") {
@@ -251,21 +424,47 @@ function normalizeToolInputSchema(schema) {
   return normalized;
 }
 
+function isOpenAIWebSearchToolType(type) {
+  const normalized = String(type || "").trim().toLowerCase();
+  if (!normalized) return false;
+  return normalized === "web_search" || normalized.startsWith("web_search_preview");
+}
+
+function convertOpenAIWebSearchTool(tool) {
+  if (!tool || typeof tool !== "object") return null;
+  const name = typeof tool.name === "string" && tool.name.trim()
+    ? tool.name.trim()
+    : "web_search";
+  const maxUses = Number(tool.max_uses);
+  return {
+    type: "web_search_20250305",
+    name,
+    ...(Number.isFinite(maxUses) && maxUses > 0 ? { max_uses: Math.trunc(maxUses) } : {})
+  };
+}
+
 /**
  * Convert OpenAI chat completion request to Claude messages request.
  */
 export function openAIToClaudeRequest(model, body, stream = false) {
-  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const isResponsesPayload = body?.input !== undefined || body?.instructions !== undefined;
+  const messages = isResponsesPayload
+    ? convertOpenAIResponsesInput(body?.input)
+    : convertOpenAIMessages(Array.isArray(body?.messages) ? body.messages : []);
   const result = {
     model,
-    messages: convertOpenAIMessages(messages),
+    messages,
     stream: Boolean(stream),
-    max_tokens: Number.isFinite(body?.max_tokens)
+    max_tokens: Number.isFinite(body?.max_output_tokens)
+      ? Number(body.max_output_tokens)
+      : (Number.isFinite(body?.max_tokens)
       ? Number(body.max_tokens)
-      : (Number.isFinite(body?.max_completion_tokens) ? Number(body.max_completion_tokens) : DEFAULT_MAX_TOKENS)
+      : (Number.isFinite(body?.max_completion_tokens) ? Number(body.max_completion_tokens) : DEFAULT_MAX_TOKENS))
   };
 
-  const system = normalizeSystemText(messages, body?.system);
+  const system = isResponsesPayload
+    ? extractResponsesSystem(body)
+    : normalizeSystemText(Array.isArray(body?.messages) ? body.messages : [], body?.system);
   if (system && ((Array.isArray(system) && system.length > 0) || (typeof system === "string" && system.trim()))) {
     result.system = system;
   }
@@ -278,6 +477,9 @@ export function openAIToClaudeRequest(model, body, stream = false) {
     result.tools = body.tools
       .map((tool) => {
         if (!tool || typeof tool !== "object") return null;
+        if (isOpenAIWebSearchToolType(tool.type)) {
+          return convertOpenAIWebSearchTool(tool);
+        }
         if (tool.type === "function" && tool.function) {
           const cacheControl = cloneCacheControl(tool.cache_control || tool.function?.cache_control);
           return {
@@ -287,6 +489,15 @@ export function openAIToClaudeRequest(model, body, stream = false) {
             ...(cacheControl ? { cache_control: cacheControl } : {})
           };
         }
+        if (tool.type === "function" && tool.name) {
+          const cacheControl = cloneCacheControl(tool.cache_control);
+          return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: normalizeToolInputSchema(tool.parameters),
+            ...(cacheControl ? { cache_control: cacheControl } : {})
+          };
+        }
         if (tool.name) {
           const cacheControl = cloneCacheControl(tool.cache_control);
           return {

package/src/translator/response/openai-to-claude.js

@@ -26,26 +26,7 @@ export function openaiToClaudeResponse(chunk, state) {
   }
 
   // First chunk - send message_start
-  if (!state.messageStartSent) {
-    state.messageStartSent = true;
-    state.messageId = chunk.id?.replace("chatcmpl-", "") || `msg_${Date.now()}`;
-    state.model = chunk.model || "unknown";
-    state.nextBlockIndex = 0;
-    
-    results.push({
-      type: "message_start",
-      message: {
-        id: state.messageId,
-        type: "message",
-        role: "assistant",
-        model: state.model,
-        content: [],
-        stop_reason: null,
-        stop_sequence: null,
-        usage: { input_tokens: 0, output_tokens: 0 }
-      }
-    });
-  }
+  ensureMessageStart(state, results, chunk);
 
   // Handle thinking/reasoning content
   const reasoningContent = delta?.reasoning_content || delta?.reasoning;
@@ -70,7 +51,8 @@ export function openaiToClaudeResponse(chunk, state) {
   }
 
   // Handle regular content
-  if (delta?.content) {
+  const textDelta = normalizeTextDelta(delta?.content);
+  if (textDelta) {
     stopThinkingBlock(state, results);
 
     if (!state.textBlockStarted) {
@@ -87,7 +69,7 @@ export function openaiToClaudeResponse(chunk, state) {
     results.push({
       type: "content_block_delta",
       index: state.textBlockIndex,
-      delta: { type: "text_delta", text: delta.content }
+      delta: { type: "text_delta", text: textDelta }
     });
   }
 
@@ -95,32 +77,12 @@ export function openaiToClaudeResponse(chunk, state) {
   if (delta?.tool_calls) {
     for (const tc of delta.tool_calls) {
       const idx = tc.index ?? 0;
-
-      if (tc.id) {
-        stopThinkingBlock(state, results);
-        stopTextBlock(state, results);
-
-        const toolBlockIndex = state.nextBlockIndex++;
-        state.toolCalls.set(idx, { 
-          id: tc.id, 
-          name: tc.function?.name || "", 
-          blockIndex: toolBlockIndex 
-        });
-        
-        results.push({
-          type: "content_block_start",
-          index: toolBlockIndex,
-          content_block: {
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function?.name || "",
-            input: {}
-          }
-        });
-      }
+      const toolInfo = ensureToolUseBlock(state, results, idx, {
+        id: tc.id,
+        name: tc.function?.name
+      });
 
       if (tc.function?.arguments) {
-        const toolInfo = state.toolCalls.get(idx);
         if (toolInfo) {
           results.push({
             type: "content_block_delta",
@@ -132,31 +94,215 @@ export function openaiToClaudeResponse(chunk, state) {
     }
   }
 
+  if (delta?.function_call && typeof delta.function_call === "object") {
+    const toolInfo = ensureToolUseBlock(state, results, 0, {
+      id: delta.function_call.id,
+      name: delta.function_call.name
+    });
+    if (toolInfo && delta.function_call.arguments) {
+      results.push({
+        type: "content_block_delta",
+        index: toolInfo.blockIndex,
+        delta: { type: "input_json_delta", partial_json: delta.function_call.arguments }
+      });
+    }
+  }
+
+  emitFinalChoiceMessageFallback(choice?.message, state, results);
+
   // Finish
   if (choice.finish_reason) {
-    stopThinkingBlock(state, results);
-    stopTextBlock(state, results);
+    state.finishReason = choice.finish_reason;
+    results.push(...finalizeOpenAIToClaudeStream(state));
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+function normalizeTextDelta(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => {
+      if (typeof part === "string") return part;
+      if (!part || typeof part !== "object") return "";
+      if ((part.type === "text" || part.type === "output_text") && typeof part.text === "string") {
+        return part.text;
+      }
+      return "";
+    })
+    .join("");
+}
+
+function ensureToolUseBlock(state, results, index, { id, name } = {}) {
+  if (!state?.toolCalls || !(state.toolCalls instanceof Map)) return null;
+  const normalizedIndex = Number.isFinite(index) ? Number(index) : 0;
+  const existing = state.toolCalls.get(normalizedIndex);
+  if (existing) return existing;
+
+  const toolName = typeof name === "string" && name.trim() ? name.trim() : "tool";
+  const toolId = typeof id === "string" && id.trim()
+    ? id.trim()
+    : `tool_${state.messageId || "call"}_${normalizedIndex}`;
+
+  stopThinkingBlock(state, results);
+  stopTextBlock(state, results);
+
+  const toolBlockIndex = state.nextBlockIndex++;
+  const toolInfo = {
+    id: toolId,
+    name: toolName,
+    blockIndex: toolBlockIndex,
+    closed: false
+  };
+  state.toolCalls.set(normalizedIndex, toolInfo);
+
+  results.push({
+    type: "content_block_start",
+    index: toolBlockIndex,
+    content_block: {
+      type: "tool_use",
+      id: toolId,
+      name: toolName,
+      input: {}
+    }
+  });
+
+  return toolInfo;
+}
+
+function normalizeMessageToolCalls(message) {
+  const toolCalls = Array.isArray(message?.tool_calls)
+    ? message.tool_calls.filter((call) => call && typeof call === "object")
+    : [];
+
+  if (message?.function_call && typeof message.function_call === "object") {
+    toolCalls.push({
+      id: message.function_call.id,
+      function: {
+        name: message.function_call.name,
+        arguments: message.function_call.arguments
+      }
+    });
+  }
 
-    // Stop all tool blocks
-    for (const [, toolInfo] of state.toolCalls) {
+  return toolCalls;
+}
+
+function emitTextDelta(text, state, results) {
+  if (!text) return;
+  stopThinkingBlock(state, results);
+
+  if (!state.textBlockStarted) {
+    state.textBlockIndex = state.nextBlockIndex++;
+    state.textBlockStarted = true;
+    state.textBlockClosed = false;
+    results.push({
+      type: "content_block_start",
+      index: state.textBlockIndex,
+      content_block: { type: "text", text: "" }
+    });
+  }
+
+  results.push({
+    type: "content_block_delta",
+    index: state.textBlockIndex,
+    delta: { type: "text_delta", text }
+  });
+}
+
+function emitFinalChoiceMessageFallback(message, state, results) {
+  if (!message || typeof message !== "object") return;
+
+  const hasTextOutput = state.textBlockStarted || state.textBlockClosed;
+  if (!hasTextOutput) {
+    const fallbackText = normalizeTextDelta(message.content)
+      || (typeof message.refusal === "string" ? message.refusal : "");
+    emitTextDelta(fallbackText, state, results);
+  }
+
+  const hasToolOutput = state.toolCalls instanceof Map && state.toolCalls.size > 0;
+  if (hasToolOutput) return;
+
+  const toolCalls = normalizeMessageToolCalls(message);
+  for (let index = 0; index < toolCalls.length; index += 1) {
+    const toolCall = toolCalls[index];
+    if (!toolCall || typeof toolCall !== "object") continue;
+    const toolInfo = ensureToolUseBlock(state, results, toolCall.index ?? index, {
+      id: toolCall.id,
+      name: toolCall.function?.name
+    });
+    if (toolInfo && toolCall.function?.arguments) {
       results.push({
-        type: "content_block_stop",
-        index: toolInfo.blockIndex
+        type: "content_block_delta",
+        index: toolInfo.blockIndex,
+        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
       });
     }
+  }
+}
 
-    state.finishReason = choice.finish_reason;
-    
-    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+function ensureMessageStart(state, results, chunk = undefined) {
+  if (state.messageStartSent) return;
+  state.messageStartSent = true;
+  state.messageId = chunk?.id?.replace("chatcmpl-", "") || state.messageId || `msg_${Date.now()}`;
+  state.model = chunk?.model || state.model || "unknown";
+  state.nextBlockIndex = Number.isFinite(state.nextBlockIndex) ? state.nextBlockIndex : 0;
+
+  results.push({
+    type: "message_start",
+    message: {
+      id: state.messageId,
+      type: "message",
+      role: "assistant",
+      model: state.model,
+      content: [],
+      stop_reason: null,
+      stop_sequence: null,
+      usage: { input_tokens: 0, output_tokens: 0 }
+    }
+  });
+}
+
+export function finalizeOpenAIToClaudeStream(state, { force = false } = {}) {
+  const results = [];
+  if (!state || (!state.messageStartSent && !force)) return results;
+
+  if (!state.messageStartSent) {
+    ensureMessageStart(state, results);
+  }
+
+  stopThinkingBlock(state, results);
+  stopTextBlock(state, results);
+
+  for (const [, toolInfo] of state.toolCalls) {
+    if (toolInfo?.closed) continue;
+    results.push({
+      type: "content_block_stop",
+      index: toolInfo.blockIndex
+    });
+    toolInfo.closed = true;
+  }
+
+  if (!state.messageDeltaSent) {
+    const hasToolCalls = state.toolCalls instanceof Map && state.toolCalls.size > 0;
+    const normalizedFinishReason = hasToolCalls && (!state.finishReason || state.finishReason === "stop")
+      ? "tool_calls"
+      : (state.finishReason || "stop");
     results.push({
       type: "message_delta",
-      delta: { stop_reason: convertFinishReason(choice.finish_reason) },
-      usage: finalUsage
+      delta: { stop_reason: convertFinishReason(normalizedFinishReason) },
+      usage: state.usage || { input_tokens: 0, output_tokens: 0 }
     });
+    state.messageDeltaSent = true;
+  }
+
+  if (!state.messageStopSent) {
     results.push({ type: "message_stop" });
+    state.messageStopSent = true;
   }
 
-  return results.length > 0 ? results : null;
+  return results;
 }
 
 /**
@@ -169,6 +315,7 @@ function stopThinkingBlock(state, results) {
     index: state.thinkingBlockIndex
   });
   state.thinkingBlockStarted = false;
+  state.thinkingBlockIndex = null;
 }
 
 /**
@@ -191,6 +338,7 @@ function convertFinishReason(reason) {
   switch (reason) {
     case "stop": return "end_turn";
     case "length": return "max_tokens";
+    case "function_call": return "tool_use";
     case "tool_calls": return "tool_use";
     default: return "end_turn";
   }