zevairouter 1.0.153 → 1.0.154

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

@@ -13,12 +13,21 @@ function extractContent(content) {
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content
-      .filter(part => {
-        if (!part || typeof part !== "object") return false;
-        return part.type === "text" && typeof part.text === "string";
+      .map(part => {
+        if (!part || typeof part !== "object") return "";
+        if (part.type === "text" && typeof part.text === "string") return part.text;
+        if (part.type === "image_url") {
+          const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+          return url ? `<image_url>${escapeXml(url)}</image_url>` : "";
+        }
+        if (part.type === "image" && part.source?.data) {
+          const mediaType = part.source.media_type || "image/png";
+          return `<image_url>data:${mediaType};base64,${part.source.data}</image_url>`;
+        }
+        return "";
       })
-      .map(part => part.text || "")
-      .join("");
+      .filter(Boolean)
+      .join("\n");
   }
   return "";
 }
@@ -118,6 +127,9 @@ function convertMessages(messages) {
             const toolName = toolMeta?.name || "tool";
             const toolContent = extractContent(block.content);
             parts.push(buildToolResultBlock(toolName, toolCallId, toolContent));
+          } else {
+            const preservedContent = extractContent([block]);
+            if (preservedContent) parts.push(preservedContent);
           }
         }
         const joined = parts.filter(Boolean).join("\n");
@@ -176,7 +188,7 @@ export function buildCursorRequest(model, body, stream, credentials) {
   return {
     ...rest,
     messages,
-    max_tokens: 32000
+    max_tokens: body.max_tokens ?? body.max_output_tokens ?? 32000
   };
 }
 

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

