zevairouter 1.0.152 → 1.0.154

package/open-sse/transformer/streamToJsonConverter.js

@@ -8,35 +8,55 @@
  * Process a single SSE message and update state accordingly.
  */
 function processSSEMessage(msg, state) {
-  if (!msg.trim()) return;
+  if (!msg.trim()) return { terminal: false, streamDone: false };
 
   const eventMatch = msg.match(/^event:\s*(.+)$/m);
   const dataMatch = msg.match(/^data:\s*(.+)$/m);
-  if (!eventMatch || !dataMatch) return;
+  if (!dataMatch) return { terminal: false, streamDone: false };
 
-  const eventType = eventMatch[1].trim();
   const dataStr = dataMatch[1].trim();
-  if (dataStr === "[DONE]") return;
+  if (dataStr === "[DONE]") return { terminal: false, streamDone: true };
 
   let parsed;
   try { parsed = JSON.parse(dataStr); }
-  catch { throw new Error(`Malformed SSE data for ${eventType}`); }
+  catch {
+    const eventType = eventMatch?.[1]?.trim() || "unknown event";
+    throw new Error(`Malformed SSE data for ${eventType}`);
+  }
+
+  const eventType = eventMatch?.[1]?.trim() || parsed?.type;
+  const response = parsed?.response;
+  if (response && typeof response === "object") {
+    state.response = { ...state.response, ...response };
+    state.responseId = response.id || state.responseId;
+    state.created = response.created_at ?? state.created;
+    if (response.usage && typeof response.usage === "object") {
+      state.usage = { ...state.usage, ...response.usage };
+    }
+  }
 
   if (eventType === "response.created") {
-    state.responseId = parsed.response?.id || state.responseId;
-    state.created = parsed.response?.created_at || state.created;
+    state.responseId = response?.id || state.responseId;
+    state.created = response?.created_at ?? state.created;
   } else if (eventType === "response.output_item.done") {
     state.items.set(parsed.output_index ?? 0, parsed.item);
   } else if (eventType === "response.completed" || eventType === "response.done") {
     state.status = "completed";
-    if (parsed.response?.usage) {
-      state.usage.input_tokens = parsed.response.usage.input_tokens || 0;
-      state.usage.output_tokens = parsed.response.usage.output_tokens || 0;
-      state.usage.total_tokens = parsed.response.usage.total_tokens || 0;
-    }
+    state.terminalSeen = true;
+  } else if (eventType === "response.incomplete") {
+    state.status = "incomplete";
+    state.terminalSeen = true;
   } else if (eventType === "response.failed") {
     state.status = "failed";
+    state.error = response?.error || parsed.error || null;
+    state.terminalSeen = true;
+  } else if (eventType === "error" || parsed?.error) {
+    state.status = "failed";
+    state.error = parsed.error || response?.error || parsed;
+    state.terminalSeen = true;
   }
+
+  return { terminal: state.terminalSeen, streamDone: false };
 }
 
 const EMPTY_RESPONSE = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
@@ -60,47 +80,71 @@ export async function convertResponsesStreamToJson(stream) {
     created: Math.floor(Date.now() / 1000),
     status: "in_progress",
     usage: { ...EMPTY_RESPONSE },
-    items: new Map()
+    items: new Map(),
+    response: {},
+    error: null,
+    terminalSeen: false,
   };
 
+  let cancelReason = null;
   try {
+    readLoop:
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
 
       buffer += decoder.decode(value, { stream: true });
-      const messages = buffer.split("\n\n");
+      const messages = buffer.split(/\r?\n\r?\n/);
       buffer = messages.pop() || "";
 
       for (const msg of messages) {
-        processSSEMessage(msg, state);
+        const result = processSSEMessage(msg, state);
+        if (result.terminal || result.streamDone) {
+          cancelReason = "responses_terminal_received";
+          break readLoop;
+        }
       }
     }
 
