open-sse 1.0.0

package/translator/helpers/openaiHelper.js

@@ -0,0 +1,80 @@
+// OpenAI helper functions for translator
+
+// Valid OpenAI content block types
+export const VALID_OPENAI_CONTENT_TYPES = ["text", "image_url", "image"];
+export const VALID_OPENAI_MESSAGE_TYPES = ["text", "image_url", "image", "tool_calls", "tool_result"];
+
+// Filter messages to OpenAI standard format
+// Remove: thinking, redacted_thinking, signature, and other non-OpenAI blocks
+export function filterToOpenAIFormat(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+  
+  body.messages = body.messages.map(msg => {
+    // Keep tool messages as-is (OpenAI format)
+    if (msg.role === "tool") return msg;
+    
+    // Keep assistant messages with tool_calls as-is
+    if (msg.role === "assistant" && msg.tool_calls) return msg;
+    
+    // Handle string content
+    if (typeof msg.content === "string") return msg;
+    
+    // Handle array content
+    if (Array.isArray(msg.content)) {
+      const filteredContent = [];
+      
+      for (const block of msg.content) {
+        // Skip thinking blocks
+        if (block.type === "thinking" || block.type === "redacted_thinking") continue;
+        
+        // Only keep valid OpenAI content types
+        if (VALID_OPENAI_CONTENT_TYPES.includes(block.type)) {
+          // Remove signature field if exists
+          const { signature, cache_control, ...cleanBlock } = block;
+          filteredContent.push(cleanBlock);
+        } else if (block.type === "tool_use") {
+          // Convert tool_use to tool_calls format (handled separately)
+          continue;
+        } else if (block.type === "tool_result") {
+          // Keep tool_result but clean it
+          const { signature, cache_control, ...cleanBlock } = block;
+          filteredContent.push(cleanBlock);
+        }
+      }
+      
+      // If all content was filtered, add empty text
+      if (filteredContent.length === 0) {
+        filteredContent.push({ type: "text", text: "" });
+      }
+      
+      return { ...msg, content: filteredContent };
+    }
+    
+    return msg;
+  });
+  
+  // Filter out messages with only empty text (but NEVER filter tool messages)
+  body.messages = body.messages.filter(msg => {
+    // Always keep tool messages
+    if (msg.role === "tool") return true;
+    // Always keep assistant messages with tool_calls
+    if (msg.role === "assistant" && msg.tool_calls) return true;
+    
+    if (typeof msg.content === "string") return msg.content.trim() !== "";
+    if (Array.isArray(msg.content)) {
+      return msg.content.some(b => 
+        (b.type === "text" && b.text?.trim()) ||
+        b.type !== "text"
+      );
+    }
+    return true;
+  });
+
+  // Remove empty tools array (some providers like QWEN reject it)
+  if (body.tools && Array.isArray(body.tools) && body.tools.length === 0) {
+    delete body.tools;
+  }
+
+  return body;
+}
+

package/translator/helpers/responsesApiHelper.js

