@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/utils/stream.js

@@ -0,0 +1,517 @@
+import { translateResponse, initState } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { trackPendingRequest, appendRequestLog } from '../../../dist/lib/usageDb.js';
+import { extractUsage, 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";
+
+export { COLORS, formatSSE };
+
+// sharedEncoder is stateless — safe to share across streams
+const sharedEncoder = new TextEncoder();
+
+/**
+ * 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
+ * @param {string} options.model - Model name
+ * @param {string} options.connectionId - Connection ID for usage tracking
+ * @param {object} options.body - Request body (for input token estimation)
+ * @param {function} options.onStreamComplete - Callback when stream completes (content, usage)
+ * @param {string} options.apiKey - API key for usage tracking
+ */
+export function createSSEStream(options = {}) {
+  const {
+    mode = STREAM_MODE.TRANSLATE,
+    targetFormat,
+    sourceFormat,
+    provider = null,
+    reqLogger = null,
+    toolNameMap = null,
+    model = null,
+    connectionId = null,
+    body = null,
+    onStreamComplete = null,
+    apiKey = null
+  } = options;
+
+  let buffer = "";
+  let usage = null;
+
+  // Per-stream decoder with stream:true to correctly handle multi-byte chars split across chunks
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+
+  const state = mode === STREAM_MODE.TRANSLATE ? { ...initState(sourceFormat), provider, toolNameMap, model } : null;
+
+  let totalContentLength = 0;
+  let accumulatedContent = "";
+  let accumulatedThinking = "";
+  let ttftAt = null;
+  let sseLineCount = 0;
+  let sseEmittedCount = 0;
+  const eventTypeCounts = {};
+
+  // Track Responses API event framing for same-format passthrough (codex)
+  let currentOpenAIResponsesEvent = null;
+  let openAIResponsesTerminalSeen = false;
+  let openAIResponsesDoneSent = 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;
+          }
+        }
+
+        // Capture Responses API event name to preserve framing in same-format passthrough
+        if (mode === STREAM_MODE.TRANSLATE && targetFormat === FORMATS.OPENAI_RESPONSES && trimmed.startsWith("event:")) {
+          currentOpenAIResponsesEvent = trimmed.slice(6).trim();
+        }
+
+        // Passthrough mode: normalize and forward
+        if (mode === STREAM_MODE.PASSTHROUGH) {
+          let output;
+          let injectedUsage = false;
+
+          // Handle raw JSON error disguised as SSE in passthrough mode
+          if (trimmed.startsWith("{")) {
+            try {
+              const parsedJson = JSON.parse(trimmed);
+              if (parsedJson && (parsedJson.error || parsedJson.code !== undefined || parsedJson.msg)) {
+                const errorMsg = parsedJson.error?.message || parsedJson.msg || (typeof parsedJson.error === "string" ? parsedJson.error : JSON.stringify(parsedJson));
+                const errorChunk = {
+                  id: `err_${Date.now()}`,
+                  object: "chat.completion.chunk",
+                  created: Math.floor(Date.now() / 1000),
+                  model: model || "unknown",
+                  choices: [{
+                    index: 0,
+                    delta: { content: `\n\n[Provider Error]: ${errorMsg}\n\n` },
+                    finish_reason: "stop"
+                  }]
+                };
+                output = formatSSE(errorChunk, FORMATS.OPENAI);
+                reqLogger?.appendConvertedChunk?.(output);
+                controller.enqueue(sharedEncoder.encode(output));
+                
+                const doneOutput = "data: [DONE]\n\n";
+                reqLogger?.appendConvertedChunk?.(doneOutput);
+                controller.enqueue(sharedEncoder.encode(doneOutput));
+                continue;
+              }
+            } catch (e) {}
+          }
+
+          if (trimmed.startsWith("data:") && trimmed.slice(5).trim() !== "[DONE]") {
+            try {
+              const parsed = JSON.parse(trimmed.slice(5).trim());
+
+              const idFixed = fixInvalidId(parsed);
+
+              // Ensure OpenAI-required fields are present on streaming chunks (Letta compat)
+              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; }
+              }
+
+              // Strip Azure-specific non-standard fields from streaming chunks
+              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 (!hasValuableContent(parsed, FORMATS.OPENAI)) {
+                continue;
+              }
+
+              const delta = parsed.choices?.[0]?.delta;
+              
+              // Map refusal to content for clients that do not support the refusal field
+              if (delta?.refusal && !delta?.content) {
+                delta.content = `[Refusal]: ${delta.refusal}`;
+              }
+              
+              const content = delta?.content;
+              const reasoning = delta?.reasoning_content;
+              if (content && typeof content === "string") {
+                totalContentLength += content.length;
+                accumulatedContent += content;
+              }
+              if (reasoning && typeof reasoning === "string") {
+                totalContentLength += reasoning.length;
+                accumulatedThinking += reasoning;
+              }
+
+              const extracted = extractUsage(parsed);
+              if (extracted) {
+                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 { }
+          }
+
+          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;
+        }
+
+        // Translate mode
+        if (!trimmed) continue;
+
+        const parsed = parseSSELine(trimmed, targetFormat);
+        if (!parsed) continue;
+        
+        // Intercept raw JSON error that provider sent instead of SSE
+        if (parsed._isRawError) {
+          const errorMsg = parsed.raw.error?.message || parsed.raw.msg || (typeof parsed.raw.error === "string" ? parsed.raw.error : JSON.stringify(parsed.raw));
+          const errorChunk = {
+            id: `err_${Date.now()}`,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: model || "unknown",
+            choices: [{
+              index: 0,
+              delta: { content: `\n\n[Provider Error]: ${errorMsg}\n\n` },
+              finish_reason: "stop"
+            }]
+          };
+          const output = formatSSE(errorChunk, sourceFormat);
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(sharedEncoder.encode(output));
+          sseEmittedCount++;
+          
+          const doneOutput = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(doneOutput);
+          controller.enqueue(sharedEncoder.encode(doneOutput));
+          if (targetFormat === FORMATS.OPENAI_RESPONSES && sourceFormat === FORMATS.OPENAI_RESPONSES) openAIResponsesDoneSent = true;
+          continue;
+        }
+
+        // Map refusal to content for older clients that do not support refusal field
+        if (parsed.choices?.[0]?.delta?.refusal && !parsed.choices[0].delta.content) {
+          parsed.choices[0].delta.content = `[Refusal]: ${parsed.choices[0].delta.refusal}`;
+        }
+
+        // Responses API same-format passthrough: preserve event framing + track terminal state
+        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;
+        }
+
+        // For Ollama: done=true is the final chunk with finish_reason/usage, must translate
+        // For other formats: done=true is the [DONE] sentinel, skip
+        if (parsed && parsed.done && targetFormat !== FORMATS.OLLAMA) {
+          // Synthesize response.failed if the Responses stream never sent a terminal event
+          if (keepsOpenAIResponsesFormat && !openAIResponsesTerminalSeen) {
+            const failedOutput = formatIncompleteOpenAIResponsesStreamFailure();
+            reqLogger?.appendConvertedChunk?.(failedOutput);
+            controller.enqueue(sharedEncoder.encode(failedOutput));
+            openAIResponsesTerminalSeen = true;
+            sseEmittedCount++;
+          }
+
+          const output = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(output);
+          controller.enqueue(sharedEncoder.encode(output));
+          if (keepsOpenAIResponsesFormat) openAIResponsesDoneSent = true;
+          continue;
+        }
+
+        // Claude format - content
+        if (parsed.delta?.text) {
+          totalContentLength += parsed.delta.text.length;
+          accumulatedContent += parsed.delta.text;
+        }
+        // Claude format - thinking
+        if (parsed.delta?.thinking) {
+          totalContentLength += parsed.delta.thinking.length;
+          accumulatedThinking += parsed.delta.thinking;
+        }
+        
+        // OpenAI format - content
+        if (parsed.choices?.[0]?.delta?.content) {
+          totalContentLength += parsed.choices[0].delta.content.length;
+          accumulatedContent += parsed.choices[0].delta.content;
+        }
+        // OpenAI format - reasoning
+        if (parsed.choices?.[0]?.delta?.reasoning_content) {
+          totalContentLength += parsed.choices[0].delta.reasoning_content.length;
+          accumulatedThinking += parsed.choices[0].delta.reasoning_content;
+        }
+        
+        // Gemini format
+        if (parsed.candidates?.[0]?.content?.parts) {
+          for (const part of parsed.candidates[0].content.parts) {
+            if (part.text && typeof part.text === "string") {
+              totalContentLength += part.text.length;
+              // Check if this is thinking content
+              if (part.thought === true) {
+                accumulatedThinking += part.text;
+              } else {
+                accumulatedContent += part.text;
+              }
+            }
+          }
+        }
+
+        // Extract usage
+        const extracted = extractUsage(parsed);
+        if (extracted) state.usage = extracted; // Keep original usage for logging
+
+        // Responses same-format passthrough: re-emit with original event framing
+        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;
+
+        // Translate: targetFormat -> openai -> sourceFormat
+        const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
+
+        // Log OpenAI intermediate chunks (if available)
+        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;
+            // Filter empty chunks
+            if (!hasValuableContent(item, sourceFormat)) {
+              continue; // Skip this empty chunk
+            }
+
+            // Inject estimated usage if finish chunk has no valid usage
+            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); // Filter + already has buffer
+              state.usage = estimated;
+            } else if (state.finishReason && isFinishChunk && state.usage) {
+              // Add buffer and filter usage for client (but keep original in state.usage for logging)
+              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);
+          }
+
+          
+          // IMPORTANT: In passthrough mode we still must terminate the SSE stream.
+          // Some clients (e.g. OpenClaw) expect the OpenAI-style sentinel:
+          //   data: [DONE]\n\n
+          // Without it they can hang until timeout and trigger failover.
+          const doneOutput = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(doneOutput);
+          controller.enqueue(sharedEncoder.encode(doneOutput));
+
+          if (onStreamComplete) {
+            onStreamComplete({
+              content: accumulatedContent,
+              thinking: accumulatedThinking
+            }, usage, ttftAt);
+          }
+          return;
+        }
+
+        if (buffer.trim()) {
+          const parsed = parseSSELine(buffer.trim());
+          if (parsed && !parsed.done) {
+            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;
+                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));
+          }
+        }
+
+        // Synthesize response.failed if a Responses passthrough stream never reached a terminal event
+        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) {
+          const doneOutput = "data: [DONE]\n\n";
+          reqLogger?.appendConvertedChunk?.(doneOutput);
+          controller.enqueue(sharedEncoder.encode(doneOutput));
+        }
+
+        if (!hasValidUsage(state?.usage) && totalContentLength > 0) {
+          state.usage = estimateUsage(body, totalContentLength, sourceFormat);
+        }
+        
+        if (onStreamComplete) {
+          onStreamComplete({
+            content: accumulatedContent,
+            thinking: accumulatedThinking
+          }, state?.usage, ttftAt);
+        }
+      } 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) {
+  return createSSEStream({
+    mode: STREAM_MODE.TRANSLATE,
+    targetFormat,
+    sourceFormat,
+    provider,
+    reqLogger,
+    toolNameMap,
+    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
+  });
+}

