vforclaude2 0.3.87

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

@@ -0,0 +1,129 @@
+/**
+ * Normalize Responses API input to array format.
+ * Accepts string or array, returns array of message items.
+ * @param {string|Array} input - raw input from Responses API body
+ * @returns {Array|null} normalized array or null if invalid
+ */
+export function normalizeResponsesInput(input) {
+  if (typeof input === "string") {
+    const text = input.trim() === "" ? "..." : input;
+    return [{ type: "message", role: "user", content: [{ type: "input_text", text }] }];
+  }
+  if (Array.isArray(input)) return input;
+  return null;
+}
+
+/**
+ * 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 = [];
+
+  const inputItems = normalizeResponsesInput(body.input);
+  if (!inputItems) return body;
+
+  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);
+
+    if (itemType === "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, 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") {
+            const url = c.image_url || c.file_id || "";
+            return { type: "image_url", image_url: { url, detail: c.detail || "auto" } };
+          }
+          return c;
+        })
+        : item.content;
+      result.messages.push({ role: item.role, content });
+    }
+    else if (itemType === "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 (itemType === "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 (itemType === "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/open-sse/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/open-sse/translator/index.js

@@ -0,0 +1,204 @@
+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();
+
+// Track initialization state
+let initialized = false;
+
+// 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);
+  }
+}
+
+// Lazy load translators (called once on first use)
+function ensureInitialized() {
+  if (initialized) return;
+  initialized = true;
+
+  // Request translators - sync require pattern for bundler
+  require("./request/claude-to-openai.js");
+  require("./request/openai-to-claude.js");
+  require("./request/gemini-to-openai.js");
+  require("./request/openai-to-gemini.js");
+  require("./request/antigravity-to-openai.js");
+  require("./request/openai-responses.js");
+  require("./request/openai-to-kiro.js");
+  require("./request/openai-to-cursor.js");
+  require("./request/openai-to-ollama.js");
+
+  // Response translators
+  require("./response/claude-to-openai.js");
+  require("./response/openai-to-claude.js");
+  require("./response/gemini-to-openai.js");
+  require("./response/openai-to-antigravity.js");
+  require("./response/openai-responses.js");
+  require("./response/kiro-to-openai.js");
+  require("./response/cursor-to-openai.js");
+  require("./response/ollama-to-openai.js");
+}
+
+// Translate request: source -> openai -> target
+export function translateRequest(sourceFormat, targetFormat, model, body, stream = true, credentials = null, provider = null, reqLogger = null) {
+  ensureInitialized();
+  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);
+        // Log OpenAI intermediate format
+        reqLogger?.logOpenAIRequest?.(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);
+      }
+    }
+  }
+
+  // Always normalize to clean OpenAI format when target is OpenAI
+  // This handles hybrid requests (e.g., OpenAI messages + Claude tools)
+  if (targetFormat === FORMATS.OPENAI) {
+    result = filterToOpenAIFormat(result);
+  }
+
+  // Final step: prepare request for Claude format endpoints
+  if (targetFormat === FORMATS.CLAUDE) {
+    const apiKey = credentials?.accessToken || credentials?.apiKey || null;
+    result = prepareClaudeRequest(result, provider, apiKey);
+  }
+
+  return result;
+}
+
+// Translate response chunk: target -> openai -> source
+export function translateResponse(targetFormat, sourceFormat, chunk, state) {
+  ensureInitialized();
+  // If same format, return as-is
+  if (sourceFormat === targetFormat) {
+    return [chunk];
+  }
+
+  let results = [chunk];
+  let openaiResults = null; // Store OpenAI intermediate results
+
+  // 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];
+        openaiResults = results; // Store OpenAI intermediate
+      }
+    }
+  }
+
+  // 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;
+    }
+  }
+
+  // Attach OpenAI intermediate results for logging
+  if (openaiResults && sourceFormat !== FORMATS.OPENAI && targetFormat !== FORMATS.OPENAI) {
+    results._openaiIntermediate = openaiResults;
+  }
+
+  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 (kept for backward compatibility)
+export function initTranslators() {
+  ensureInitialized();
+}

package/open-sse/translator/request/antigravity-to-openai.js

@@ -0,0 +1,223 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
+
+// Convert Antigravity request to OpenAI format
+// Antigravity body: { project, model, userAgent, requestType, requestId, request: { contents, systemInstruction, tools, toolConfig, generationConfig, sessionId } }
+export function antigravityToOpenAIRequest(model, body, stream) {
+  const req = body.request || body;
+  const result = {
+    model: model,
+    messages: [],
+    stream: stream
+  };
+
+  // Generation config
+  if (req.generationConfig) {
+    const config = req.generationConfig;
+    if (config.maxOutputTokens) {
+      const tempBody = { max_tokens: config.maxOutputTokens, tools: req.tools };
+      result.max_tokens = adjustMaxTokens(tempBody);
+    }
+    if (config.temperature !== undefined) {
+      result.temperature = config.temperature;
+    }
+    if (config.topP !== undefined) {
+      result.top_p = config.topP;
+    }
+    if (config.topK !== undefined) {
+      result.top_k = config.topK;
+    }
+
+    // Thinking config → reasoning_effort
+    if (config.thinkingConfig) {
+      const budget = config.thinkingConfig.thinkingBudget || 0;
+      if (budget > 0) {
+        if (budget <= 2048) {
+          result.reasoning_effort = "low";
+        } else if (budget <= 16384) {
+          result.reasoning_effort = "medium";
+        } else {
+          result.reasoning_effort = "high";
+        }
+      }
+    }
+  }
+
+  // System instruction
+  if (req.systemInstruction) {
+    const systemText = extractText(req.systemInstruction);
+    if (systemText) {
+      result.messages.push({ role: "system", content: systemText });
+    }
+  }
+
+  // Convert contents to messages
+  if (req.contents && Array.isArray(req.contents)) {
+    for (const content of req.contents) {
+      const converted = convertContent(content);
+      if (converted) {
+        if (Array.isArray(converted)) {
+          result.messages.push(...converted);
+        } else {
+          result.messages.push(converted);
+        }
+      }
+    }
+  }
+
+  // Tools
+  if (req.tools && Array.isArray(req.tools)) {
+    result.tools = [];
+    for (const tool of req.tools) {
+      if (tool.functionDeclarations) {
+        for (const func of tool.functionDeclarations) {
+          result.tools.push({
+            type: "function",
+            function: {
+              name: func.name,
+              description: func.description || "",
+              parameters: normalizeSchemaTypes(func.parameters) || { type: "object", properties: {} }
+            }
+          });
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+// Recursively convert Antigravity schema types (OBJECT, STRING, etc.) to lowercase
+function normalizeSchemaTypes(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  const result = Array.isArray(schema) ? [...schema] : { ...schema };
+
+  if (typeof result.type === "string") {
+    result.type = result.type.toLowerCase();
+  }
+
+  if (result.properties) {
+    const normalized = {};
+    for (const [key, val] of Object.entries(result.properties)) {
+      normalized[key] = normalizeSchemaTypes(val);
+    }
+    result.properties = normalized;
+  }
+
+  if (result.items) {
+    result.items = normalizeSchemaTypes(result.items);
+  }
+
+  return result;
+}
+
+// Convert Antigravity content to OpenAI message
+// Handles: text, thought, thoughtSignature, functionCall, functionResponse, inlineData
+function convertContent(content) {
+  const role = content.role === "model" ? "assistant" : content.role === "user" ? "user" : content.role;
+
+  if (!content.parts || !Array.isArray(content.parts)) {
+    return null;
+  }
+
+  const textParts = [];
+  const toolCalls = [];
+  const toolResults = [];
+  let reasoningContent = "";
+
+  for (const part of content.parts) {
+    // Thinking content (thought: true)
+    if (part.thought === true && part.text) {
+      reasoningContent += part.text;
+      continue;
+    }
+
+    // Text with thoughtSignature = regular text after thinking
+    if (part.thoughtSignature && part.text !== undefined) {
+      textParts.push({ type: "text", text: part.text });
+      continue;
+    }
+
+    // Regular text
+    if (part.text !== undefined) {
+      textParts.push({ type: "text", text: part.text });
+    }
+
+    // Inline data (images)
+    if (part.inlineData) {
+      textParts.push({
+        type: "image_url",
+        image_url: {
+          url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
+        }
+      });
+    }
+
+    // Function call
+    if (part.functionCall) {
+      toolCalls.push({
+        id: part.functionCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        type: "function",
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args || {})
+        }
+      });
+    }
+
+    // Function response → collect all, each becomes a separate tool message
+    if (part.functionResponse) {
+      toolResults.push({
+        role: "tool",
+        tool_call_id: part.functionResponse.id || part.functionResponse.name,
+        content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
+      });
+    }
+  }
+
+  // Content with only functionResponses → return array of tool messages
+  if (toolResults.length > 0) {
+    return toolResults;
+  }
+
+  // Assistant with tool calls
+  if (toolCalls.length > 0) {
+    const msg = { role: "assistant" };
+    if (textParts.length > 0) {
+      msg.content = textParts.length === 1 && textParts[0].type === "text" ? textParts[0].text : textParts;
+    }
+    if (reasoningContent) {
+      msg.reasoning_content = reasoningContent;
+    }
+    msg.tool_calls = toolCalls;
+    return msg;
+  }
+
+  // Regular message
+  if (textParts.length > 0 || reasoningContent) {
+    const msg = { role };
+    if (textParts.length > 0) {
+      msg.content = textParts.length === 1 && textParts[0].type === "text" ? textParts[0].text : textParts;
+    }
+    if (reasoningContent) {
+      msg.reasoning_content = reasoningContent;
+    }
+    return msg;
+  }
+
+  return null;
+}
+
+// Extract text from systemInstruction
+function extractText(instruction) {
+  if (typeof instruction === "string") return instruction;
+  if (instruction.parts && Array.isArray(instruction.parts)) {
+    return instruction.parts.map(p => p.text || "").join("");
+  }
+  return "";
+}
+
+// Register
+register(FORMATS.ANTIGRAVITY, FORMATS.OPENAI, antigravityToOpenAIRequest, null);