swayrouter 1.0.0

package/src/utils/streamHandler.js

@@ -0,0 +1,256 @@
+import { STREAM_STALL_TIMEOUT_MS } from "../config/runtimeConfig.js";
+import { dbg, isDebugEnabled } from "./debugLog.js";
+
+export function isGracefulNetworkClose(error) {
+  const seen = new Set();
+  let current = error;
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const name = String(current.name || "").toLowerCase();
+    const code = String(current.code || "").toUpperCase();
+    const message = String(current.message || "").toLowerCase();
+    if (name === "aborterror") return true;
+    if (
+      code === "UND_ERR_SOCKET" ||
+      code === "ECONNRESET" ||
+      code === "ECONNABORTED" ||
+      code === "ETIMEDOUT" ||
+      code === "EPIPE" ||
+      code === "ERR_STREAM_PREMATURE_CLOSE" ||
+      message.includes("other side closed") ||
+      message.includes("socket hang up") ||
+      message.includes("econnreset") ||
+      message.includes("econnaborted") ||
+      message.includes("etimedout") ||
+      message.includes("epipe") ||
+      message.includes("premature close")
+    ) {
+      return true;
+    }
+    current = current.cause;
+  }
+  return false;
+}
+
+function getTimeString() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+
+export function createStreamController({ onDisconnect, onError, log, provider, model, reqTag = "", callerSignal = null } = {}) {
+  const abortController = new AbortController();
+  const startTime = Date.now();
+  let disconnected = false;
+  let callerAborted = false;
+  let abortTimeout = null;
+  let removeCallerAbort = null;
+
+  const onCallerAbort = () => {
+    if (disconnected) return;
+    callerAborted = true;
+    disconnected = true;
+    if (abortTimeout) {
+      clearTimeout(abortTimeout);
+      abortTimeout = null;
+    }
+    try { abortController.abort(callerSignal?.reason); } catch { abortController.abort(); }
+    onDisconnect?.({ reason: "caller_aborted", duration: Date.now() - startTime });
+  };
+  if (callerSignal) {
+    if (callerSignal.aborted) onCallerAbort();
+    else {
+      callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+      removeCallerAbort = () => callerSignal.removeEventListener("abort", onCallerAbort);
+    }
+  }
+
+  const logStream = (symbol, status, isError = false) => {
+    const duration = Date.now() - startTime;
+    const emit = isError ? log?.errorLine : log?.line;
+    if (emit) emit(reqTag, symbol, `${status} · ${provider}/${model} · ${duration}ms`);
+    else console.log(`[${getTimeString()}] ${symbol} ${provider}/${model} · ${status} · ${duration}ms`);
+  };
+
+  return {
+    signal: abortController.signal,
+    startTime,
+
+    isConnected: () => !disconnected,
+    isCallerAborted: () => callerAborted,
+
+    handleDisconnect: (reason = "client_closed") => {
+      if (disconnected) return;
+      disconnected = true;
+      removeCallerAbort?.();
+      removeCallerAbort = null;
+
+      logStream("WARN", `DISCONNECT · ${reason}`);
+      dbg("CTRL", `${provider}/${model} | disconnect=${reason} | dur=${Date.now() - startTime}ms`);
+
+      abortTimeout = setTimeout(() => {
+        abortController.abort();
+      }, 500);
+
+      onDisconnect?.({ reason, duration: Date.now() - startTime });
+    },
+
+    handleComplete: () => {
+      if (disconnected) return;
+      disconnected = true;
+      removeCallerAbort?.();
+      removeCallerAbort = null;
+
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+    },
+
+    handleError: (error) => {
+      if (disconnected) return;
+      disconnected = true;
+      removeCallerAbort?.();
+      removeCallerAbort = null;
+
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+        abortTimeout = null;
+      }
+
+      if (error.name === "AbortError") {
+        logStream("WARN", "ABORTED");
+        onError?.(error);
+        return;
+      }
+
+      logStream("ERROR", `ERROR: ${error.message}${error.stack ? `\n    ${error.stack}` : ""}`, true);
+      onError?.(error);
+    },
+
+    abort: () => abortController.abort()
+  };
+}
+
+export function createDisconnectAwareStream(transformStream, streamController, onAbortTerminal = null) {
+  const reader = transformStream.readable.getReader();
+  const writer = transformStream.writable.getWriter();
+  let terminalEmitted = false;
+
+  const emitTerminal = (controller) => {
+    if (terminalEmitted || !onAbortTerminal) return;
+    terminalEmitted = true;
+    try {
+      const bytes = onAbortTerminal();
+      if (bytes) controller.enqueue(bytes);
+    } catch {                            }
+  };
+
+  return new ReadableStream({
+    async pull(controller) {
+      if (!streamController.isConnected()) {
+        if (!streamController.isCallerAborted?.()) emitTerminal(controller);
+        controller.close();
+        return;
+      }
+
+      try {
+        const { done, value } = await reader.read();
+
+        if (done) {
+          streamController.handleComplete();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        const wasConnected = streamController.isConnected();
+        const callerAborted = streamController.isCallerAborted?.() === true;
+
+        const msg0 = error?.message || "";
+        const isControllerClosed = msg0.includes("already closed") || msg0.includes("Invalid state");
+        if (!isControllerClosed && !callerAborted) streamController.handleError(error);
+        reader.cancel().catch(() => {});
+        writer.abort().catch(() => {});
+
+        const isNetworkClose = isGracefulNetworkClose(error);
+
+        try {
+          if (callerAborted) {
+            controller.close();
+          } else if (!wasConnected || isNetworkClose || onAbortTerminal) {
+            emitTerminal(controller);
+            controller.close();
+          } else {
+            controller.error(error);
+          }
+        } catch (e) {                                   }
+      }
+    },
+
+    cancel(reason) {
+      streamController.handleDisconnect(reason || "cancelled");
+      reader.cancel();
+      writer.abort();
+    }
+  });
+}
+
+export function pipeWithDisconnect(providerResponse, transformStream, streamController, onAbortTerminal = null, stallTimeoutMs = STREAM_STALL_TIMEOUT_MS) {
+  let stallTimer = null;
+  let chunkCount = 0;
+  let totalBytes = 0;
+  let lastChunkAt = Date.now();
+  const t0 = Date.now();
+  const tag = "STREAM";
+  const clearStall = () => {
+    if (stallTimer) { clearTimeout(stallTimer); stallTimer = null; }
+  };
+  const armStall = () => {
+    clearStall();
+    stallTimer = setTimeout(() => {
+      stallTimer = null;
+      dbg(tag, `STALL TIMEOUT ${stallTimeoutMs}ms | chunks=${chunkCount} | bytes=${totalBytes} | sinceLast=${Date.now() - lastChunkAt}ms`);
+      streamController.handleError?.(new Error("stream stall timeout"));
+      streamController.abort?.();
+    }, stallTimeoutMs);
+  };
+
+  const wrappedController = {
+    signal: streamController.signal,
+    startTime: streamController.startTime,
+    isConnected: () => streamController.isConnected(),
+    handleComplete: () => { dbg(tag, `complete | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleComplete(); },
+    handleError: (e) => { dbg(tag, `error: ${e?.message} | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleError(e); },
+    handleDisconnect: (r) => { dbg(tag, `disconnect: ${r} | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); streamController.handleDisconnect(r); },
+    abort: () => { clearStall(); streamController.abort(); }
+  };
+
+  armStall();
+  dbg(tag, `pipe start | stallTimeout=${stallTimeoutMs}ms`);
+
+  const upstreamTap = new TransformStream({
+    transform(chunk, controller) {
+      chunkCount++;
+      const sz = chunk?.byteLength || chunk?.length || 0;
+      totalBytes += sz;
+      const now = Date.now();
+      const gap = now - lastChunkAt;
+      lastChunkAt = now;
+      if (isDebugEnabled && (chunkCount <= 5 || chunkCount % 20 === 0 || gap > 5000)) {
+        dbg(tag, `chunk #${chunkCount} | size=${sz}B | gap=${gap}ms | total=${totalBytes}B`);
+      }
+      armStall();
+      controller.enqueue(chunk);
+    },
+    flush() { dbg(tag, `upstream EOF | chunks=${chunkCount} | bytes=${totalBytes} | dur=${Date.now() - t0}ms`); clearStall(); }
+  });
+
+  const transformedBody = providerResponse.body
+    .pipeThrough(upstreamTap)
+    .pipeThrough(transformStream);
+
+  return createDisconnectAwareStream(
+    { readable: transformedBody, writable: { getWriter: () => ({ abort: () => Promise.resolve() }) } },
+    wrappedController,
+    onAbortTerminal
+  );
+}

package/src/utils/streamHelpers.js

@@ -0,0 +1,113 @@
+import { FORMATS } from "../translator/formats.js";
+
+export function parseSSELine(line, format = null) {
+  if (!line) return null;
+
+  if (format === FORMATS.OLLAMA) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        return JSON.parse(trimmed);
+      } catch (error) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  if (line.charCodeAt(0) !== 100) return null;
+
+  const data = line.slice(5).trim();
+  if (data === "[DONE]") return { done: true };
+
+  try {
+    return JSON.parse(data);
+  } catch (error) {
+    if (data.length > 0 && data.length < 1000) {
+      console.log(`[WARN] Failed to parse SSE line (${data.length} chars): ${data.substring(0, 100)}...`);
+    }
+    return null;
+  }
+}
+
+export function hasValuableContent(chunk, format) {
+
+  if (format === FORMATS.OPENAI && chunk.choices?.[0]?.delta) {
+    const delta = chunk.choices[0].delta;
+    return delta.content && delta.content !== "" ||
+           delta.reasoning_content && delta.reasoning_content !== "" ||
+           delta.tool_calls && delta.tool_calls.length > 0 ||
+           chunk.choices[0].finish_reason ||
+           delta.role;
+  }
+
+  if (format === FORMATS.CLAUDE) {
+    const isContentBlockDelta = chunk.type === "content_block_delta";
+    const hasText = chunk.delta?.text && chunk.delta.text !== "";
+    const hasThinking = chunk.delta?.thinking && chunk.delta.thinking !== "";
+    const hasInputJson = chunk.delta?.partial_json && chunk.delta.partial_json !== "";
+
+    if (isContentBlockDelta && !hasText && !hasThinking && !hasInputJson) {
+      return false;
+    }
+    return true;
+  }
+
+  return true;
+}
+
+export function fixInvalidId(parsed) {
+  if (parsed.id && (parsed.id === "chat" || parsed.id === "completion" || parsed.id.length < 8)) {
+    const fallbackId = parsed.extend_fields?.requestId ||
+                      parsed.extend_fields?.traceId ||
+                      Date.now().toString(36);
+    parsed.id = `chatcmpl-${fallbackId}`;
+    return true;
+  }
+  return false;
+}
+
+function cleanUsagePayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return payload;
+  }
+
+  let cleaned = payload;
+
+  if ("usage" in cleaned) {
+    if (cleaned.usage === null) {
+      const { usage, ...payloadWithoutUsage } = cleaned;
+      cleaned = payloadWithoutUsage;
+    } else if (typeof cleaned.usage === "object" && cleaned.usage.perf_metrics === null) {
+      const { perf_metrics, ...usageWithoutPerf } = cleaned.usage;
+      cleaned = { ...cleaned, usage: usageWithoutPerf };
+    }
+  }
+
+  if (cleaned.response && typeof cleaned.response === "object" && !Array.isArray(cleaned.response)) {
+    const cleanedResponse = cleanUsagePayload(cleaned.response);
+    if (cleanedResponse !== cleaned.response) {
+      cleaned = { ...cleaned, response: cleanedResponse };
+    }
+  }
+
+  return cleaned;
+}
+
+export function formatSSE(data, sourceFormat) {
+  if (data === null || data === undefined) return "data: null\n\n";
+  if (data && data.done) return "data: [DONE]\n\n";
+
+  if (data && data.event && data.data) {
+    const cleanedEventData = cleanUsagePayload(data.data);
+    return `event: ${data.event}\ndata: ${JSON.stringify(cleanedEventData)}\n\n`;
+  }
+
+  data = cleanUsagePayload(data);
+
+  if (sourceFormat === FORMATS.CLAUDE && data && data.type) {
+    return `event: ${data.type}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+
+  return `data: ${JSON.stringify(data)}\n\n`;
+}

package/src/utils/toolDeduper.js

@@ -0,0 +1,44 @@
+const DEDUP_RULES = [
+  {
+
+    triggers: ["mcp__exa__web_search_exa", "mcp__exa__web_fetch_exa"],
+    strip: ["WebSearch", "WebFetch", "mcp__workspace__web_fetch"],
+  },
+  {
+
+    triggers: ["mcp__tavily__tavily_search", "mcp__tavily__tavily_extract"],
+    strip: ["WebSearch", "WebFetch", "mcp__workspace__web_fetch"],
+  },
+  {
+
+    triggers: [/^mcp__browsermcp__/],
+    strip: [/^mcp__Claude_in_Chrome__/],
+  },
+];
+
+function getToolName(t) {
+  return t?.name || t?.function?.name || "";
+}
+
+function matches(name, pattern) {
+  if (typeof pattern === "string") return name === pattern;
+  return pattern instanceof RegExp ? pattern.test(name) : false;
+}
+
+function dedupeTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return { tools, stripped: [] };
+  const names = tools.map(getToolName);
+  const toStrip = new Set();
+  for (const rule of DEDUP_RULES) {
+    const hasTrigger = names.some((n) => rule.triggers.some((p) => matches(n, p)));
+    if (!hasTrigger) continue;
+    for (const n of names) {
+      if (rule.strip.some((p) => matches(n, p))) toStrip.add(n);
+    }
+  }
+  if (toStrip.size === 0) return { tools, stripped: [] };
+  const out = tools.filter((t) => !toStrip.has(getToolName(t)));
+  return { tools: out, stripped: Array.from(toStrip) };
+}
+
+export { dedupeTools };