@@ -0,0 +1,103 @@
+/**
+ * Convert OpenAI Responses API format to standard chat completions format
+ * Responses API uses: { input: [...], instructions: "..." }
+ * Chat API uses: { messages: [...] }
+ */
+export function convertResponsesApiFormat(body) {
+  if (!body.input) return body;
+
+  const result = { ...body };
+  result.messages = [];
+
+  // Convert instructions to system message
+  if (body.instructions) {
+    result.messages.push({ role: "system", content: body.instructions });
+  }
+
+  // Group items by conversation turn
+  let currentAssistantMsg = null;
+  let pendingToolCalls = [];
+  let pendingToolResults = [];
+
+  for (const item of body.input) {
+    if (item.type === "message") {
+      // Flush any pending assistant message with tool calls
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+      // Flush pending tool results
+      if (pendingToolResults.length > 0) {
+        for (const tr of pendingToolResults) {
+          result.messages.push(tr);
+        }
+        pendingToolResults = [];
+      }
+
+      // Convert content: input_text → text, output_text → text
+      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 };
+            return c;
+          })
+        : item.content;
+      result.messages.push({ role: item.role, content });
+    } 
+    else if (item.type === "function_call") {
+      // Start or append to assistant message with tool_calls
+      if (!currentAssistantMsg) {
+        currentAssistantMsg = {
+          role: "assistant",
+          content: null,
+          tool_calls: []
+        };
+      }
+      currentAssistantMsg.tool_calls.push({
+        id: item.call_id,
+        type: "function",
+        function: {
+          name: item.name,
+          arguments: item.arguments
+        }
+      });
+    }
+    else if (item.type === "function_call_output") {
+      // Flush assistant message first if exists
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+      // Add tool result
+      pendingToolResults.push({
+        role: "tool",
+        tool_call_id: item.call_id,
+        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
+      });
+    }
+    else if (item.type === "reasoning") {
+      // Skip reasoning items - they are for display only
+      continue;
+    }
+  }
+
+  // Flush remaining
+  if (currentAssistantMsg) {
+    result.messages.push(currentAssistantMsg);
+  }
+  if (pendingToolResults.length > 0) {
+    for (const tr of pendingToolResults) {
+      result.messages.push(tr);
+    }
+  }
+
+  // Cleanup Responses API specific fields
+  delete result.input;
+  delete result.instructions;
+  delete result.include;
+  delete result.prompt_cache_key;
+  delete result.store;
+  delete result.reasoning;
+
+  return result;
+}

package/translator/helpers/toolCallHelper.js

