open-sse 1.0.0

package/translator/from-openai/openai-responses.js

@@ -0,0 +1,361 @@
+/**
+ * Translator: OpenAI Chat Completions → OpenAI Responses API (response)
+ * Converts streaming chunks from Chat Completions to Responses API events
+ */
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+
+/**
+ * Translate OpenAI chunk to Responses API events
+ * @returns {Array} Array of events with { event, data } structure
+ */
+function translateResponse(chunk, state) {
+  if (!chunk) {
+    // Flush remaining events
+    return flushEvents(state);
+  }
+  
+  if (!chunk.choices?.length) return [];
+  
+  const events = [];
+  const nextSeq = () => ++state.seq;
+  
+  const emit = (eventType, data) => {
+    data.sequence_number = nextSeq();
+    events.push({ event: eventType, data });
+  };
+
+  const choice = chunk.choices[0];
+  const idx = choice.index || 0;
+  const delta = choice.delta || {};
+
+  // Emit initial events
+  if (!state.started) {
+    state.started = true;
+    state.responseId = chunk.id ? `resp_${chunk.id}` : state.responseId;
+    
+    emit("response.created", {
+      type: "response.created",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress",
+        background: false,
+        error: null,
+        output: []
+      }
+    });
+
+    emit("response.in_progress", {
+      type: "response.in_progress",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress"
+      }
+    });
+  }
+
+  // Handle reasoning_content
+  if (delta.reasoning_content) {
+    startReasoning(state, emit, idx);
+    emitReasoningDelta(state, emit, delta.reasoning_content);
+  }
+
+  // Handle text content
+  if (delta.content) {
+    let content = delta.content;
+
+    if (content.includes("<think>")) {
+      state.inThinking = true;
+      content = content.replace("<think>", "");
+      startReasoning(state, emit, idx);
+    }
+
+    if (content.includes("</think>")) {
+      const parts = content.split("</think>");
+      const thinkPart = parts[0];
+      const textPart = parts.slice(1).join("</think>");
+      if (thinkPart) emitReasoningDelta(state, emit, thinkPart);
+      closeReasoning(state, emit);
+      state.inThinking = false;
+      content = textPart;
+    }
+
+    if (state.inThinking && content) {
+      emitReasoningDelta(state, emit, content);
+      return events;
+    }
+
+    if (content) {
+      emitTextContent(state, emit, idx, content);
+    }
+  }
+
+  // Handle tool_calls
+  if (delta.tool_calls) {
+    closeMessage(state, emit, idx);
+    for (const tc of delta.tool_calls) {
+      emitToolCall(state, emit, tc);
+    }
+  }
+
+  // Handle finish_reason
+  if (choice.finish_reason) {
+    for (const i in state.msgItemAdded) closeMessage(state, emit, i);
+    closeReasoning(state, emit);
+    for (const i in state.funcCallIds) closeToolCall(state, emit, i);
+    sendCompleted(state, emit);
+  }
+
+  return events;
+}
+
+// Helper functions
+function startReasoning(state, emit, idx) {
+  if (!state.reasoningId) {
+    state.reasoningId = `rs_${state.responseId}_${idx}`;
+    state.reasoningIndex = idx;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: idx,
+      item: { id: state.reasoningId, type: "reasoning", summary: [] }
+    });
+
+    emit("response.reasoning_summary_part.added", {
+      type: "response.reasoning_summary_part.added",
+      item_id: state.reasoningId,
+      output_index: idx,
+      summary_index: 0,
+      part: { type: "summary_text", text: "" }
+    });
+    state.reasoningPartAdded = true;
+  }
+}
+
+function emitReasoningDelta(state, emit, text) {
+  if (!text) return;
+  state.reasoningBuf += text;
+  emit("response.reasoning_summary_text.delta", {
+    type: "response.reasoning_summary_text.delta",
+    item_id: state.reasoningId,
+    output_index: state.reasoningIndex,
+    summary_index: 0,
+    delta: text
+  });
+}
+
+function closeReasoning(state, emit) {
+  if (state.reasoningId && !state.reasoningDone) {
+    state.reasoningDone = true;
+    
+    emit("response.reasoning_summary_text.done", {
+      type: "response.reasoning_summary_text.done",
+      item_id: state.reasoningId,
+      output_index: state.reasoningIndex,
+      summary_index: 0,
+      text: state.reasoningBuf
+    });
+
+    emit("response.reasoning_summary_part.done", {
+      type: "response.reasoning_summary_part.done",
+      item_id: state.reasoningId,
+      output_index: state.reasoningIndex,
+      summary_index: 0,
+      part: { type: "summary_text", text: state.reasoningBuf }
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: state.reasoningIndex,
+      item: {
+        id: state.reasoningId,
+        type: "reasoning",
+        summary: [{ type: "summary_text", text: state.reasoningBuf }]
+      }
+    });
+  }
+}
+
+function emitTextContent(state, emit, idx, content) {
+  if (!state.msgItemAdded[idx]) {
+    state.msgItemAdded[idx] = true;
+    const msgId = `msg_${state.responseId}_${idx}`;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: idx,
+      item: { id: msgId, type: "message", content: [], role: "assistant" }
+    });
+  }
+
+  if (!state.msgContentAdded[idx]) {
+    state.msgContentAdded[idx] = true;
+    
+    emit("response.content_part.added", {
+      type: "response.content_part.added",
+      item_id: `msg_${state.responseId}_${idx}`,
+      output_index: idx,
+      content_index: 0,
+      part: { type: "output_text", annotations: [], logprobs: [], text: "" }
+    });
+  }
+
+  emit("response.output_text.delta", {
+    type: "response.output_text.delta",
+    item_id: `msg_${state.responseId}_${idx}`,
+    output_index: idx,
+    content_index: 0,
+    delta: content,
+    logprobs: []
+  });
+
+  if (!state.msgTextBuf[idx]) state.msgTextBuf[idx] = "";
+  state.msgTextBuf[idx] += content;
+}
+
+function closeMessage(state, emit, idx) {
+  if (state.msgItemAdded[idx] && !state.msgItemDone[idx]) {
+    state.msgItemDone[idx] = true;
+    const fullText = state.msgTextBuf[idx] || "";
+    const msgId = `msg_${state.responseId}_${idx}`;
+
+    emit("response.output_text.done", {
+      type: "response.output_text.done",
+      item_id: msgId,
+      output_index: parseInt(idx),
+      content_index: 0,
+      text: fullText,
+      logprobs: []
+    });
+
+    emit("response.content_part.done", {
+      type: "response.content_part.done",
+      item_id: msgId,
+      output_index: parseInt(idx),
+      content_index: 0,
+      part: { type: "output_text", annotations: [], logprobs: [], text: fullText }
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: parseInt(idx),
+      item: {
+        id: msgId,
+        type: "message",
+        content: [{ type: "output_text", annotations: [], logprobs: [], text: fullText }],
+        role: "assistant"
+      }
+    });
+  }
+}
+
+function emitToolCall(state, emit, tc) {
+  const tcIdx = tc.index ?? 0;
+  const newCallId = tc.id;
+  const funcName = tc.function?.name;
+
+  if (funcName) state.funcNames[tcIdx] = funcName;
+
+  if (!state.funcCallIds[tcIdx] && newCallId) {
+    state.funcCallIds[tcIdx] = newCallId;
+    
+    emit("response.output_item.added", {
+      type: "response.output_item.added",
+      output_index: tcIdx,
+      item: {
+        id: `fc_${newCallId}`,
+        type: "function_call",
+        arguments: "",
+        call_id: newCallId,
+        name: state.funcNames[tcIdx] || ""
+      }
+    });
+  }
+
+  if (!state.funcArgsBuf[tcIdx]) state.funcArgsBuf[tcIdx] = "";
+
+  if (tc.function?.arguments) {
+    const refCallId = state.funcCallIds[tcIdx] || newCallId;
+    if (refCallId) {
+      emit("response.function_call_arguments.delta", {
+        type: "response.function_call_arguments.delta",
+        item_id: `fc_${refCallId}`,
+        output_index: tcIdx,
+        delta: tc.function.arguments
+      });
+    }
+    state.funcArgsBuf[tcIdx] += tc.function.arguments;
+  }
+}
+
+function closeToolCall(state, emit, idx) {
+  const callId = state.funcCallIds[idx];
+  if (callId && !state.funcItemDone[idx]) {
+    const args = state.funcArgsBuf[idx] || "{}";
+    
+    emit("response.function_call_arguments.done", {
+      type: "response.function_call_arguments.done",
+      item_id: `fc_${callId}`,
+      output_index: parseInt(idx),
+      arguments: args
+    });
+
+    emit("response.output_item.done", {
+      type: "response.output_item.done",
+      output_index: parseInt(idx),
+      item: {
+        id: `fc_${callId}`,
+        type: "function_call",
+        arguments: args,
+        call_id: callId,
+        name: state.funcNames[idx] || ""
+      }
+    });
+
+    state.funcItemDone[idx] = true;
+    state.funcArgsDone[idx] = true;
+  }
+}
+
+function sendCompleted(state, emit) {
+  if (!state.completedSent) {
+    state.completedSent = true;
+    emit("response.completed", {
+      type: "response.completed",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "completed",
+        background: false,
+        error: null
+      }
+    });
+  }
+}
+
+function flushEvents(state) {
+  if (state.completedSent) return [];
+  
+  const events = [];
+  const nextSeq = () => ++state.seq;
+  const emit = (eventType, data) => {
+    data.sequence_number = nextSeq();
+    events.push({ event: eventType, data });
+  };
+
+  for (const i in state.msgItemAdded) closeMessage(state, emit, i);
+  closeReasoning(state, emit);
+  for (const i in state.funcCallIds) closeToolCall(state, emit, i);
+  sendCompleted(state, emit);
+  
+  return events;
+}
+
+// Register translator
+register(FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES, null, translateResponse);
+