package/open-sse/utils/streamFailureFinalization.js

@@ -0,0 +1,134 @@
+import {
+  finalizeMostRecentPendingRequest,
+  finalizePendingRequestById,
+} from '../../../dist/lib/usage/usageHistory.js';
+
+import { HTTP_STATUS } from "../config/constants.js";
+import { buildErrorBody } from "./error.js";
+
+export function finalizeStreamRequestLog({
+  pendingRequestId,
+  model,
+  provider,
+  connectionId,
+  providerResponse,
+  clientResponse,
+  status,
+  error,
+  errorCode,
+  onWarn,
+}) {
+  try {
+    const completedById = finalizePendingRequestById(pendingRequestId, {
+      providerResponse,
+      clientResponse,
+      status,
+      error: error || null,
+      errorCode: errorCode || null,
+    });
+    if (!completedById) {
+      finalizeMostRecentPendingRequest(model, provider, connectionId, {
+        providerResponse,
+        clientResponse,
+        status,
+        error: error || null,
+        errorCode: errorCode || null,
+      });
+    }
+  } catch (err) {
+    try {
+      if (onWarn) {
+        onWarn(err);
+      } else {
+        console.warn(
+          "finalizeMostRecentPendingRequest failed:",
+          err && typeof err === "object" && "message" in err
+            ? err.message
+            : err
+        );
+      }
+    } catch {}
+  }
+}
+
+export function createStreamFailureFinalizers({
+  isFailureCompletionRecorded,
+  isStreamCompletionRecorded = () => false,
+  onStreamComplete,
+  persistFailureUsage,
+  onStreamFailure,
+}) {
+  const handleStreamFailure = (failure) => {
+    if (isStreamCompletionRecorded()) {
+      return true;
+    }
+
+    const status = failure.status || HTTP_STATUS.BAD_GATEWAY;
+    const message = failure.message || "Upstream stream error";
+    const code = failure.code || failure.type || String(status);
+
+    if (!isFailureCompletionRecorded()) {
+      const errorBody = buildErrorBody(status, message);
+      onStreamComplete({
+        status,
+        usage: null,
+        responseBody: errorBody,
+        providerPayload: errorBody,
+        clientPayload: errorBody,
+        error: message,
+        errorCode: code,
+        ttft: 0,
+      });
+    }
+
+    persistFailureUsage(status, code);
+    try {
+      onStreamFailure?.(failure);
+    } catch {
+      // Best-effort fallback state update only.
+    }
+    return true;
+  };
+
+  const isClientClosedPipelineError = (message, statusCode) => {
+    const normalized = message.toLowerCase();
+    return (
+      statusCode === 499 ||
+      normalized.includes("responseaborted") ||
+      normalized.includes("controller is already closed") ||
+      normalized.includes("readablestream is closed") ||
+      normalized.includes("writablestream is closed") ||
+      normalized.includes("aborterror")
+    );
+  };
+
+  let pipelineStreamFailureFinalized = false;
+  const onPipelineStreamError = ({ message, statusCode }) => {
+    if (pipelineStreamFailureFinalized) return true;
+    pipelineStreamFailureFinalized = true;
+
+    const normalizedMessage = message || "Upstream stream error";
+    const clientClosed = isClientClosedPipelineError(normalizedMessage, statusCode);
+    const status = clientClosed
+      ? 499
+      : Number.isFinite(statusCode) && statusCode >= 400 && statusCode <= 599
+        ? statusCode
+        : HTTP_STATUS.BAD_GATEWAY;
+    const code = clientClosed
+      ? "client_disconnected"
+      : normalizedMessage.toLowerCase().includes("terminated")
+        ? "stream_terminated"
+        : "stream_pipeline_error";
+    const type = clientClosed ? "client_disconnected" : "stream_error";
+
+    handleStreamFailure({
+      status,
+      message: normalizedMessage,
+      code,
+      type,
+    });
+    return true;
+  };
+
+  return { handleStreamFailure, onPipelineStreamError };
+}