zevairouter 1.0.153 → 1.0.154

package/open-sse/transformer/responsesTransformer.js

@@ -57,10 +57,12 @@ export function createResponsesApiTransformStream(logger = null) {
     responseId: `resp_${Date.now()}`,
     created: Math.floor(Date.now() / 1000),
     started: false,
+    nextOutputIndex: 0,
     msgTextBuf: {},
     msgItemAdded: {},
     msgContentAdded: {},
     msgItemDone: {},
+    msgOutputIndices: {},
     reasoningId: "",
     reasoningIndex: -1,
     reasoningBuf: "",
@@ -70,14 +72,19 @@ export function createResponsesApiTransformStream(logger = null) {
     funcArgsBuf: {},
     funcNames: {},
     funcCallIds: {},
+    funcOutputIndices: {},
     funcArgsDone: {},
     funcItemDone: {},
     buffer: "",
-    completedSent: false
+    inputTerminated: false,
+    terminalSent: false,
+    doneSent: false
   };
 
   const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
   const nextSeq = () => ++state.seq;
+  const allocateOutputIndex = () => state.nextOutputIndex++;
   
   const emit = (controller, eventType, data) => {
     data.sequence_number = nextSeq();
@@ -86,15 +93,44 @@ export function createResponsesApiTransformStream(logger = null) {
     controller.enqueue(encoder.encode(output));
   };
 
+  const ensureStarted = (controller, parsed = null) => {
+    if (state.started) return;
+    state.started = true;
+    state.responseId = parsed?.id ? `resp_${parsed.id}` : state.responseId;
+
+    emit(controller, "response.created", {
+      type: "response.created",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress",
+        background: false,
+        error: null,
+        output: []
+      }
+    });
+
+    emit(controller, "response.in_progress", {
+      type: "response.in_progress",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "in_progress"
+      }
+    });
+  };
+
   // Helper to start reasoning
   const startReasoning = (controller, idx) => {
     if (!state.reasoningId) {
       state.reasoningId = `rs_${state.responseId}_${idx}`;
-      state.reasoningIndex = idx;
+      state.reasoningIndex = allocateOutputIndex();
       
       emit(controller, "response.output_item.added", {
         type: "response.output_item.added",
-        output_index: idx,
+        output_index: state.reasoningIndex,
         item: {
           id: state.reasoningId,
           type: "reasoning",
@@ -105,7 +141,7 @@ export function createResponsesApiTransformStream(logger = null) {
       emit(controller, "response.reasoning_summary_part.added", {
         type: "response.reasoning_summary_part.added",
         item_id: state.reasoningId,
-        output_index: idx,
+        output_index: state.reasoningIndex,
         summary_index: 0,
         part: { type: "summary_text", text: "" }
       });
@@ -162,11 +198,12 @@ export function createResponsesApiTransformStream(logger = null) {
       state.msgItemDone[idx] = true;
       const fullText = state.msgTextBuf[idx] || "";
       const msgId = `msg_${state.responseId}_${idx}`;
+      const outputIndex = state.msgOutputIndices[idx];
 
       emit(controller, "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: []
@@ -175,14 +212,14 @@ export function createResponsesApiTransformStream(logger = null) {
       emit(controller, "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(controller, "response.output_item.done", {
         type: "response.output_item.done",
-        output_index: parseInt(idx),
+        output_index: outputIndex,
         item: {
           id: msgId,
           type: "message",
@@ -197,17 +234,18 @@ export function createResponsesApiTransformStream(logger = null) {
     const callId = state.funcCallIds[idx];
     if (callId && !state.funcItemDone[idx]) {
       const args = state.funcArgsBuf[idx] || "{}";
+      const outputIndex = state.funcOutputIndices[idx];
       
       emit(controller, "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(controller, "response.output_item.done", {
         type: "response.output_item.done",
-        output_index: parseInt(idx),
+        output_index: outputIndex,
         item: {
           id: `fc_${callId}`,
           type: "function_call",
@@ -223,8 +261,8 @@ export function createResponsesApiTransformStream(logger = null) {
   };
 
   const sendCompleted = (controller) => {
-    if (!state.completedSent) {
-      state.completedSent = true;
+    if (!state.terminalSent) {
+      state.terminalSent = true;
       emit(controller, "response.completed", {
         type: "response.completed",
         response: {
@@ -239,201 +277,233 @@ export function createResponsesApiTransformStream(logger = null) {
     }
   };
 
-  return new TransformStream({
-    transform(chunk, controller) {
-      const text = new TextDecoder().decode(chunk);
-      logger?.logInput(text.trim());
-      state.buffer += text;
+  const sendFailed = (controller, upstreamError = null) => {
+    if (state.terminalSent) return;
+    state.terminalSent = true;
+    const error = upstreamError && typeof upstreamError === "object" ? upstreamError : {};
+    emit(controller, "response.failed", {
+      type: "response.failed",
+      response: {
+        id: state.responseId,
+        object: "response",
+        created_at: state.created,
+        status: "failed",
+        background: false,
+        error: {
+          type: error.type || "stream_error",
+          code: error.code || "stream_disconnected",
+          message: error.message || "chat completion stream ended before a terminal event"
+        },
+        output: []
+      }
+    });
+  };
 
-      const messages = state.buffer.split("\n\n");
-      state.buffer = messages.pop() || "";
+  const sendDone = (controller) => {
+    if (state.doneSent) return;
+    state.doneSent = true;
+    logger?.logOutput("data: [DONE]");
+    controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+  };
 
-      for (const msg of messages) {
-        if (!msg.trim()) continue;
+  const closeOutputItems = (controller) => {
+    for (const i in state.msgItemAdded) closeMessage(controller, i);
+    closeReasoning(controller);
+    for (const i in state.funcCallIds) closeToolCall(controller, i);
+  };
 
-        const dataMatch = msg.match(/^data:\s*(.+)$/m);
-        if (!dataMatch) continue;
+  const finishSuccessfully = (controller) => {
+    if (state.terminalSent) return;
+    closeOutputItems(controller);
+    sendCompleted(controller);
+    sendDone(controller);
+  };
 
-        const dataStr = dataMatch[1].trim();
-        if (dataStr === "[DONE]") continue;
+  const handleMessage = (msg, controller) => {
+    if (!msg.trim() || state.inputTerminated) return;
 
-        let parsed;
-        try {
-          parsed = JSON.parse(dataStr);
-        } catch {
-          continue;
-        }
+    const dataMatch = msg.match(/^data:\s*(.+)$/m);
+    if (!dataMatch) return;
 
-        if (!parsed.choices?.length) continue;
-        
-        const choice = parsed.choices[0];
-        const idx = choice.index || 0;
-        const delta = choice.delta || {};
-
-        // Emit initial events
-        if (!state.started) {
-          state.started = true;
-          state.responseId = parsed.id ? `resp_${parsed.id}` : state.responseId;
-          
-          emit(controller, "response.created", {
-            type: "response.created",
-            response: {
-              id: state.responseId,
-              object: "response",
-              created_at: state.created,
-              status: "in_progress",
-              background: false,
-              error: null,
-              output: []
-            }
-          });
+    const dataStr = dataMatch[1].trim();
+    if (dataStr === "[DONE]") {
+      state.inputTerminated = true;
+      ensureStarted(controller);
+      finishSuccessfully(controller);
+      return;
+    }
 
-          emit(controller, "response.in_progress", {
-            type: "response.in_progress",
-            response: {
-              id: state.responseId,
-              object: "response",
-              created_at: state.created,
-              status: "in_progress"
-            }
+    let parsed;
+    try {
+      parsed = JSON.parse(dataStr);
+    } catch {
+      state.inputTerminated = true;
+      ensureStarted(controller);
+      closeOutputItems(controller);
+      sendFailed(controller, { code: "invalid_sse", message: "upstream emitted malformed SSE data" });
+      sendDone(controller);
+      return;
+    }
+
+    if (parsed?.error) {
+      state.inputTerminated = true;
+      ensureStarted(controller, parsed);
+      closeOutputItems(controller);
+      sendFailed(controller, parsed.error);
+      sendDone(controller);
+      return;
+    }
+    if (!parsed.choices?.length) return;
+
+    const choice = parsed.choices[0];
+    const idx = choice.index || 0;
+    const delta = choice.delta || {};
+    ensureStarted(controller, parsed);
+
+    // Handle reasoning_content (OpenAI native format)
+    if (delta.reasoning_content) {
+      startReasoning(controller, idx);
+      emitReasoningDelta(controller, delta.reasoning_content);
+    }
+
+    // Handle text content (may contain <think> tags)
+    if (delta.content) {
+      let content = delta.content;
+
+      if (content.includes("<think>")) {
+        state.inThinking = true;
+        content = content.replace("<think>", "");
+        startReasoning(controller, idx);
+      }
+
+      if (content.includes("</think>")) {
+        const parts = content.split("</think>");
+        const thinkPart = parts[0];
+        const textPart = parts.slice(1).join("</think>");
+
+        if (thinkPart) emitReasoningDelta(controller, thinkPart);
+        closeReasoning(controller);
+        state.inThinking = false;
+        content = textPart;
+      }
+
+      if (state.inThinking && content) {
+        emitReasoningDelta(controller, content);
+      } else if (content) {
+        if (!state.msgItemAdded[idx]) {
+          state.msgItemAdded[idx] = true;
+          state.msgOutputIndices[idx] = allocateOutputIndex();
+          const msgId = `msg_${state.responseId}_${idx}`;
+
+          emit(controller, "response.output_item.added", {
+            type: "response.output_item.added",
+            output_index: state.msgOutputIndices[idx],
+            item: { id: msgId, type: "message", content: [], role: "assistant" }
           });
         }
 
-        // Handle reasoning_content (OpenAI native format)
-        if (delta.reasoning_content) {
-          startReasoning(controller, idx);
-          emitReasoningDelta(controller, delta.reasoning_content);
+        if (!state.msgContentAdded[idx]) {
+          state.msgContentAdded[idx] = true;
+
+          emit(controller, "response.content_part.added", {
+            type: "response.content_part.added",
+            item_id: `msg_${state.responseId}_${idx}`,
+            output_index: state.msgOutputIndices[idx],
+            content_index: 0,
+            part: { type: "output_text", annotations: [], logprobs: [], text: "" }
+          });
         }
 
-        // Handle text content (may contain <think> tags)
-        if (delta.content) {
-          let content = delta.content;
+        emit(controller, "response.output_text.delta", {
+          type: "response.output_text.delta",
+          item_id: `msg_${state.responseId}_${idx}`,
+          output_index: state.msgOutputIndices[idx],
+          content_index: 0,
+          delta: content,
+          logprobs: []
+        });
+
+        if (!state.msgTextBuf[idx]) state.msgTextBuf[idx] = "";
+        state.msgTextBuf[idx] += content;
+      }
+    }
 
-          if (content.includes("<think>")) {
-            state.inThinking = true;
-            content = content.replace("<think>", "");
-            startReasoning(controller, idx);
-          }
+    // Handle tool_calls
+    if (delta.tool_calls) {
+      closeMessage(controller, idx);
 
-          if (content.includes("</think>")) {
-            const parts = content.split("</think>");
-            const thinkPart = parts[0];
-            const textPart = parts.slice(1).join("</think>");
-            
-            if (thinkPart) emitReasoningDelta(controller, thinkPart);
-            closeReasoning(controller);
-            state.inThinking = false;
-            content = textPart;
-          }
+      for (const tc of delta.tool_calls) {
+        const tcIdx = tc.index ?? 0;
+        const newCallId = tc.id;
+        const funcName = tc.function?.name;
 
-          if (state.inThinking && content) {
-            emitReasoningDelta(controller, content);
-            continue;
-          }
+        if (state.funcOutputIndices[tcIdx] === undefined) {
+          state.funcOutputIndices[tcIdx] = allocateOutputIndex();
+        }
 
-          // Regular text content
-          if (content) {
-            if (!state.msgItemAdded[idx]) {
-              state.msgItemAdded[idx] = true;
-              const msgId = `msg_${state.responseId}_${idx}`;
-              
-              emit(controller, "response.output_item.added", {
-                type: "response.output_item.added",
-                output_index: idx,
-                item: { id: msgId, type: "message", content: [], role: "assistant" }
-              });
-            }
+        if (funcName) state.funcNames[tcIdx] = funcName;
+
+        if (!state.funcCallIds[tcIdx] && newCallId) {
+          state.funcCallIds[tcIdx] = newCallId;
 
-            if (!state.msgContentAdded[idx]) {
-              state.msgContentAdded[idx] = true;
-              
-              emit(controller, "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(controller, "response.output_item.added", {
+            type: "response.output_item.added",
+            output_index: state.funcOutputIndices[tcIdx],
+            item: {
+              id: `fc_${newCallId}`,
+              type: "function_call",
+              arguments: "",
+              call_id: newCallId,
+              name: state.funcNames[tcIdx] || ""
             }
+          });
+        }
 
-            emit(controller, "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.funcArgsBuf[tcIdx]) state.funcArgsBuf[tcIdx] = "";
 
-            if (!state.msgTextBuf[idx]) state.msgTextBuf[idx] = "";
-            state.msgTextBuf[idx] += content;
+        if (tc.function?.arguments) {
+          const refCallId = state.funcCallIds[tcIdx] || newCallId;
+          if (refCallId) {
+            emit(controller, "response.function_call_arguments.delta", {
+              type: "response.function_call_arguments.delta",
+              item_id: `fc_${refCallId}`,
+              output_index: state.funcOutputIndices[tcIdx],
+              delta: tc.function.arguments
+            });
           }
+          state.funcArgsBuf[tcIdx] += tc.function.arguments;
         }
+      }
+    }
 
-        // Handle tool_calls
-        if (delta.tool_calls) {
-          closeMessage(controller, idx);
-
-          for (const tc of delta.tool_calls) {
-            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(controller, "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 (choice.finish_reason) {
+      state.inputTerminated = true;
+      finishSuccessfully(controller);
+    }
+  };
 
-            if (!state.funcArgsBuf[tcIdx]) state.funcArgsBuf[tcIdx] = "";
-
-            if (tc.function?.arguments) {
-              const refCallId = state.funcCallIds[tcIdx] || newCallId;
-              if (refCallId) {
-                emit(controller, "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;
-            }
-          }
-        }
+  return new TransformStream({
+    transform(chunk, controller) {
+      const text = decoder.decode(chunk, { stream: true });
+      logger?.logInput(text.trim());
+      state.buffer += text;
 
-        // Handle finish_reason
-        if (choice.finish_reason) {
-          for (const i in state.msgItemAdded) closeMessage(controller, i);
-          closeReasoning(controller);
-          for (const i in state.funcCallIds) closeToolCall(controller, i);
-          sendCompleted(controller);
-        }
-      }
+      const messages = state.buffer.split(/\r?\n\r?\n/);
+      state.buffer = messages.pop() || "";
+      for (const msg of messages) handleMessage(msg, controller);
     },
 
     flush(controller) {
-      for (const i in state.msgItemAdded) closeMessage(controller, i);
-      closeReasoning(controller);
-      for (const i in state.funcCallIds) closeToolCall(controller, i);
-      sendCompleted(controller);
+      state.buffer += decoder.decode();
+      if (state.buffer.trim()) handleMessage(state.buffer, controller);
 
-      logger?.logOutput("data: [DONE]");
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      if (!state.terminalSent) {
+        ensureStarted(controller);
+        closeOutputItems(controller);
+        sendFailed(controller);
+      }
+      sendDone(controller);
       logger?.flush();
     }
   });
 }
-