@@ -0,0 +1,111 @@
+// Tool call helper functions for translator
+
+// Generate unique tool call ID
+export function generateToolCallId() {
+  return `call_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
+}
+
+// Ensure all tool_calls have id field and arguments is string (some providers require it)
+export function ensureToolCallIds(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+  
+  for (const msg of body.messages) {
+    if (msg.role === "assistant" && msg.tool_calls && Array.isArray(msg.tool_calls)) {
+      for (const tc of msg.tool_calls) {
+        if (!tc.id) {
+          tc.id = generateToolCallId();
+        }
+        if (!tc.type) {
+          tc.type = "function";
+        }
+        // Ensure arguments is JSON string, not object
+        if (tc.function?.arguments && typeof tc.function.arguments !== "string") {
+          tc.function.arguments = JSON.stringify(tc.function.arguments);
+        }
+      }
+    }
+  }
+  
+  return body;
+}
+
+// Get tool_call ids from assistant message (OpenAI format: tool_calls, Claude format: tool_use in content)
+export function getToolCallIds(msg) {
+  if (msg.role !== "assistant") return [];
+  
+  const ids = [];
+  
+  // OpenAI format: tool_calls array
+  if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      if (tc.id) ids.push(tc.id);
+    }
+  }
+  
+  // Claude format: tool_use blocks in content
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        ids.push(block.id);
+      }
+    }
+  }
+  
+  return ids;
+}
+
+// Check if user message has tool_result for given ids (OpenAI format: role=tool, Claude format: tool_result in content)
+export function hasToolResults(msg, toolCallIds) {
+  if (!msg || !toolCallIds.length) return false;
+  
+  // OpenAI format: role = "tool" with tool_call_id
+  if (msg.role === "tool" && msg.tool_call_id) {
+    return toolCallIds.includes(msg.tool_call_id);
+  }
+  
+  // Claude format: tool_result blocks in user message content
+  if (msg.role === "user" && Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_result" && toolCallIds.includes(block.tool_use_id)) {
+        return true;
+      }
+    }
+  }
+  
+  return false;
+}
+
+// Fix missing tool responses - insert empty tool_result if assistant has tool_use but next message has no tool_result
+export function fixMissingToolResponses(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+  
+  const newMessages = [];
+  
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    const nextMsg = body.messages[i + 1];
+    
+    newMessages.push(msg);
+    
+    // Check if this is assistant with tool_calls/tool_use
+    const toolCallIds = getToolCallIds(msg);
+    if (toolCallIds.length === 0) continue;
+    
+    // Check if next message has tool_result
+    if (nextMsg && !hasToolResults(nextMsg, toolCallIds)) {
+      // Insert tool responses for each tool_call
+      for (const id of toolCallIds) {
+        // OpenAI format: role = "tool"
+        newMessages.push({
+          role: "tool",
+          tool_call_id: id,
+          content: ""
+        });
+      }
+    }
+  }
+  
+  body.messages = newMessages;
+  return body;
+}
+

package/translator/index.js

@@ -0,0 +1,167 @@
+import { FORMATS } from "./formats.js";
+import { ensureToolCallIds, fixMissingToolResponses } from "./helpers/toolCallHelper.js";
+import { prepareClaudeRequest } from "./helpers/claudeHelper.js";
+import { filterToOpenAIFormat } from "./helpers/openaiHelper.js";
+import { normalizeThinkingConfig } from "../services/provider.js";
+
+// Registry for translators
+const requestRegistry = new Map();
+const responseRegistry = new Map();
+
+// Register translator
+export function register(from, to, requestFn, responseFn) {
+  const key = `${from}:${to}`;
+  if (requestFn) {
+    requestRegistry.set(key, requestFn);
+  }
+  if (responseFn) {
+    responseRegistry.set(key, responseFn);
+  }
+}
+
+// Translate request: source -> openai -> target
+export function translateRequest(sourceFormat, targetFormat, model, body, stream = true, credentials = null, provider = null) {
+  let result = body;
+
+  // Normalize thinking config: remove if lastMessage is not user
+  normalizeThinkingConfig(result);
+
+  // Always ensure tool_calls have id (some providers require it)
+  ensureToolCallIds(result);
+  
+  // Fix missing tool responses (insert empty tool_result if needed)
+  fixMissingToolResponses(result);
+
+  // If same format, skip translation steps
+  if (sourceFormat !== targetFormat) {
+    // Step 1: source -> openai (if source is not openai)
+    if (sourceFormat !== FORMATS.OPENAI) {
+      const toOpenAI = requestRegistry.get(`${sourceFormat}:${FORMATS.OPENAI}`);
+      if (toOpenAI) {
+        result = toOpenAI(model, result, stream, credentials);
+      }
+    }
+
+    // Step 1.5: Filter to clean OpenAI format (only when target is OpenAI)
+    if (targetFormat === FORMATS.OPENAI) {
+      result = filterToOpenAIFormat(result);
+    }
+
+    // Step 2: openai -> target (if target is not openai)
+    if (targetFormat !== FORMATS.OPENAI) {
+      const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
+      if (fromOpenAI) {
+        result = fromOpenAI(model, result, stream, credentials);
+      }
+    }
+  }
+
+  // Final step: prepare request for Claude format endpoints
+  if (targetFormat === FORMATS.CLAUDE) {
+    result = prepareClaudeRequest(result, provider);
+  }
+
+  return result;
+}
+
+// Translate response chunk: target -> openai -> source
+export function translateResponse(targetFormat, sourceFormat, chunk, state) {
+  // If same format, return as-is
+  if (sourceFormat === targetFormat) {
+    return [chunk];
+  }
+
+  let results = [chunk];
+
+  // Step 1: target -> openai (if target is not openai)
+  if (targetFormat !== FORMATS.OPENAI) {
+    const toOpenAI = responseRegistry.get(`${targetFormat}:${FORMATS.OPENAI}`);
+    if (toOpenAI) {
+      results = [];
+      const converted = toOpenAI(chunk, state);
+      if (converted) {
+        results = Array.isArray(converted) ? converted : [converted];
+      }
+    }
+  }
+
+  // Step 2: openai -> source (if source is not openai)
+  if (sourceFormat !== FORMATS.OPENAI) {
+    const fromOpenAI = responseRegistry.get(`${FORMATS.OPENAI}:${sourceFormat}`);
+    if (fromOpenAI) {
+      const finalResults = [];
+      for (const r of results) {
+        const converted = fromOpenAI(r, state);
+        if (converted) {
+          finalResults.push(...(Array.isArray(converted) ? converted : [converted]));
+        }
+      }
+      results = finalResults;
+    }
+  }
+
+  return results;
+}
+
+// Check if translation needed
+export function needsTranslation(sourceFormat, targetFormat) {
+  return sourceFormat !== targetFormat;
+}
+
+// Initialize state for streaming response based on format
+export function initState(sourceFormat) {
+  // Base state for all formats
+  const base = {
+    messageId: null,
+    model: null,
+    textBlockStarted: false,
+    thinkingBlockStarted: false,
+    inThinkingBlock: false,
+    currentBlockIndex: null,
+    toolCalls: new Map(),
+    finishReason: null,
+    finishReasonSent: false,
+    usage: null,
+    contentBlockIndex: -1
+  };
+
+  // Add openai-responses specific fields
+  if (sourceFormat === FORMATS.OPENAI_RESPONSES) {
+    return {
+      ...base,
+      seq: 0,
+      responseId: `resp_${Date.now()}`,
+      created: Math.floor(Date.now() / 1000),
+      started: false,
+      msgTextBuf: {},
+      msgItemAdded: {},
+      msgContentAdded: {},
+      msgItemDone: {},
+      reasoningId: "",
+      reasoningIndex: -1,
+      reasoningBuf: "",
+      reasoningPartAdded: false,
+      reasoningDone: false,
+      inThinking: false,
+      funcArgsBuf: {},
+      funcNames: {},
+      funcCallIds: {},
+      funcArgsDone: {},
+      funcItemDone: {},
+      completedSent: false
+    };
+  }
+
+  return base;
+}
+
+// Initialize all translators
+export async function initTranslators() {
+  await import("./to-openai/claude.js");
+  await import("./to-openai/gemini.js");
+  await import("./to-openai/openai.js");
+  await import("./to-openai/openai-responses.js");
+  await import("./from-openai/claude.js");
+  await import("./from-openai/gemini.js");
+  await import("./from-openai/openai-responses.js");
+}

package/translator/to-openai/claude.js

@@ -0,0 +1,238 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+// Convert Claude request to OpenAI format
+function claudeToOpenAI(model, body, stream) {
+  const result = {
+    model: model,
+    messages: [],
+    stream: stream
+  };
+
+  // Max tokens
+  if (body.max_tokens) {
+    result.max_tokens = body.max_tokens;
+  }
+
+  // Temperature
+  if (body.temperature !== undefined) {
+    result.temperature = body.temperature;
+  }
+
+  // System message
+  if (body.system) {
+    const systemContent = Array.isArray(body.system)
+      ? body.system.map(s => s.text || "").join("\n")
+      : body.system;
+    
+    if (systemContent) {
+      result.messages.push({
+        role: "system",
+        content: systemContent
+      });
+    }
+  }
+
+  // Convert messages
+  if (body.messages && Array.isArray(body.messages)) {
+    for (let i = 0; i < body.messages.length; i++) {
+      const msg = body.messages[i];
+      const converted = convertClaudeMessage(msg);
+      if (converted) {
+        // Handle array of messages (multiple tool results)
+        if (Array.isArray(converted)) {
+          result.messages.push(...converted);
+        } else {
+          result.messages.push(converted);
+        }
+      }
+    }
+  }
+
+  // Fix missing tool responses - OpenAI requires every tool_call to have a response
+  fixMissingToolResponses(result.messages);
+
+  // Tools
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools.map(tool => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema || { type: "object", properties: {} }
+      }
+    }));
+  }
+
+  // Tool choice
+  if (body.tool_choice) {
+    result.tool_choice = convertToolChoice(body.tool_choice);
+  }
+
+  return result;
+}
+
+// Fix missing tool responses - add empty responses for tool_calls without responses
+function fixMissingToolResponses(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) {
+      const toolCallIds = msg.tool_calls.map(tc => tc.id);
+      
+      // Collect all tool response IDs that IMMEDIATELY follow this assistant message
+      // Stop at any non-tool message (user or assistant)
+      const respondedIds = new Set();
+      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) {
+          respondedIds.add(nextMsg.tool_call_id);
+          insertPosition = j + 1;
+        } else {
+          // Stop at any non-tool message (user or assistant)
+          break;
+        }
+      }
+      
+      // Find missing responses and insert them
+      const missingIds = toolCallIds.filter(id => !respondedIds.has(id));
+      
+      if (missingIds.length > 0) {
+        const missingResponses = missingIds.map(id => ({
+          role: "tool",
+          tool_call_id: id,
+          content: "[No response received]"
+        }));
+        // Insert missing responses at the correct position
+        messages.splice(insertPosition, 0, ...missingResponses);
+        // Adjust index to skip inserted messages
+        i = insertPosition + missingResponses.length - 1;
+      }
+    }
+  }
+}
+
+// Convert single Claude message - returns single message or array of messages
+function convertClaudeMessage(msg) {
+  const role = msg.role === "user" || msg.role === "tool" ? "user" : "assistant";
+  
+  // Simple string content
+  if (typeof msg.content === "string") {
+    return { role, content: msg.content };
+  }
+
+  // Array content
+  if (Array.isArray(msg.content)) {
+    const parts = [];
+    const toolCalls = [];
+    const toolResults = [];
+
+    for (const block of msg.content) {
+      switch (block.type) {
+        case "text":
+          parts.push({ type: "text", text: block.text });
+          break;
+
+        case "image":
+          if (block.source?.type === "base64") {
+            parts.push({
+              type: "image_url",
+              image_url: {
+                url: `data:${block.source.media_type};base64,${block.source.data}`
+              }
+            });
+          }
+          break;
+
+        case "tool_use":
+          toolCalls.push({
+            id: block.id,
+            type: "function",
+            function: {
+              name: block.name,
+              arguments: JSON.stringify(block.input || {})
+            }
+          });
+          break;
+
+        case "tool_result":
+          // Extract actual content from tool_result
+          let resultContent = "";
+          if (typeof block.content === "string") {
+            resultContent = block.content;
+          } else if (Array.isArray(block.content)) {
+            // Claude tool_result content can be array of text blocks
+            resultContent = block.content
+              .filter(c => c.type === "text")
+              .map(c => c.text)
+              .join("\n") || JSON.stringify(block.content);
+          } else if (block.content) {
+            resultContent = JSON.stringify(block.content);
+          }
+          
+          toolResults.push({
+            role: "tool",
+            tool_call_id: block.tool_use_id,
+            content: resultContent
+          });
+          break;
+      }
+    }
+
+    // If has tool results, return array of tool messages
+    if (toolResults.length > 0) {
+      // Also include text parts as user message if any
+      if (parts.length > 0) {
+        const textContent = parts.length === 1 && parts[0].type === "text" 
+          ? parts[0].text 
+          : parts;
+        return [...toolResults, { role: "user", content: textContent }];
+      }
+      return toolResults;
+    }
+
+    // If has tool calls, return assistant message with tool_calls
+    if (toolCalls.length > 0) {
+      const result = { role: "assistant" };
+      if (parts.length > 0) {
+        result.content = parts.length === 1 && parts[0].type === "text" 
+          ? parts[0].text 
+          : parts;
+      }
+      result.tool_calls = toolCalls;
+      return result;
+    }
+
+    // Return content
+    if (parts.length > 0) {
+      return {
+        role,
+        content: parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts
+      };
+    }
+    
+    // Empty content array - return empty string content to keep message in conversation
+    if (msg.content.length === 0) {
+      return { role, content: "" };
+    }
+  }
+
+  return null;
+}
+
+// Convert tool choice
+function convertToolChoice(choice) {
+  if (!choice) return "auto";
+  if (typeof choice === "string") return choice;
+  
+  switch (choice.type) {
+    case "auto": return "auto";
+    case "any": return "required";
+    case "tool": return { type: "function", function: { name: choice.name } };
+    default: return "auto";
+  }
+}
+
+// Register
+register(FORMATS.CLAUDE, FORMATS.OPENAI, claudeToOpenAI, null);
+