open-sse 1.0.0

package/utils/stream.js

@@ -0,0 +1,274 @@
+import { translateResponse, initState } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+
+// Get HH:MM timestamp
+function getTimeString() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
+}
+
+// Extract usage from any format (Claude, OpenAI, Gemini)
+function extractUsage(chunk) {
+  // Claude format (message_delta event)
+  if (chunk.type === "message_delta" && chunk.usage) {
+    return {
+      prompt_tokens: chunk.usage.input_tokens || 0,
+      completion_tokens: chunk.usage.output_tokens || 0,
+      cache_read_input_tokens: chunk.usage.cache_read_input_tokens,
+      cache_creation_input_tokens: chunk.usage.cache_creation_input_tokens
+    };
+  }
+  // OpenAI format
+  if (chunk.usage?.prompt_tokens !== undefined) {
+    return {
+      prompt_tokens: chunk.usage.prompt_tokens,
+      completion_tokens: chunk.usage.completion_tokens || 0,
+      cached_tokens: chunk.usage.prompt_tokens_details?.cached_tokens,
+      reasoning_tokens: chunk.usage.completion_tokens_details?.reasoning_tokens
+    };
+  }
+  // Gemini format
+  if (chunk.usageMetadata) {
+    return {
+      prompt_tokens: chunk.usageMetadata.promptTokenCount || 0,
+      completion_tokens: chunk.usageMetadata.candidatesTokenCount || 0,
+      reasoning_tokens: chunk.usageMetadata.thoughtsTokenCount
+    };
+  }
+  return null;
+}
+
+// ANSI color codes
+export const COLORS = {
+  reset: "\x1b[0m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  cyan: "\x1b[36m"
+};
+
+// Log usage with cache info (green color)
+function logUsage(provider, usage) {
+  if (!usage) return;
+  
+  const p = provider?.toUpperCase() || "UNKNOWN";
+  const inTokens = usage.prompt_tokens || 0;
+  const outTokens = usage.completion_tokens || 0;
+  
+  let msg = `[${getTimeString()}] 📊 [USAGE] ${p} | in=${inTokens} | out=${outTokens}`;
+  
+  if (usage.cache_creation_input_tokens) msg += ` | cache_write=${usage.cache_creation_input_tokens}`;
+  if (usage.cache_read_input_tokens) msg += ` | cache_read=${usage.cache_read_input_tokens}`;
+  if (usage.cached_tokens) msg += ` | cached=${usage.cached_tokens}`;
+  if (usage.reasoning_tokens) msg += ` | reasoning=${usage.reasoning_tokens}`;
+  
+  console.log(`${COLORS.green}${msg}${COLORS.reset}`);
+}
+
+// Parse SSE data line
+function parseSSELine(line) {
+  if (!line || !line.startsWith("data:")) return null;
+  
+  const data = line.slice(5).trim();
+  if (data === "[DONE]") return { done: true };
+
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format output as SSE
+ * @param {object} data - Data to format
+ * @param {string} sourceFormat - Target format for client
+ * @returns {string} SSE formatted string
+ */
+export function formatSSE(data, sourceFormat) {
+  if (data.done) return "data: [DONE]\n\n";
+  
+  // OpenAI Responses API format: has event field
+  if (data.event && data.data) {
+    return `event: ${data.event}\ndata: ${JSON.stringify(data.data)}\n\n`;
+  }
+  
+  // Claude format: include event prefix
+  if (sourceFormat === FORMATS.CLAUDE && data.type) {
+    return `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+  
+  return `data: ${JSON.stringify(data)}\n\n`;
+}
+
+/**
+ * Stream modes
+ */
+const STREAM_MODE = {
+  TRANSLATE: "translate",    // Full translation between formats
+  PASSTHROUGH: "passthrough" // No translation, normalize output, extract usage
+};
+
+/**
+ * Create unified SSE transform stream
+ * @param {object} options
+ * @param {string} options.mode - Stream mode: translate, passthrough
+ * @param {string} options.targetFormat - Provider format (for translate mode)
+ * @param {string} options.sourceFormat - Client format (for translate mode)
+ * @param {string} options.provider - Provider name
+ * @param {object} options.reqLogger - Request logger instance
+ */
+export function createSSEStream(options = {}) {
+  const { 
+    mode = STREAM_MODE.TRANSLATE, 
+    targetFormat, 
+    sourceFormat, 
+    provider = null, 
+    reqLogger = null 
+  } = options;
+
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  let usage = null;
+  
+  // State for translate mode
+  const state = mode === STREAM_MODE.TRANSLATE ? { ...initState(sourceFormat), provider } : null;
+
+  return new TransformStream({
+    transform(chunk, controller) {
+      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();
+        
+        // Passthrough mode: normalize and forward
+        if (mode === STREAM_MODE.PASSTHROUGH) {
+          if (trimmed.startsWith("data:") && trimmed.slice(5).trim() !== "[DONE]") {
+            try {
+              const parsed = JSON.parse(trimmed.slice(5).trim());
+              const extracted = extractUsage(parsed);
+              if (extracted) usage = extracted;
+            } catch {}
+          }
+          // Normalize: ensure "data: " has space
+          let output;
+          if (line.startsWith("data:") && !line.startsWith("data: ")) {
+            output = "data: " + line.slice(5) + "\n";
+          } else {
+            output = line + "\n";
+          }
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(encoder.encode(output));
+          continue;
+        }
+
+        // Translate mode
+        if (!trimmed) continue;
+
+        const parsed = parseSSELine(trimmed);
+        if (!parsed) continue;
+
+        if (parsed.done) {
+          const output = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(encoder.encode(output));
+          continue;
+        }
+
+        // Extract usage
+        const extracted = extractUsage(parsed);
+        if (extracted) state.usage = extracted;
+
+        // Translate and emit
+        const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
+        if (translated?.length > 0) {
+          for (const item of translated) {
+            const output = formatSSE(item, sourceFormat);
+            reqLogger?.appendConvertedChunk?.(output);
+            controller.enqueue(encoder.encode(output));
+          }
+        }
+      }
+    },
+
+    flush(controller) {
+      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(encoder.encode(output));
+          }
+          if (usage) logUsage(provider, usage);
+          return;
+        }
+
+        // Translate mode: process remaining buffer
+        if (buffer.trim()) {
+          const parsed = parseSSELine(buffer.trim());
+          if (parsed && !parsed.done) {
+            const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
+            if (translated?.length > 0) {
+              for (const item of translated) {
+                const output = formatSSE(item, sourceFormat);
+                reqLogger?.appendConvertedChunk?.(output);
+                controller.enqueue(encoder.encode(output));
+              }
+            }
+          }
+        }
+
+        // Flush remaining events (only once at stream end)
+        const flushed = translateResponse(targetFormat, sourceFormat, null, state);
+        if (flushed?.length > 0) {
+          for (const item of flushed) {
+            const output = formatSSE(item, sourceFormat);
+            reqLogger?.appendConvertedChunk?.(output);
+            controller.enqueue(encoder.encode(output));
+          }
+        }
+
+        // Send [DONE] and log usage
+        const doneOutput = "data: [DONE]\n\n";
+        reqLogger?.appendConvertedChunk?.(doneOutput);
+        controller.enqueue(encoder.encode(doneOutput));
+
+        if (state?.usage) logUsage(state.provider || targetFormat, state.usage);
+      } catch (error) {
+        console.log("Error in flush:", error);
+      }
+    }
+  });
+}
+
+// Convenience functions for backward compatibility
+export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null) {
+  return createSSEStream({ 
+    mode: STREAM_MODE.TRANSLATE, 
+    targetFormat, 
+    sourceFormat, 
+    provider, 
+    reqLogger 
+  });
+}
+
+export function createPassthroughStreamWithLogger(provider = null, reqLogger = null) {
+  return createSSEStream({ 
+    mode: STREAM_MODE.PASSTHROUGH, 
+    provider, 
+    reqLogger 
+  });
+}
+

package/utils/streamHandler.js

@@ -0,0 +1,131 @@
+// Stream handler with disconnect detection - shared for all providers
+
+// Get HH:MM timestamp
+function getTimeString() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" });
+}
+
+/**
+ * Create stream controller with abort and disconnect detection
+ * @param {object} options
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ * @param {object} options.log - Logger instance
+ * @param {string} options.provider - Provider name
+ * @param {string} options.model - Model name
+ */
+export function createStreamController({ onDisconnect, log, provider, model } = {}) {
+  const abortController = new AbortController();
+  const startTime = Date.now();
+  let disconnected = false;
+  let abortTimeout = null;
+
+  const logStream = (status) => {
+    const duration = Date.now() - startTime;
+    const p = provider?.toUpperCase() || "UNKNOWN";
+    console.log(`[${getTimeString()}] 🌊 [STREAM] ${p} | ${model || "unknown"} | ${duration}ms | ${status}`);
+  };
+
+  return {
+    signal: abortController.signal,
+    startTime,
+
+    isConnected: () => !disconnected,
+
+    // Call when client disconnects
+    handleDisconnect: (reason = "client_closed") => {
+      if (disconnected) return;
+      disconnected = true;
+
+      logStream(`disconnect: ${reason}`);
+
+      // Delay abort to allow cleanup
+      abortTimeout = setTimeout(() => {
+        abortController.abort();
+      }, 500);
+
+      onDisconnect?.({ reason, duration: Date.now() - startTime });
+    },
+
+    // Call when stream completes normally
+    handleComplete: () => {
+      if (disconnected) return;
+      disconnected = true;
+
+      logStream("complete");
+
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+    },
+
+    // Call on error
+    handleError: (error) => {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+
+      if (error.name === "AbortError") {
+        logStream("aborted");
+        return;
+      }
+
+      logStream(`error: ${error.message}`);
+    },
+
+    abort: () => abortController.abort()
+  };
+}
+
+/**
+ * Create transform stream with disconnect detection
+ * Wraps existing transform stream and adds abort capability
+ */
+export function createDisconnectAwareStream(transformStream, streamController) {
+  const reader = transformStream.readable.getReader();
+  const writer = transformStream.writable.getWriter();
+
+  return new ReadableStream({
+    async pull(controller) {
+      if (!streamController.isConnected()) {
+        controller.close();
+        return;
+      }
+
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          streamController.handleComplete();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        streamController.handleError(error);
+        controller.error(error);
+      }
+    },
+
+    cancel(reason) {
+      streamController.handleDisconnect(reason || "cancelled");
+      reader.cancel();
+      writer.abort();
+    }
+  });
+}
+
+/**
+ * Pipe provider response through transform with disconnect detection
+ * @param {Response} providerResponse - Response from provider
+ * @param {TransformStream} transformStream - Transform stream for SSE
+ * @param {object} streamController - Stream controller from createStreamController
+ */
+export function pipeWithDisconnect(providerResponse, transformStream, streamController) {
+  const transformedBody = providerResponse.body.pipeThrough(transformStream);
+  return createDisconnectAwareStream(
+    { readable: transformedBody, writable: { getWriter: () => ({ abort: () => {} }) } },
+    streamController
+  );
+}
+