-    // Flush remaining buffer (last event may not end with \n\n)
-    if (buffer.trim()) {
-      processSSEMessage(buffer, state);
+    if (!cancelReason) {
+      buffer += decoder.decode();
+      // Flush remaining buffer (last event may not end with a blank line).
+      if (buffer.trim()) processSSEMessage(buffer, state);
     }
+  } catch (error) {
+    cancelReason = error;
+    throw error;
   } finally {
+    if (cancelReason) {
+      try { await reader.cancel(cancelReason); } catch { /* preserve conversion result/error */ }
+    }
     reader.releaseLock();
   }
 
-  if (state.status !== "completed") {
+  if (state.status === "failed") {
+    const message = state.error?.message || "Responses upstream reported failure";
+    throw new Error(message);
+  }
+  if (state.status !== "completed" && state.status !== "incomplete") {
     throw new Error(`Responses SSE ended without successful termination (status: ${state.status})`);
   }
 
   // Build output array from accumulated items (ordered by index)
-  const output = [];
-  const maxIndex = state.items.size > 0 ? Math.max(...state.items.keys()) : -1;
-  for (let i = 0; i <= maxIndex; i++) {
-    output.push(state.items.get(i) || { type: "message", content: [], role: "assistant" });
+  let output = Array.isArray(state.response.output) ? state.response.output : null;
+  if (!output) {
+    output = [];
+    const maxIndex = state.items.size > 0 ? Math.max(...state.items.keys()) : -1;
+    for (let i = 0; i <= maxIndex; i++) {
+      output.push(state.items.get(i) || { type: "message", content: [], role: "assistant" });
+    }
   }
 
   return {
+    ...state.response,
     id: state.responseId || `resp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
     object: "response",
     created_at: state.created,
-    status: state.status || "completed",
+    status: state.status,
     output,
     usage: state.usage
   };

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

@@ -11,7 +11,9 @@ export function hasValidContent(msg) {
     return msg.content.some(block =>
       (block.type === "text" && block.text?.trim()) ||
       block.type === "tool_use" ||
-      block.type === "tool_result"
+      block.type === "tool_result" ||
+      block.type === "image" ||
+      block.type === "audio"
     );
   }
   return false;
@@ -213,4 +215,3 @@ export function prepareClaudeRequest(body, provider = null, apiKey = null, conne
 
   return body;
 }
-

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

@@ -8,27 +8,91 @@
  * @param {object} options - { signal, timeoutMs }
  * @returns {Promise<{url: string, mimeType: string}|null>}
  */
+import { safeFetch } from "@/lib/safeFetch.js";
+
+async function discardResponseBody(response) {
+  try {
+    await response?.body?.cancel?.();
+  } catch {
+    // The request may already have failed or been aborted.
+  }
+}
+
+async function readResponseBody(response, maxBytes) {
+  if (!response.body?.getReader) {
+    const buffer = Buffer.from(await response.arrayBuffer());
+    return buffer.byteLength <= maxBytes ? buffer : null;
+  }
+
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks, totalBytes);
+  } finally {
+    reader.releaseLock?.();
+  }
+}
+
 export async function fetchImageAsBase64(imageUrl, options = {}) {
-  const { signal, timeoutMs = 10000 } = options;
+  const { signal, timeoutMs = 10000, maxBytes = 20 * 1024 * 1024 } = options;
   if (!imageUrl || (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://"))) {
     return null;
   }
 
   const controller = new AbortController();
-  const timeout = signal ? null : setTimeout(() => controller.abort(), timeoutMs);
-  const fetchSignal = signal || controller.signal;
+  const forwardAbort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) {
+    forwardAbort();
+  } else {
+    signal?.addEventListener("abort", forwardAbort, { once: true });
+  }
+  const timeout = Number.isFinite(timeoutMs) && timeoutMs > 0
+    ? setTimeout(() => controller.abort(), timeoutMs)
+    : null;
 
+  let response;
   try {
-    const response = await fetch(imageUrl, { signal: fetchSignal });
-    if (!response.ok) return null;
+    // Remote image URLs are client-controlled. Pin their public DNS result and
+    // reject redirects/private networks so image support cannot become SSRF.
+    response = await safeFetch(imageUrl, { signal: controller.signal });
+    if (!response.ok) {
+      await discardResponseBody(response);
+      return null;
+    }
+
+    const contentLength = Number(response.headers.get("Content-Length"));
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+      await discardResponseBody(response);
+      return null;
+    }
+
+    const rawMimeType = response.headers.get("Content-Type") || "image/jpeg";
+    const mimeType = rawMimeType.split(";", 1)[0].trim().toLowerCase();
+    if (!mimeType.startsWith("image/")) {
+      await discardResponseBody(response);
+      return null;
+    }
 
-    const mimeType = response.headers.get("Content-Type") || "image/jpeg";
-    const arrayBuffer = await response.arrayBuffer();
-    const base64 = Buffer.from(arrayBuffer).toString("base64");
+    const buffer = await readResponseBody(response, maxBytes);
+    if (!buffer) return null;
+    const base64 = buffer.toString("base64");
     return { url: `data:${mimeType};base64,${base64}`, mimeType };
   } catch {
+    await discardResponseBody(response);
     return null;
   } finally {
     if (timeout) clearTimeout(timeout);
+    signal?.removeEventListener("abort", forwardAbort);
   }
 }

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

@@ -27,7 +27,7 @@ export function normalizeResponsesInput(input) {
  * Chat API uses: { messages: [...] }
  */
 export function convertResponsesApiFormat(body) {
-  if (!body.input) return body;
+  if (!body || typeof body !== "object" || !("input" in body)) return body;
 
   const result = { ...body };
   result.messages = [];
@@ -39,12 +39,22 @@ export function convertResponsesApiFormat(body) {
 
   // Group items by conversation turn
   let currentAssistantMsg = null;
-  let pendingToolCalls = [];
-  let pendingToolResults = [];
+  let pendingReasoning = "";
 
   const inputItems = normalizeResponsesInput(body.input);
   if (!inputItems) return body;
 
+  const extractReasoningText = (item) => {
+    if (Array.isArray(item.summary)) {
+      const text = item.summary.map((part) => part?.text || "").filter(Boolean).join("\n");
+      if (text) return text;
+    }
+    if (Array.isArray(item.content)) {
+      return item.content.map((part) => part?.text || "").filter(Boolean).join("\n");
+    }
+    return "";
+  };
+
   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
@@ -56,27 +66,31 @@ export function convertResponsesApiFormat(body) {
         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" } };
+            if (c.image_url) {
+              return {
+                type: "image_url",
+                image_url: { url: c.image_url, detail: c.detail || "auto" }
+              };
+            }
+            if (c.file_id) {
+              return { type: "text", text: `[Image file reference: ${c.file_id}]` };
+            }
           }
           return c;
         })
         : item.content;
-      result.messages.push({ role: item.role, content });
+      const message = { role: item.role, content };
+      if (item.role === "assistant" && pendingReasoning) {
+        message.reasoning_content = pendingReasoning;
+      }
+      pendingReasoning = "";
+      result.messages.push(message);
     }
     else if (itemType === "function_call") {
       // Start or append to assistant message with tool_calls
@@ -87,16 +101,20 @@ export function convertResponsesApiFormat(body) {
           tool_calls: []
         };
       }
-      // Skip items with empty/missing name — upstream APIs reject nameless tool calls (#444)
-      if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
       currentAssistantMsg.tool_calls.push({
         id: item.call_id,
         type: "function",
         function: {
-          name: item.name,
-          arguments: item.arguments
+          name: typeof item.name === "string" && item.name.trim() ? item.name.trim() : "_unknown",
+          arguments: typeof item.arguments === "string"
+            ? item.arguments
+            : JSON.stringify(item.arguments ?? {})
         }
       });
+      if (pendingReasoning) {
+        currentAssistantMsg.reasoning_content = pendingReasoning;
+        pendingReasoning = "";
+      }
     }
     else if (itemType === "function_call_output") {
       // Flush assistant message first if exists
@@ -104,15 +122,15 @@ export function convertResponsesApiFormat(body) {
         result.messages.push(currentAssistantMsg);
         currentAssistantMsg = null;
       }
-      // Add tool result
-      pendingToolResults.push({
+      result.messages.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
+      const text = extractReasoningText(item);
+      if (text) pendingReasoning = pendingReasoning ? `${pendingReasoning}\n${text}` : text;
       continue;
     }
   }
@@ -121,11 +139,34 @@ export function convertResponsesApiFormat(body) {
   if (currentAssistantMsg) {
     result.messages.push(currentAssistantMsg);
   }
-  if (pendingToolResults.length > 0) {
-    for (const tr of pendingToolResults) {
-      result.messages.push(tr);
-    }
+  if (body.tools && Array.isArray(body.tools)) {
+    result.tools = body.tools
+      .map((tool) => {
+        if (tool.function) return tool;
+        const name = typeof tool.name === "string" ? tool.name.trim() : "";
+        if (!name) return null;
+        return {
+          type: "function",
+          function: {
+            name,
+            description: String(tool.description || ""),
+            parameters: normalizeToolParameters(tool.parameters),
+            strict: tool.strict,
+          },
+        };
+      })
+      .filter(Boolean);
+  }
+
+  if (body.max_output_tokens !== undefined && result.max_tokens === undefined) {
+    result.max_tokens = body.max_output_tokens;
+  }
+  if (typeof body.reasoning?.effort === "string" && result.reasoning_effort === undefined) {
+    result.reasoning_effort = body.reasoning.effort;
   }
+  const responseFormat = responsesTextFormatToChat(body.text?.format);
+  if (responseFormat) result.response_format = responseFormat;
+  result.tool_choice = responsesToolChoiceToChat(body.tool_choice);
 
   // Cleanup Responses API specific fields
   delete result.input;
@@ -134,6 +175,40 @@ export function convertResponsesApiFormat(body) {
   delete result.prompt_cache_key;
   delete result.store;
   delete result.reasoning;
+  delete result.text;
+  delete result.max_output_tokens;
 
   return result;
 }
+
+function normalizeToolParameters(parameters) {
+  if (!parameters) return { type: "object", properties: {} };
+  if (parameters.type === "object" && !parameters.properties) {
+    return { ...parameters, properties: {} };
+  }
+  return parameters;
+}
+
+function responsesTextFormatToChat(format) {
+  if (!format || typeof format !== "object") return null;
+  if (format.type !== "json_schema") return { ...format };
+
+  const { type, name, description, schema, strict } = format;
+  return {
+    type,
+    json_schema: {
+      ...(name !== undefined && { name }),
+      ...(description !== undefined && { description }),
+      ...(schema !== undefined && { schema }),
+      ...(strict !== undefined && { strict }),
+    },
+  };
+}
+
+function responsesToolChoiceToChat(choice) {
+  if (!choice || typeof choice !== "object" || choice.function) return choice;
+  if (choice.type === "function" && typeof choice.name === "string" && choice.name.trim()) {
+    return { type: "function", function: { name: choice.name.trim() } };
+  }
+  return choice;
+}

package/open-sse/translator/index.js

@@ -104,7 +104,7 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
     if (targetFormat !== FORMATS.OPENAI) {
       const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
       if (fromOpenAI) {
-        result = fromOpenAI(model, result, stream, credentials);
+        result = fromOpenAI(model, result, stream, credentials, provider);
       }
     }
   }
@@ -223,10 +223,12 @@ export function initState(sourceFormat) {
       responseId: `resp_${Date.now()}`,
       created: Math.floor(Date.now() / 1000),
       started: false,
+      nextOutputIndex: 0,
       msgTextBuf: {},
       msgItemAdded: {},
       msgContentAdded: {},
       msgItemDone: {},
+      msgOutputIndices: {},
       reasoningId: "",
       reasoningIndex: -1,
       reasoningBuf: "",
@@ -238,6 +240,7 @@ export function initState(sourceFormat) {
       funcCallIds: {},
       funcArgsDone: {},
       funcItemDone: {},
+      funcOutputIndices: {},
       completedSent: false
     };
   }

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

@@ -54,8 +54,9 @@ export function antigravityToOpenAIRequest(model, body, stream) {
 
   // Convert contents to messages
   if (req.contents && Array.isArray(req.contents)) {
+    const conversionState = { nextGeneratedId: 0, pendingCallIdsByName: new Map() };
     for (const content of req.contents) {
-      const converted = convertContent(content);
+      const converted = convertContent(content, conversionState);
       if (converted) {
         if (Array.isArray(converted)) {
           result.messages.push(...converted);
@@ -121,7 +122,7 @@ function normalizeSchemaTypes(schema) {
 
 // Convert Antigravity content to OpenAI message
 // Handles: text, thought, thoughtSignature, functionCall, functionResponse, inlineData
-function convertContent(content) {
+function convertContent(content, state) {
   const role = content.role === "model" ? "assistant" : content.role === "user" ? "user" : content.role;
 
   if (!content.parts || !Array.isArray(content.parts)) {
@@ -163,8 +164,9 @@ function convertContent(content) {
 
     // Function call
     if (part.functionCall) {
+      const callId = resolveFunctionCallId(part.functionCall, state);
       toolCalls.push({
-        id: part.functionCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        id: callId,
         type: "function",
         function: {
           name: part.functionCall.name,
@@ -177,18 +179,13 @@ function convertContent(content) {
     if (part.functionResponse) {
       toolResults.push({
         role: "tool",
-        tool_call_id: part.functionResponse.id || part.functionResponse.name,
+        tool_call_id: resolveFunctionResponseId(part.functionResponse, state),
         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
+  let convertedMessage = null;
   if (toolCalls.length > 0) {
     const msg = { role: "assistant" };
     if (textParts.length > 0) {
@@ -198,11 +195,11 @@ function convertContent(content) {
       msg.reasoning_content = reasoningContent;
     }
     msg.tool_calls = toolCalls;
-    return msg;
+    convertedMessage = msg;
   }
 
   // Regular message
-  if (textParts.length > 0 || reasoningContent) {
+  if (!convertedMessage && (textParts.length > 0 || reasoningContent)) {
     const msg = { role };
     if (textParts.length > 0) {
       msg.content = textParts.length === 1 && textParts[0].type === "text" ? textParts[0].text : textParts;
@@ -210,10 +207,39 @@ function convertContent(content) {
     if (reasoningContent) {
       msg.reasoning_content = reasoningContent;
     }
-    return msg;
+    convertedMessage = msg;
+  }
+
+  if (toolResults.length > 0) {
+    return convertedMessage ? [...toolResults, convertedMessage] : toolResults;
   }
+  return convertedMessage;
+}
+
+function resolveFunctionCallId(functionCall, state) {
+  const name = functionCall.name || "tool";
+  const id = functionCall.id || `call_${sanitizeIdPart(name)}_${state.nextGeneratedId++}`;
+  const queue = state.pendingCallIdsByName.get(name) || [];
+  queue.push(id);
+  state.pendingCallIdsByName.set(name, queue);
+  return id;
+}
+
+function resolveFunctionResponseId(functionResponse, state) {
+  const name = functionResponse.name || "tool";
+  const queue = state.pendingCallIdsByName.get(name) || [];
+  if (functionResponse.id) {
+    const index = queue.indexOf(functionResponse.id);
+    if (index >= 0) queue.splice(index, 1);
+    return functionResponse.id;
+  }
+  const matchedId = queue.shift();
+  if (queue.length === 0) state.pendingCallIdsByName.delete(name);
+  return matchedId || `call_${sanitizeIdPart(name)}_response_${state.nextGeneratedId++}`;
+}
 
-  return null;
+function sanitizeIdPart(value) {
+  return String(value || "tool").replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40) || "tool";
 }
 
 // Extract text from systemInstruction