Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

3.4 KB
Raw Blame
/**
 * Progress Tracker — Phase 9.3
 *
 * Emits SSE `event: progress` events during long streaming responses.
 * Opt-in via X-OmniRoute-Progress: true header.
 *
 * Progress events contain:
 *   { tokens_generated, elapsed_ms }
 *
 * @module utils/progressTracker
 */

const DEFAULT_INTERVAL_MS = 2000;

/**
 * Create a progress emitter for a streaming response.
 * Returns a TransformStream that injects progress events periodically.
 *
 * @param {object} options
 * @param {number} [options.intervalMs=2000] - Interval between events
 * @param {AbortSignal} [options.signal] - Abort signal for cancellation
 * @returns {TransformStream}
 */
export function createProgressTransform({
  intervalMs = DEFAULT_INTERVAL_MS,
  signal,
}: { intervalMs?: number; signal?: AbortSignal } = {}) {
  let tokenCount = 0;
  let startTime = Date.now();
  let intervalId;
  let writer;
  let pendingLine = "";

  const encoder = new TextEncoder();
  const decoder = new TextDecoder();

  const countDataLines = (text: string) => {
    tokenCount += text.split("\n").filter((line) => line.startsWith("data: ")).length;
  };

  return new TransformStream(
    {
      start(controller) {
        writer = controller;
        startTime = Date.now();

        intervalId = setInterval(() => {
          if (signal?.aborted) {
            clearInterval(intervalId);
            return;
          }
          const progressEvent = `event: progress\ndata: ${JSON.stringify({
            tokens_generated: tokenCount,
            elapsed_ms: Date.now() - startTime,
          })}\n\n`;
          try {
            controller.enqueue(encoder.encode(progressEvent));
          } catch {
            // Stream closed
            clearInterval(intervalId);
          }
        }, intervalMs);

        // Clean up on abort
        signal?.addEventListener(
          "abort",
          () => {
            clearInterval(intervalId);
          },
          { once: true }
        );
      },

      transform(chunk, controller) {
        const text =
          typeof chunk === "string"
            ? decoder.decode() + chunk
            : decoder.decode(chunk, { stream: true });
        pendingLine += text;

        const lastNewline = pendingLine.lastIndexOf("\n");
        if (lastNewline >= 0) {
          countDataLines(pendingLine.slice(0, lastNewline + 1));
          pendingLine = pendingLine.slice(lastNewline + 1);
        }
        controller.enqueue(chunk);
      },

      flush() {
        clearInterval(intervalId);
        pendingLine += decoder.decode();
        countDataLines(pendingLine);
        // Final progress event
        if (writer) {
          try {
            const finalEvent = `event: progress\ndata: ${JSON.stringify({
              tokens_generated: tokenCount,
              elapsed_ms: Date.now() - startTime,
              done: true,
            })}\n\n`;
            writer.enqueue(encoder.encode(finalEvent));
          } catch {
            // Stream already closed
          }
        }
      },

      cancel() {
        clearInterval(intervalId);
      },
    },
    { highWaterMark: 16384 },
    { highWaterMark: 16384 }
  );
}

/**
 * Check if client opted into progress tracking.
 * @param {Headers|object} headers
 * @returns {boolean}
 */
export function wantsProgress(headers) {
  if (!headers) return false;
  const get = typeof headers.get === "function" ? (k) => headers.get(k) : (k) => headers[k];
  return get("x-omniroute-progress") === "true";
}