swayrouter 1.0.0

package/src/utils/stream.js

@@ -0,0 +1,511 @@
+import { translateResponse, initState } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { trackPendingRequest, appendRequestLog } from "@/lib/usageDb.js";
+import { extractUsage, mergeUsage, hasValidUsage, estimateUsage, logUsage, addBufferToUsage, filterUsageForFormat, COLORS } from "./usageTracking.js";
+import { parseSSELine, hasValuableContent, fixInvalidId, formatSSE } from "./streamHelpers.js";
+import { getOpenAIResponsesEventName, isOpenAIResponsesTerminalEvent, formatIncompleteOpenAIResponsesStreamFailure } from "./responsesStreamHelpers.js";
+import { dbg, isDebugEnabled } from "./debugLog.js";
+
+import { SSE_DONE, SSE_HEADERS, SSE_HEADERS_NO_BUFFER } from "./sseConstants.js";
+
+export { COLORS, formatSSE };
+export { SSE_DONE, SSE_HEADERS, SSE_HEADERS_NO_BUFFER };
+
+const sharedEncoder = new TextEncoder();
+
+const STREAM_MODE = {
+  TRANSLATE: "translate",
+  PASSTHROUGH: "passthrough"
+};
+
+const GEMINI_WRAPPED_FORMATS = new Set([
+  FORMATS.GEMINI,
+  FORMATS.GEMINI_CLI,
+  FORMATS.ANTIGRAVITY,
+  FORMATS.VERTEX,
+]);
+
+function getStreamPayload(chunk, format) {
+  if (!GEMINI_WRAPPED_FORMATS.has(format)) return chunk;
+  const wrapped = chunk?.response;
+  return wrapped && typeof wrapped === "object" && !Array.isArray(wrapped) ? wrapped : chunk;
+}
+
+function hasStreamTerminalMarker(chunk, format) {
+  const payload = getStreamPayload(chunk, format);
+  return Boolean(
+    chunk?.done
+    || payload?.done
+    || chunk?.choices?.some?.((choice) => choice?.finish_reason != null)
+    || payload?.choices?.some?.((choice) => choice?.finish_reason != null)
+    || chunk?.candidates?.some?.((candidate) => candidate?.finishReason != null || candidate?.finish_reason != null)
+    || payload?.candidates?.some?.((candidate) => candidate?.finishReason != null || candidate?.finish_reason != null)
+    || chunk?.type === "message_stop"
+    || payload?.type === "message_stop"
+    || chunk?.type === "response.completed"
+    || payload?.type === "response.completed"
+    || chunk?.type === "response.failed"
+    || payload?.type === "response.failed"
+    || chunk?.type === "response.incomplete"
+    || payload?.type === "response.incomplete"
+    || chunk?.delta?.stop_reason != null
+    || payload?.delta?.stop_reason != null
+    || chunk?.stop_reason != null
+    || payload?.stop_reason != null
+  );
+}
+
+function collectStreamText(chunk, format) {
+  const payload = getStreamPayload(chunk, format);
+  let content = "";
+  let thinking = "";
+
+  if (typeof payload?.delta?.text === "string") content += payload.delta.text;
+  if (typeof payload?.delta?.thinking === "string") thinking += payload.delta.thinking;
+
+  const openAiDelta = payload?.choices?.[0]?.delta;
+  if (typeof openAiDelta?.content === "string") content += openAiDelta.content;
+  if (typeof openAiDelta?.reasoning_content === "string") thinking += openAiDelta.reasoning_content;
+
+  const parts = payload?.candidates?.[0]?.content?.parts;
+  if (Array.isArray(parts)) {
+    for (const part of parts) {
+      if (typeof part?.text !== "string") continue;
+      if (part.thought === true) thinking += part.text;
+      else content += part.text;
+    }
+  }
+
+  return { content, thinking, length: content.length + thinking.length };
+}
+
+// Request details only need a bounded preview. The client stream itself is
+// still passed through in full; this cap prevents a long completion from
+// being retained in memory until the provider closes the connection.
+export const MAX_STREAM_COMPLETION_PREVIEW_CHARS = 64 * 1024;
+
+export function appendStreamPreview(current, value, max = MAX_STREAM_COMPLETION_PREVIEW_CHARS) {
+  if (typeof value !== "string" || !value || current.length >= max) return current;
+  const remaining = max - current.length;
+  return current + (value.length <= remaining ? value : value.slice(0, remaining));
+}
+
+export function createSSEStream(options = {}) {
+  const {
+    mode = STREAM_MODE.TRANSLATE,
+    targetFormat,
+    sourceFormat,
+    provider = null,
+    reqLogger = null,
+    toolNameMap = null,
+    customToolNames = null,
+    model = null,
+    connectionId = null,
+    body = null,
+    onStreamComplete = null,
+    apiKey = null
+  } = options;
+
+  let buffer = "";
+  let usage = null;
+
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+
+  const state = mode === STREAM_MODE.TRANSLATE
+    ? { ...initState(sourceFormat), provider, toolNameMap, customToolNames: new Set(customToolNames || []), model }
+    : null;
+
+  let totalContentLength = 0;
+  let accumulatedContent = "";
+  let accumulatedThinking = "";
+  let ttftAt = null;
+  let sseLineCount = 0;
+  let sseEmittedCount = 0;
+  const eventTypeCounts = {};
+
+  let currentOpenAIResponsesEvent = null;
+  let openAIResponsesTerminalSeen = false;
+  let openAIResponsesDoneSent = false;
+  let streamDoneSent = false;
+  let streamTerminalSeen = false;
+
+  return new TransformStream({
+    transform(chunk, controller) {
+      if (!ttftAt) ttftAt = Date.now();
+      const text = decoder.decode(chunk, { stream: true });
+      buffer += text;
+      reqLogger?.appendProviderChunk?.(text);
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (isDebugEnabled && trimmed) {
+          sseLineCount++;
+          if (trimmed.startsWith("event:")) {
+            const evt = trimmed.slice(6).trim();
+            eventTypeCounts[evt] = (eventTypeCounts[evt] || 0) + 1;
+          }
+        }
+
+        if (mode === STREAM_MODE.TRANSLATE && targetFormat === FORMATS.OPENAI_RESPONSES && trimmed.startsWith("event:")) {
+          currentOpenAIResponsesEvent = trimmed.slice(6).trim();
+        }
+
+        if (mode === STREAM_MODE.PASSTHROUGH) {
+          let output;
+          let injectedUsage = false;
+
+          if (trimmed.startsWith("data:") && trimmed.slice(5).trim() === "[DONE]") {
+            streamTerminalSeen = true;
+            streamDoneSent = true;
+          }
+          if (trimmed.startsWith("data:") && trimmed.slice(5).trim() !== "[DONE]") {
+            try {
+              const parsed = JSON.parse(trimmed.slice(5).trim());
+
+              const idFixed = fixInvalidId(parsed);
+
+              let fieldsInjected = false;
+              if (parsed.choices !== undefined) {
+                if (!parsed.object) { parsed.object = "chat.completion.chunk"; fieldsInjected = true; }
+                if (!parsed.created) { parsed.created = Math.floor(Date.now() / 1000); fieldsInjected = true; }
+              }
+
+              if (parsed.prompt_filter_results !== undefined) {
+                delete parsed.prompt_filter_results;
+                fieldsInjected = true;
+              }
+              if (parsed?.choices) {
+                for (const choice of parsed.choices) {
+                  if (choice.content_filter_results !== undefined) {
+                    delete choice.content_filter_results;
+                    fieldsInjected = true;
+                  }
+                }
+              }
+
+              if (parsed?.choices) {
+                for (const choice of parsed.choices) {
+                  if (choice.delta?.tool_calls && Array.isArray(choice.delta.tool_calls) && choice.delta.tool_calls.length === 0) {
+                    delete choice.delta.tool_calls;
+                    fieldsInjected = true;
+                  }
+                }
+              }
+
+              if (!hasValuableContent(parsed, FORMATS.OPENAI)) {
+                continue;
+              }
+
+              const delta = parsed.choices?.[0]?.delta;
+              const content = delta?.content;
+              const reasoning = delta?.reasoning_content;
+              if (content && typeof content === "string") {
+                totalContentLength += content.length;
+                accumulatedContent = appendStreamPreview(accumulatedContent, content);
+              }
+              if (reasoning && typeof reasoning === "string") {
+                totalContentLength += reasoning.length;
+                accumulatedThinking = appendStreamPreview(accumulatedThinking, reasoning);
+              }
+
+              const extracted = extractUsage(parsed);
+              if (extracted) {
+                usage = mergeUsage(usage, extracted);
+              }
+
+              const isFinishChunk = parsed.choices?.[0]?.finish_reason;
+              if (isFinishChunk && !hasValidUsage(parsed.usage)) {
+                const estimated = estimateUsage(body, totalContentLength, FORMATS.OPENAI);
+                parsed.usage = filterUsageForFormat(estimated, FORMATS.OPENAI);
+                output = `data: ${JSON.stringify(parsed)}\n`;
+                usage = estimated;
+                injectedUsage = true;
+              } else if (isFinishChunk && usage) {
+                const buffered = addBufferToUsage(usage);
+                parsed.usage = filterUsageForFormat(buffered, FORMATS.OPENAI);
+                output = `data: ${JSON.stringify(parsed)}\n`;
+                injectedUsage = true;
+              } else if (idFixed || fieldsInjected) {
+                output = `data: ${JSON.stringify(parsed)}\n`;
+                injectedUsage = true;
+              }
+            } catch {
+
+              continue;
+            }
+          }
+
+          if (!injectedUsage) {
+            if (line.startsWith("data:") && !line.startsWith("data: ")) {
+              output = "data: " + line.slice(5) + "\n";
+            } else {
+              output = line + "\n";
+            }
+          }
+
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(sharedEncoder.encode(output));
+          continue;
+        }
+
+        if (!trimmed) continue;
+
+        const parsed = parseSSELine(trimmed, targetFormat);
+        if (!parsed) continue;
+        if (hasStreamTerminalMarker(parsed, targetFormat)) streamTerminalSeen = true;
+
+        const isOpenAIResponsesStream = targetFormat === FORMATS.OPENAI_RESPONSES;
+        const keepsOpenAIResponsesFormat = isOpenAIResponsesStream && sourceFormat === FORMATS.OPENAI_RESPONSES;
+        const openAIResponsesEventName = isOpenAIResponsesStream
+          ? getOpenAIResponsesEventName(currentOpenAIResponsesEvent, parsed)
+          : null;
+
+        if (isOpenAIResponsesStream && isOpenAIResponsesTerminalEvent(openAIResponsesEventName, parsed)) {
+          openAIResponsesTerminalSeen = true;
+        }
+
+        if (parsed && parsed.done && targetFormat !== FORMATS.OLLAMA) {
+
+          if (keepsOpenAIResponsesFormat && !openAIResponsesTerminalSeen) {
+            const failedOutput = formatIncompleteOpenAIResponsesStreamFailure();
+            reqLogger?.appendConvertedChunk?.(failedOutput);
+            controller.enqueue(sharedEncoder.encode(failedOutput));
+            openAIResponsesTerminalSeen = true;
+            sseEmittedCount++;
+          }
+
+          if (keepsOpenAIResponsesFormat && !streamDoneSent) {
+            const doneOutput = "data: [DONE]\n\n";
+            reqLogger?.appendConvertedChunk?.(doneOutput);
+            controller.enqueue(sharedEncoder.encode(doneOutput));
+          }
+          streamDoneSent = true;
+          if (keepsOpenAIResponsesFormat) openAIResponsesDoneSent = true;
+          continue;
+        }
+
+        const textDelta = collectStreamText(parsed, targetFormat);
+        totalContentLength += textDelta.length;
+        accumulatedContent = appendStreamPreview(accumulatedContent, textDelta.content);
+        accumulatedThinking = appendStreamPreview(accumulatedThinking, textDelta.thinking);
+
+        const extracted = extractUsage(parsed);
+        if (extracted) state.usage = mergeUsage(state.usage, extracted);
+
+        if (keepsOpenAIResponsesFormat && openAIResponsesEventName) {
+          const output = formatSSE({ event: openAIResponsesEventName, data: parsed }, sourceFormat);
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(sharedEncoder.encode(output));
+          currentOpenAIResponsesEvent = null;
+          sseEmittedCount++;
+          continue;
+        }
+
+        currentOpenAIResponsesEvent = null;
+
+        const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
+
+        if (translated?._openaiIntermediate) {
+          for (const item of translated._openaiIntermediate) {
+            const openaiOutput = formatSSE(item, FORMATS.OPENAI);
+            reqLogger?.appendOpenAIChunk?.(openaiOutput);
+          }
+        }
+
+        if (translated?.length > 0) {
+          for (const item of translated) {
+            if (item === null || item === undefined) continue;
+
+            if (!hasValuableContent(item, sourceFormat)) {
+              continue;
+            }
+
+            const isFinishChunk = item.type === "message_delta" || item.choices?.[0]?.finish_reason;
+            if (state.finishReason && isFinishChunk && !hasValidUsage(item.usage) && totalContentLength > 0) {
+              const estimated = estimateUsage(body, totalContentLength, sourceFormat);
+              item.usage = filterUsageForFormat(estimated, sourceFormat);
+              state.usage = estimated;
+            } else if (state.finishReason && isFinishChunk && state.usage) {
+
+              const buffered = addBufferToUsage(state.usage);
+              item.usage = filterUsageForFormat(buffered, sourceFormat);
+            }
+
+            const output = formatSSE(item, sourceFormat);
+            reqLogger?.appendConvertedChunk?.(output);
+            controller.enqueue(sharedEncoder.encode(output));
+            sseEmittedCount++;
+          }
+        }
+      }
+    },
+
+    flush(controller) {
+      const evtSummary = Object.entries(eventTypeCounts).map(([k, v]) => `${k}=${v}`).join(",") || "none";
+      dbg("SSE", `flush | provider=${provider} | model=${model} | recvLines=${sseLineCount} | emitted=${sseEmittedCount} | events=[${evtSummary}]`);
+      trackPendingRequest(model, provider, connectionId, false);
+      try {
+        const remaining = decoder.decode();
+        if (remaining) buffer += remaining;
+
+        if (mode === STREAM_MODE.PASSTHROUGH) {
+          if (buffer) {
+            let output = buffer;
+            if (buffer.startsWith("data:") && !buffer.startsWith("data: ")) {
+              output = "data: " + buffer.slice(5);
+            }
+            reqLogger?.appendConvertedChunk?.(output);
+            controller.enqueue(sharedEncoder.encode(output));
+          }
+
+          if (!hasValidUsage(usage) && totalContentLength > 0) {
+            usage = estimateUsage(body, totalContentLength, FORMATS.OPENAI);
+          }
+
+          if (hasValidUsage(usage)) {
+            logUsage(provider, usage, model, connectionId, apiKey);
+          } else {
+            appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
+          }
+
+          const isGeminiFamily = provider === "antigravity" || provider === "gemini" || provider === "vertex";
+          if (!streamDoneSent && !isGeminiFamily) {
+            const doneOutput = "data: [DONE]\n\n";
+            reqLogger?.appendConvertedChunk?.(doneOutput);
+            controller.enqueue(sharedEncoder.encode(doneOutput));
+          }
+
+          if (onStreamComplete) {
+            onStreamComplete({
+              content: accumulatedContent,
+              thinking: accumulatedThinking
+             }, usage, ttftAt, streamTerminalSeen);
+          }
+          return;
+        }
+
+        if (buffer.trim()) {
+          const parsed = parseSSELine(buffer.trim(), targetFormat);
+          if (parsed) {
+            if (hasStreamTerminalMarker(parsed, targetFormat)) streamTerminalSeen = true;
+
+            if (!parsed.done) {
+              const textDelta = collectStreamText(parsed, targetFormat);
+              totalContentLength += textDelta.length;
+              accumulatedContent = appendStreamPreview(accumulatedContent, textDelta.content);
+              accumulatedThinking = appendStreamPreview(accumulatedThinking, textDelta.thinking);
+
+              const extracted = extractUsage(parsed);
+              if (extracted) state.usage = mergeUsage(state.usage, extracted);
+            }
+            const translated = parsed && !parsed.done
+              ? translateResponse(targetFormat, sourceFormat, parsed, state)
+              : null;
+
+            if (translated?._openaiIntermediate) {
+              for (const item of translated._openaiIntermediate) {
+                const openaiOutput = formatSSE(item, FORMATS.OPENAI);
+                reqLogger?.appendOpenAIChunk?.(openaiOutput);
+              }
+            }
+
+            if (translated?.length > 0) {
+              for (const item of translated) {
+                if (item === null || item === undefined) continue;
+                const output = formatSSE(item, sourceFormat);
+                reqLogger?.appendConvertedChunk?.(output);
+                controller.enqueue(sharedEncoder.encode(output));
+              }
+            }
+          }
+        }
+
+        const flushed = translateResponse(targetFormat, sourceFormat, null, state);
+
+        if (flushed?._openaiIntermediate) {
+          for (const item of flushed._openaiIntermediate) {
+            const openaiOutput = formatSSE(item, FORMATS.OPENAI);
+            reqLogger?.appendOpenAIChunk?.(openaiOutput);
+          }
+        }
+
+        if (flushed?.length > 0) {
+          for (const item of flushed) {
+            if (item === null || item === undefined) continue;
+            const output = formatSSE(item, sourceFormat);
+            reqLogger?.appendConvertedChunk?.(output);
+            controller.enqueue(sharedEncoder.encode(output));
+          }
+        }
+
+        const keepsOpenAIResponsesFormat = targetFormat === FORMATS.OPENAI_RESPONSES && sourceFormat === FORMATS.OPENAI_RESPONSES;
+        if (keepsOpenAIResponsesFormat && !openAIResponsesTerminalSeen) {
+          const failedOutput = formatIncompleteOpenAIResponsesStreamFailure();
+          reqLogger?.appendConvertedChunk?.(failedOutput);
+          controller.enqueue(sharedEncoder.encode(failedOutput));
+          openAIResponsesTerminalSeen = true;
+        }
+
+        if (keepsOpenAIResponsesFormat && !openAIResponsesDoneSent && !streamDoneSent) {
+          const doneOutput = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(doneOutput);
+          controller.enqueue(sharedEncoder.encode(doneOutput));
+          openAIResponsesDoneSent = true;
+          streamDoneSent = true;
+        }
+
+        if (!hasValidUsage(state?.usage) && totalContentLength > 0) {
+          state.usage = estimateUsage(body, totalContentLength, sourceFormat);
+        }
+
+        if (hasValidUsage(state?.usage)) {
+          logUsage(state.provider || targetFormat, state.usage, model, connectionId, apiKey);
+        } else {
+          appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
+        }
+
+        if (onStreamComplete) {
+          onStreamComplete({
+            content: accumulatedContent,
+            thinking: accumulatedThinking
+          }, state?.usage, ttftAt, streamTerminalSeen);
+        }
+      } catch (error) {
+        console.log("Error in flush:", error);
+      }
+    }
+  });
+}
+
+export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null, customToolNames = null) {
+  return createSSEStream({
+    mode: STREAM_MODE.TRANSLATE,
+    targetFormat,
+    sourceFormat,
+    provider,
+    reqLogger,
+    toolNameMap,
+    customToolNames,
+    model,
+    connectionId,
+    body,
+    onStreamComplete,
+    apiKey
+  });
+}
+
+export function createPassthroughStreamWithLogger(provider = null, reqLogger = null, model = null, connectionId = null, body = null, onStreamComplete = null, apiKey = null) {
+  return createSSEStream({
+    mode: STREAM_MODE.PASSTHROUGH,
+    provider,
+    reqLogger,
+    model,
+    connectionId,
+    body,
+    onStreamComplete,
+    apiKey
+  });
+}