package/translator/helpers/claudeHelper.js

@@ -0,0 +1,179 @@
+// Claude helper functions for translator
+import { DEFAULT_THINKING_CLAUDE_SIGNATURE } from "../../config/defaultThinkingSignature.js";
+
+// Check if message has valid non-empty content
+export function hasValidContent(msg) {
+  if (typeof msg.content === "string" && msg.content.trim()) return true;
+  if (Array.isArray(msg.content)) {
+    return msg.content.some(block =>
+      (block.type === "text" && block.text?.trim()) ||
+      block.type === "tool_use" ||
+      block.type === "tool_result"
+    );
+  }
+  return false;
+}
+
+// Fix tool_use/tool_result ordering for Claude API
+// 1. Assistant message with tool_use: remove text AFTER tool_use (Claude doesn't allow)
+// 2. Merge consecutive same-role messages
+export function fixToolUseOrdering(messages) {
+  if (messages.length <= 1) return messages;
+  
+  // Pass 1: Fix assistant messages with tool_use - remove text after tool_use
+  for (const msg of messages) {
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      const hasToolUse = msg.content.some(b => b.type === "tool_use");
+      if (hasToolUse) {
+        // Keep only: thinking blocks + tool_use blocks (remove text blocks after tool_use)
+        const newContent = [];
+        let foundToolUse = false;
+        
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            foundToolUse = true;
+            newContent.push(block);
+          } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+            newContent.push(block);
+          } else if (!foundToolUse) {
+            // Keep text blocks BEFORE tool_use
+            newContent.push(block);
+          }
+          // Skip text blocks AFTER tool_use
+        }
+        
+        msg.content = newContent;
+      }
+    }
+  }
+  
+  // Pass 2: Merge consecutive same-role messages
+  const merged = [];
+  
+  for (const msg of messages) {
+    const last = merged[merged.length - 1];
+    
+    if (last && last.role === msg.role) {
+      // Merge content arrays
+      const lastContent = Array.isArray(last.content) ? last.content : [{ type: "text", text: last.content }];
+      const msgContent = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+      
+      // Put tool_result first, then other content
+      const toolResults = [...lastContent.filter(b => b.type === "tool_result"), ...msgContent.filter(b => b.type === "tool_result")];
+      const otherContent = [...lastContent.filter(b => b.type !== "tool_result"), ...msgContent.filter(b => b.type !== "tool_result")];
+      
+      last.content = [...toolResults, ...otherContent];
+    } else {
+      // Ensure content is array
+      const content = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+      merged.push({ role: msg.role, content: [...content] });
+    }
+  }
+  
+  return merged;
+}
+
+// Prepare request for Claude format endpoints
+// - Cleanup cache_control
+// - Filter empty messages
+// - Add thinking block for Anthropic endpoint (provider === "claude")
+// - Fix tool_use/tool_result ordering
+export function prepareClaudeRequest(body, provider = null) {
+  // 1. System: remove all cache_control, add only to last block with ttl 1h
+  if (body.system && Array.isArray(body.system)) {
+    body.system = body.system.map((block, i) => {
+      const { cache_control, ...rest } = block;
+      if (i === body.system.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+  }
+
+  // 2. Messages: process in optimized passes
+  if (body.messages && Array.isArray(body.messages)) {
+    const len = body.messages.length;
+    let filtered = [];
+
+    // Pass 1: remove cache_control + filter empty messages
+    for (let i = 0; i < len; i++) {
+      const msg = body.messages[i];
+      
+      // Remove cache_control from content blocks
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          delete block.cache_control;
+        }
+      }
+
+      // Keep final assistant even if empty, otherwise check valid content
+      const isFinalAssistant = i === len - 1 && msg.role === "assistant";
+      if (isFinalAssistant || hasValidContent(msg)) {
+        filtered.push(msg);
+      }
+    }
+
+    // Pass 1.5: Fix tool_use/tool_result ordering
+    // Each tool_use must have tool_result in the NEXT message (not same message with other content)
+    filtered = fixToolUseOrdering(filtered);
+
+    body.messages = filtered;
+
+    // Check if thinking is enabled AND last message is from user
+    const lastMessage = filtered[filtered.length - 1];
+    const lastMessageIsUser = lastMessage?.role === "user";
+    const thinkingEnabled = body.thinking?.type === "enabled" && lastMessageIsUser;
+
+    // Pass 2 (reverse): add cache_control to last assistant + handle thinking for Anthropic
+    let lastAssistantProcessed = false;
+    for (let i = filtered.length - 1; i >= 0; i--) {
+      const msg = filtered[i];
+      
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        // Add cache_control to last block of first (from end) assistant with content
+        if (!lastAssistantProcessed && msg.content.length > 0) {
+          msg.content[msg.content.length - 1].cache_control = { type: "ephemeral" };
+          lastAssistantProcessed = true;
+        }
+
+        // Handle thinking blocks for Anthropic endpoint only
+        if (provider === "claude") {
+          let hasToolUse = false;
+          let hasThinking = false;
+          
+          // Always replace signature for all thinking blocks
+          for (const block of msg.content) {
+            if (block.type === "thinking" || block.type === "redacted_thinking") {
+              block.signature = DEFAULT_THINKING_CLAUDE_SIGNATURE;
+              hasThinking = true;
+            }
+            if (block.type === "tool_use") hasToolUse = true;
+          }
+
+          // Add thinking block if thinking enabled + has tool_use but no thinking
+          if (thinkingEnabled && !hasThinking && hasToolUse) {
+            msg.content.unshift({
+              type: "thinking",
+              thinking: ".",
+              signature: DEFAULT_THINKING_CLAUDE_SIGNATURE
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Tools: remove all cache_control, add only to last tool with ttl 1h
+  if (body.tools && Array.isArray(body.tools)) {
+    body.tools = body.tools.map((tool, i) => {
+      const { cache_control, ...rest } = tool;
+      if (i === body.tools.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+  }
+
+  return body;
+}
+

package/translator/helpers/geminiHelper.js

@@ -0,0 +1,131 @@
+// Gemini helper functions for translator
+
+// Unsupported JSON Schema constraints that should be removed for Antigravity
+export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
+  "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
+  "pattern", "minItems", "maxItems", "format",
+  "default", "examples", "$schema", "const"
+];
+
+// Default safety settings
+export const DEFAULT_SAFETY_SETTINGS = [
+  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+];
+
+// Convert OpenAI content to Gemini parts
+export function convertOpenAIContentToParts(content) {
+  const parts = [];
+  
+  if (typeof content === "string") {
+    parts.push({ text: content });
+  } else if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === "text") {
+        parts.push({ text: item.text });
+      } else if (item.type === "image_url" && item.image_url?.url?.startsWith("data:")) {
+        const match = item.image_url.url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          parts.push({
+            inlineData: { mime_type: match[1], data: match[2] }
+          });
+        }
+      }
+    }
+  }
+  
+  return parts;
+}
+
+// Extract text content from OpenAI content
+export 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("");
+  }
+  return "";
+}
+
+// Try parse JSON safely
+export function tryParseJSON(str) {
+  if (typeof str !== "string") return str;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return null;
+  }
+}
+
+// Generate request ID
+export function generateRequestId() {
+  return `agent-${crypto.randomUUID()}`;
+}
+
+// Generate session ID
+export function generateSessionId() {
+  return `-${Math.floor(Math.random() * 9000000000000000000)}`;
+}
+
+// Generate project ID
+export function generateProjectId() {
+  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
+  const nouns = ["fuze", "wave", "spark", "flow", "core"];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
+}
+
+// Clean JSON Schema for Antigravity API compatibility - removes unsupported keywords recursively
+export function cleanJSONSchemaForAntigravity(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  
+  const cleaned = Array.isArray(schema) ? [] : {};
+  
+  for (const [key, value] of Object.entries(schema)) {
+    if (UNSUPPORTED_SCHEMA_CONSTRAINTS.includes(key)) continue;
+    
+    // Handle type array like ["string", "null"] - Gemini only supports single type
+    if (key === "type" && Array.isArray(value)) {
+      const nonNullType = value.find(t => t !== "null") || "string";
+      cleaned[key] = nonNullType;
+      continue;
+    }
+    
+    if (value && typeof value === "object") {
+      cleaned[key] = cleanJSONSchemaForAntigravity(value);
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  
+  // Cleanup required fields - only keep fields that exist in properties
+  if (cleaned.required && Array.isArray(cleaned.required) && cleaned.properties) {
+    const validRequired = cleaned.required.filter(field => 
+      Object.prototype.hasOwnProperty.call(cleaned.properties, field)
+    );
+    if (validRequired.length === 0) {
+      delete cleaned.required;
+    } else {
+      cleaned.required = validRequired;
+    }
+  }
+  
+  // Add placeholder for empty object schemas (Antigravity requirement)
+  if (cleaned.type === "object") {
+    if (!cleaned.properties || Object.keys(cleaned.properties).length === 0) {
+      cleaned.properties = {
+        reason: {
+          type: "string",
+          description: "Brief explanation of why you are calling this tool"
+        }
+      };
+      cleaned.required = ["reason"];
+    }
+  }
+  
+  return cleaned;
+}
+