@@ -90,10 +90,13 @@ function openaiToGeminiBase(model, body, stream, signature = DEFAULT_THINKING_AG
       const content = msg.content;
 
       if (role === "system" && body.messages.length > 1) {
-        result.systemInstruction = {
-          role: "user",
-          parts: [{ text: typeof content === "string" ? content : extractTextContent(content) }]
-        };
+        const text = typeof content === "string" ? content : extractTextContent(content);
+        if (text) {
+          if (!result.systemInstruction) {
+            result.systemInstruction = { role: "user", parts: [] };
+          }
+          result.systemInstruction.parts.push({ text });
+        }
       } else if (role === "user" || (role === "system" && body.messages.length === 1)) {
         const parts = convertOpenAIContentToParts(content);
         if (parts.length > 0) {
@@ -473,4 +476,3 @@ export function openaiToAntigravityRequest(model, body, stream, credentials = nu
 register(FORMATS.OPENAI, FORMATS.GEMINI, openaiToGeminiRequest, null);
 register(FORMATS.OPENAI, FORMATS.GEMINI_CLI, (model, body, stream, credentials) => wrapInCloudCodeEnvelope(model, openaiToGeminiCLIRequest(model, body, stream), credentials), null);
 register(FORMATS.OPENAI, FORMATS.ANTIGRAVITY, openaiToAntigravityRequest, null);
-

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

@@ -331,8 +331,14 @@ function convertMessages(messages, tools, model) {
               const format = mediaType.split("/")[1] || mediaType;
               pendingImages.push({ format, source: { bytes: base64Match[2] } });
             } else if (url.startsWith("http://") || url.startsWith("https://")) {
-              // Kiro only supports base64 — fallback to URL text
-              textParts.push(`[Image: ${url}]`);
+              const pathname = (() => {
+                try { return new URL(url).pathname; } catch { return ""; }
+              })();
+              const extension = pathname.match(/\.([a-zA-Z0-9]+)$/)?.[1]?.toLowerCase();
+              pendingImages.push({
+                format: extension === "jpg" ? "jpeg" : (extension || "jpeg"),
+                source: { url }
+              });
             }
           } else if (c.type === "image") {
             // Claude format: source.type = "base64", source.media_type, source.data
@@ -469,6 +475,12 @@ function convertMessages(messages, tools, model) {
       // Merge context: combine toolResults, images, etc.
       const prevCtx = prev.userInputMessage.userInputMessageContext;
       const curCtx = current.userInputMessage.userInputMessageContext;
+      if (current.userInputMessage.images?.length > 0) {
+        prev.userInputMessage.images = [
+          ...(prev.userInputMessage.images || []),
+          ...current.userInputMessage.images
+        ];
+      }
       if (curCtx) {
         if (!prevCtx) {
           prev.userInputMessage.userInputMessageContext = curCtx;
@@ -548,7 +560,7 @@ function convertMessages(messages, tools, model) {
 export function buildKiroPayload(model, body, stream, credentials) {
   const messages = body.messages || [];
   const tools = body.tools || [];
-  const maxTokens = 32000;
+  const maxTokens = body.max_tokens ?? body.max_output_tokens ?? 32000;
   const temperature = body.temperature;
   const topP = body.top_p;
 

package/open-sse/translator/response/openai-responses.js

@@ -113,10 +113,16 @@ export function openaiToOpenAIResponsesResponse(chunk, state) {
 }
 
 // Helper functions
+function allocateOutputIndex(state) {
+  const index = Number.isInteger(state.nextOutputIndex) ? state.nextOutputIndex : 0;
+  state.nextOutputIndex = index + 1;
+  return index;
+}
+
 function startReasoning(state, emit, idx) {
   if (!state.reasoningId) {
     state.reasoningId = `rs_${state.responseId}_${idx}`;
-    state.reasoningIndex = idx;
+    state.reasoningIndex = allocateOutputIndex(state);
     
     emit("response.output_item.added", {
       type: "response.output_item.added",
@@ -182,11 +188,12 @@ function closeReasoning(state, emit) {
 function emitTextContent(state, emit, idx, content) {
   if (!state.msgItemAdded[idx]) {
     state.msgItemAdded[idx] = true;
+    state.msgOutputIndices[idx] = allocateOutputIndex(state);
     const msgId = `msg_${state.responseId}_${idx}`;
     
     emit("response.output_item.added", {
       type: "response.output_item.added",
-      output_index: idx,
+      output_index: state.msgOutputIndices[idx],
       item: { id: msgId, type: "message", content: [], role: "assistant" }
     });
   }
@@ -197,7 +204,7 @@ function emitTextContent(state, emit, idx, content) {
     emit("response.content_part.added", {
       type: "response.content_part.added",
       item_id: `msg_${state.responseId}_${idx}`,
-      output_index: idx,
+      output_index: state.msgOutputIndices[idx],
       content_index: 0,
       part: { type: "output_text", annotations: [], logprobs: [], text: "" }
     });
@@ -206,7 +213,7 @@ function emitTextContent(state, emit, idx, content) {
   emit("response.output_text.delta", {
     type: "response.output_text.delta",
     item_id: `msg_${state.responseId}_${idx}`,
-    output_index: idx,
+    output_index: state.msgOutputIndices[idx],
     content_index: 0,
     delta: content,
     logprobs: []
@@ -221,11 +228,12 @@ function closeMessage(state, emit, idx) {
     state.msgItemDone[idx] = true;
     const fullText = state.msgTextBuf[idx] || "";
     const msgId = `msg_${state.responseId}_${idx}`;
+    const outputIndex = state.msgOutputIndices[idx];
 
     emit("response.output_text.done", {
       type: "response.output_text.done",
       item_id: msgId,
-      output_index: parseInt(idx),
+      output_index: outputIndex,
       content_index: 0,
       text: fullText,
       logprobs: []
@@ -234,14 +242,14 @@ function closeMessage(state, emit, idx) {
     emit("response.content_part.done", {
       type: "response.content_part.done",
       item_id: msgId,
-      output_index: parseInt(idx),
+      output_index: outputIndex,
       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),
+      output_index: outputIndex,
       item: {
         id: msgId,
         type: "message",
@@ -257,6 +265,10 @@ function emitToolCall(state, emit, tc) {
   const newCallId = tc.id;
   const funcName = tc.function?.name;
 
+  if (state.funcOutputIndices[tcIdx] === undefined) {
+    state.funcOutputIndices[tcIdx] = allocateOutputIndex(state);
+  }
+
   if (funcName) state.funcNames[tcIdx] = funcName;
 
   if (!state.funcCallIds[tcIdx] && newCallId) {
@@ -264,7 +276,7 @@ function emitToolCall(state, emit, tc) {
     
     emit("response.output_item.added", {
       type: "response.output_item.added",
-      output_index: tcIdx,
+      output_index: state.funcOutputIndices[tcIdx],
       item: {
         id: `fc_${newCallId}`,
         type: "function_call",
@@ -283,7 +295,7 @@ function emitToolCall(state, emit, tc) {
       emit("response.function_call_arguments.delta", {
         type: "response.function_call_arguments.delta",
         item_id: `fc_${refCallId}`,
-        output_index: tcIdx,
+        output_index: state.funcOutputIndices[tcIdx],
         delta: tc.function.arguments
       });
     }
@@ -295,17 +307,18 @@ function closeToolCall(state, emit, idx) {
   const callId = state.funcCallIds[idx];
   if (callId && !state.funcItemDone[idx]) {
     const args = state.funcArgsBuf[idx] || "{}";
+    const outputIndex = state.funcOutputIndices[idx];
     
     emit("response.function_call_arguments.done", {
       type: "response.function_call_arguments.done",
       item_id: `fc_${callId}`,
-      output_index: parseInt(idx),
+      output_index: outputIndex,
       arguments: args
     });
 
     emit("response.output_item.done", {
       type: "response.output_item.done",
-      output_index: parseInt(idx),
+      output_index: outputIndex,
       item: {
         id: `fc_${callId}`,
         type: "function_call",
@@ -363,6 +376,33 @@ function computeFinishReason(state) {
     : "stop";
 }
 
+function normalizeResponsesError(data, eventType) {
+  const payload = data && typeof data === "object" ? data : {};
+  const rawError = payload.error ?? payload.response?.error;
+  const source = rawError && typeof rawError === "object" && !Array.isArray(rawError)
+    ? rawError
+    : {};
+  const fallbackCode = eventType === "response.failed" ? "response_failed" : "stream_error";
+  const code = source.code ?? payload.code ?? fallbackCode;
+  const message = source.message
+    || (typeof rawError === "string" ? rawError : null)
+    || payload.message
+    || (eventType === "response.failed" ? "Responses API request failed" : "Responses API stream error");
+  const payloadErrorType = payload.type && payload.type !== eventType && payload.type !== "error"
+    ? payload.type
+    : null;
+  const codeErrorType = typeof code === "string"
+    && (code.endsWith("_error") || code === "server_error")
+    ? code
+    : null;
+  const type = source.type || payload.error_type || payloadErrorType || codeErrorType || "server_error";
+  const error = { ...source, message, type };
+
+  if (!("param" in error) && "param" in payload) error.param = payload.param;
+  error.code = code;
+  return error;
+}
+
 /**
  * Translate OpenAI Responses API chunk to OpenAI Chat Completions format
  * This is for when Codex returns data and we need to send it to an OpenAI-compatible client
@@ -409,6 +449,26 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
     state.currentToolCallId = null;
   }
 
+  const isErrorEvent = eventType === "error"
+    || eventType === "response.failed"
+    || data?.response?.status === "failed"
+    || (!eventType && Boolean(data?.error));
+
+  if (isErrorEvent) {
+    // A Responses failure must remain machine-readable. Turning it into
+    // assistant text makes SDKs treat a rejected request as a success.
+    if (state.finishReasonSent || state.errorSent) return null;
+
+    const error = normalizeResponsesError(data, eventType);
+    state.error = error;
+    state.errorSent = true;
+    state.finishReasonSent = true;
+    return { error };
+  }
+
+  // Error events are terminal; ignore contradictory provider output afterward.
+  if (state.errorSent) return null;
+
   // Text content delta
   if (eventType === "response.output_text.delta") {
     const delta = data.delta || "";
@@ -542,32 +602,6 @@ export function openaiResponsesToOpenAIResponse(chunk, state) {
     return null;
   }
 
-  // Error events from Responses API (e.g. model_not_found)
-  if (eventType === "error" || eventType === "response.failed") {
-    // Avoid emitting duplicate errors (error + response.failed arrive back-to-back)
-    if (state.finishReasonSent) return null;
-
-    const error = data.error || data.response?.error;
-    if (error) {
-      state.error = error;
-      state.finishReasonSent = true;
-
-      // Surface the error as an OpenAI-compatible error chunk
-      return {
-        id: state.chatId || `chatcmpl-${Date.now()}`,
-        object: "chat.completion.chunk",
-        created: state.created || Math.floor(Date.now() / 1000),
-        model: state.model || "unknown",
-        choices: [{
-          index: 0,
-          delta: { content: `[Error] ${error.message || JSON.stringify(error)}` },
-          finish_reason: "stop"
-        }]
-      };
-    }
-    return null;
-  }
-
   // Reasoning summary delta → emit as reasoning_content for client thinking display
   if (eventType === "response.reasoning_summary_text.delta") {
     const delta = data.delta || "";

package/open-sse/utils/responsesStreamHelpers.js

@@ -6,6 +6,7 @@ import { formatSSE } from "./streamHelpers.js";
 const OPENAI_RESPONSES_TERMINAL_EVENTS = new Set([
   "response.completed",
   "response.failed",
+  "response.incomplete",
   "error"
 ]);
 
@@ -19,31 +20,87 @@ export function isOpenAIResponsesTerminalEvent(eventName, chunk) {
   const type = getOpenAIResponsesEventName(eventName, chunk);
   if (OPENAI_RESPONSES_TERMINAL_EVENTS.has(type)) return true;
   const status = chunk?.response?.status;
-  return status === "completed" || status === "failed";
+  return status === "completed" || status === "failed" || status === "incomplete";
 }
 
 const sharedEncoder = new TextEncoder();
 
 // Encoded response.failed + [DONE] payload for aborted/stalled Responses passthrough streams
-export function buildAbortedResponsesTerminalBytes() {
-  return sharedEncoder.encode(`${formatIncompleteOpenAIResponsesStreamFailure()}data: [DONE]\n\n`);
+export function buildAbortedResponsesTerminalBytes(options = {}) {
+  return sharedEncoder.encode(`${formatIncompleteOpenAIResponsesStreamFailure(options)}data: [DONE]\n\n`);
 }
 
 // Synthesize a response.failed event for streams that close without a terminal event
-export function formatIncompleteOpenAIResponsesStreamFailure() {
+export function formatIncompleteOpenAIResponsesStreamFailure({ responseId, createdAt, sequenceNumber } = {}) {
+  const data = {
+    type: "response.failed",
+    response: {
+      id: responseId || `resp_${Date.now()}`,
+      object: "response",
+      created_at: createdAt || Math.floor(Date.now() / 1000),
+      status: "failed",
+      background: false,
+      error: {
+        type: "stream_error",
+        code: "stream_disconnected",
+        message: "stream closed before response.completed"
+      },
+      output: []
+    }
+  };
+  if (Number.isFinite(sequenceNumber)) data.sequence_number = sequenceNumber;
+
   return formatSSE({
     event: "response.failed",
-    data: {
-      type: "response.failed",
-      response: {
-        id: `resp_${Date.now()}`,
-        status: "failed",
-        error: {
-          type: "stream_error",
-          code: "stream_disconnected",
-          message: "stream closed before response.completed"
-        }
-      }
-    }
+    data
   }, FORMATS.OPENAI_RESPONSES);
 }
+
+/**
+ * Track terminal state in bytes already delivered to the client. On a later
+ * transport error, preserve an existing terminal event and only add [DONE].
+ */
+export function createAbortedResponsesTerminalHandler() {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let terminalSeen = false;
+  let doneSeen = false;
+  let responseId = null;
+  let createdAt = null;
+  let sequenceNumber = null;
+
+  const inspectMessage = (message) => {
+    if (!message.trim()) return;
+    const eventName = message.match(/^event:\s*(.+)$/m)?.[1]?.trim() || null;
+    const dataText = message.match(/^data:\s*(.+)$/m)?.[1]?.trim();
+    if (!dataText) return;
+    if (dataText === "[DONE]") {
+      doneSeen = true;
+      return;
+    }
+
+    let parsed;
+    try { parsed = JSON.parse(dataText); } catch { return; }
+    responseId = parsed?.response?.id || responseId;
+    createdAt = parsed?.response?.created_at || createdAt;
+    if (Number.isFinite(parsed?.sequence_number)) {
+      sequenceNumber = parsed.sequence_number + 1;
+    }
+    if (isOpenAIResponsesTerminalEvent(eventName, parsed)) terminalSeen = true;
+  };
+
+  return {
+    observe(chunk) {
+      buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+      const messages = buffer.split(/\r?\n\r?\n/);
+      buffer = messages.pop() || "";
+      for (const message of messages) inspectMessage(message);
+    },
+    build() {
+      if (buffer.trim()) inspectMessage(buffer);
+      if (doneSeen) return null;
+      if (terminalSeen) return sharedEncoder.encode("data: [DONE]\n\n");
+      return buildAbortedResponsesTerminalBytes({ responseId, createdAt, sequenceNumber });
+    }
+  };
+}