n9router 0.4.44 → 0.4.46

package/app/open-sse/shared/clineAuth.js

@@ -0,0 +1,37 @@
+import pkg from "../../package.json" with { type: "json" };
+
+const APP_VERSION = pkg.version || "0.0.0";
+
+export function getClineAccessToken(token) {
+  if (typeof token !== "string") return "";
+  const trimmed = token.trim();
+  if (!trimmed) return "";
+  return trimmed.startsWith("workos:") ? trimmed : `workos:${trimmed}`;
+}
+
+export function getClineAuthorizationHeader(token) {
+  const accessToken = getClineAccessToken(token);
+  return accessToken ? `Bearer ${accessToken}` : "";
+}
+
+export function buildClineHeaders(token, extraHeaders = {}) {
+  const authorization = getClineAuthorizationHeader(token);
+  const headers = {
+    "HTTP-Referer": "https://cline.bot",
+    "X-Title": "Cline",
+    "User-Agent": `9Router/${APP_VERSION}`,
+    "X-PLATFORM": process.platform || "unknown",
+    "X-PLATFORM-VERSION": process.version || "unknown",
+    "X-CLIENT-TYPE": "9router",
+    "X-CLIENT-VERSION": APP_VERSION,
+    "X-CORE-VERSION": APP_VERSION,
+    "X-IS-MULTIROOT": "false",
+    ...extraHeaders,
+  };
+
+  if (authorization) {
+    headers.Authorization = authorization;
+  }
+
+  return headers;
+}

package/app/open-sse/shared/machineId.js

@@ -0,0 +1,19 @@
+import { machineIdSync } from "node-machine-id";
+import crypto from "node:crypto";
+
+let cachedRawId = null;
+
+function loadRawMachineId() {
+  if (cachedRawId) return cachedRawId;
+  try {
+    cachedRawId = machineIdSync();
+  } catch {
+    cachedRawId = crypto.randomUUID();
+  }
+  return cachedRawId;
+}
+
+export async function getConsistentMachineId(salt = "endpoint-proxy-salt") {
+  const rawId = loadRawMachineId();
+  return crypto.createHash("sha256").update(rawId + salt).digest("hex").substring(0, 16);
+}

package/app/open-sse/shared/qoder/constants.js

@@ -0,0 +1,64 @@
+/**
+ * Qoder API constants ported from CLIProxyAPIPlus qoder-provider branch.
+ *
+ * Endpoint set:
+ *   openapi.qoder.sh   - device flow + userinfo + quota usage
+ *   center.qoder.sh    - token refresh (best-effort, currently 403 for device tokens)
+ *   api3.qoder.sh      - inference (chat) + model list, requires COSY signing
+ *   qoder.com/device   - browser landing page for device authorization
+ */
+
+export const QODER_OPENAPI_BASE = "https://openapi.qoder.sh";
+export const QODER_CENTER_BASE = "https://center.qoder.sh";
+export const QODER_CHAT_BASE = "https://api3.qoder.sh";
+
+export const QODER_LOGIN_URL = "https://qoder.com/device/selectAccounts";
+
+// Device flow endpoints
+export const QODER_DEVICE_TOKEN_URL = `${QODER_OPENAPI_BASE}/api/v1/deviceToken/poll`;
+export const QODER_USERINFO_URL = `${QODER_OPENAPI_BASE}/api/v1/userinfo`;
+export const QODER_QUOTA_USAGE_URL = `${QODER_OPENAPI_BASE}/api/v2/quota/usage`;
+export const QODER_REFRESH_TOKEN_URL = `${QODER_CENTER_BASE}/algo/api/v3/user/refresh_token`;
+
+// Inference endpoints (under /algo on api3.qoder.sh, all COSY-signed)
+export const QODER_CHAT_SIG_PATH = "/api/v2/service/pro/sse/agent_chat_generation";
+export const QODER_CHAT_URL = `${QODER_CHAT_BASE}/algo${QODER_CHAT_SIG_PATH}?FetchKeys=llm_model_result&AgentId=agent_common`;
+export const QODER_CHAT_URL_ENCODED = `${QODER_CHAT_URL}&Encode=1`;
+export const QODER_MODEL_LIST_URL = `${QODER_CHAT_BASE}/algo/api/v2/model/list`;
+
+// COSY header constants. These are not arbitrary — the upstream signature
+// validation matches them against the values used at signing time.
+export const QODER_IDE_VERSION = "1.0.0";
+export const QODER_CLIENT_TYPE = "5";
+export const QODER_DATA_POLICY = "disagree";
+export const QODER_LOGIN_VERSION = "v2";
+export const QODER_MACHINE_OS = "x86_64_windows";
+export const QODER_MACHINE_TYPE = "5";
+
+// Canonical model identifiers. Identity map — keep as a map so callers can
+// cheaply test "is this a known qoder model?" before sending the request.
+export const QODER_MODEL_MAP = {
+  // Tier models
+  auto: "auto",
+  ultimate: "ultimate",
+  performance: "performance",
+  efficient: "efficient",
+  lite: "lite",
+  // Frontier models
+  qmodel: "qmodel",
+  qmodel_latest: "qmodel_latest",
+  dmodel: "dmodel",
+  dfmodel: "dfmodel",
+  gm51model: "gm51model",
+  kmodel: "kmodel",
+  mmodel: "mmodel",
+};
+
+// RSA public key for COSY encryption (extracted from Qoder IDE v0.9).
+// Matches the CLIProxyAPIPlus branch and live qodercli traffic.
+export const QODER_RSA_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA8iMH5c02LilrsERw9t6Pv5Nc
+4k6Pz1EaDicBMpdpxKduSZu5OANqUq8er4GM95omAGIOPOh+Nx0spthYA2BqGz+l
+6HRkPJ7S236FZz73In/KVuLnwI8JJ2CbuJap8kvheCCZpmAWpb/cPx/3Vr/J6I17
+XcW+ML9FoCI6AOvOzwIDAQAB
+-----END PUBLIC KEY-----`;

package/app/open-sse/shared/qoder/cosy.js

@@ -0,0 +1,175 @@
+/**
+ * Qoder COSY (hybrid RSA+AES+MD5) signing, ported from CLIProxyAPIPlus
+ * qoder-provider branch (internal/auth/qoder/cosy.go).
+ *
+ * Every signed request carries:
+ *   - an AES-128-CBC payload of the user info, the AES key wrapped in RSA
+ *   - an MD5 signature over `payload || cosyKey || timestamp || body || sigPath`
+ *   - the body's MD5 hash + length so the server can validate integrity
+ *   - 17 Cosy-* / X-* headers fingerprinting the client (machine id, IDE
+ *     version, organization id, etc.)
+ *
+ * The on-the-wire header keys use the same casing as qodercli:
+ *   Cosy-Machineid, not Cosy-MachineID.
+ */
+
+import crypto from "crypto";
+import { v4 as uuidv4 } from "uuid";
+
+import {
+  QODER_CLIENT_TYPE,
+  QODER_DATA_POLICY,
+  QODER_IDE_VERSION,
+  QODER_LOGIN_VERSION,
+  QODER_MACHINE_OS,
+  QODER_MACHINE_TYPE,
+  QODER_RSA_PUBLIC_KEY,
+} from "./constants.js";
+
+// AES-128 wants a 16-byte key. Match qodercli/Veria: take the first 16 chars
+// of a fresh UUID's canonical string (hyphens included). The key is fresh
+// per request so even though the IV reuses the key bytes, each request still
+// has a unique IV.
+function generateAesKey() {
+  return uuidv4().slice(0, 16);
+}
+
+function pkcs7Pad(data, blockSize) {
+  const padding = blockSize - (data.length % blockSize);
+  const padded = Buffer.alloc(data.length + padding, padding);
+  data.copy(padded, 0);
+  return padded;
+}
+
+function aesEncryptCbcBase64(plaintext, keyStr) {
+  const keyBytes = Buffer.from(keyStr, "utf8");
+  if (keyBytes.length !== 16) {
+    throw new Error(`aes key must be 16 bytes, got ${keyBytes.length}`);
+  }
+  const iv = keyBytes.subarray(0, 16);
+  const cipher = crypto.createCipheriv("aes-128-cbc", keyBytes, iv);
+  cipher.setAutoPadding(false);
+  const padded = pkcs7Pad(Buffer.from(plaintext, "utf8"), 16);
+  const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
+  return encrypted.toString("base64");
+}
+
+function rsaEncryptBase64(data) {
+  const encrypted = crypto.publicEncrypt(
+    { key: QODER_RSA_PUBLIC_KEY, padding: crypto.constants.RSA_PKCS1_PADDING },
+    Buffer.from(data, "utf8"),
+  );
+  return encrypted.toString("base64");
+}
+
+function encryptUserInfo(userInfo) {
+  const aesKey = generateAesKey();
+  const plaintext = JSON.stringify(userInfo);
+  const infoB64 = aesEncryptCbcBase64(plaintext, aesKey);
+  const cosyKeyB64 = rsaEncryptBase64(aesKey);
+  return { cosyKey: cosyKeyB64, info: infoB64 };
+}
+
+function md5Hex(input) {
+  return crypto.createHash("md5").update(input).digest("hex");
+}
+
+/**
+ * Strip the leading "/algo" prefix from the request path. Matches qodercli
+ * convention. Empty input returns "".
+ */
+function computeSigPath(requestUrl) {
+  let pathname;
+  try {
+    pathname = new URL(requestUrl).pathname || "";
+  } catch {
+    return "";
+  }
+  if (pathname.startsWith("/algo")) {
+    return pathname.slice("/algo".length);
+  }
+  return pathname;
+}
+
+/**
+ * Generate a fresh machine UUID. Persisted on the connection record so
+ * every request from the same auth carries the same machineId.
+ */
+export function generateMachineId() {
+  return uuidv4();
+}
+
+/**
+ * Build the full Cosy-* header set for a single Qoder request.
+ *
+ * @param {Buffer|Uint8Array|string} body  The exact bytes that will be sent.
+ *   For GET requests pass an empty Buffer / "".
+ * @param {string} requestUrl              Full request URL (used for sigPath).
+ * @param {object} creds
+ * @param {string} creds.userId            Stable Qoder user id.
+ * @param {string} creds.authToken         Device access token (`dt-...`).
+ * @param {string} [creds.name]            Display name (optional).
+ * @param {string} [creds.email]           Email (optional, can be empty).
+ * @param {string} [creds.machineId]       Persisted machine UUID.
+ * @returns {Record<string, string>} Header map ready to merge onto fetch().
+ */
+export function buildCosyHeaders(body, requestUrl, creds) {
+  if (!creds?.userId) throw new Error("cosy: user id is empty");
+  if (!creds?.authToken) throw new Error("cosy: auth token is empty");
+
+  const bodyBuf = Buffer.isBuffer(body)
+    ? body
+    : typeof body === "string"
+      ? Buffer.from(body, "latin1")
+      : Buffer.from(body || []);
+
+  const { cosyKey, info } = encryptUserInfo({
+    uid: creds.userId,
+    security_oauth_token: creds.authToken,
+    name: creds.name || "",
+    aid: "",
+    email: creds.email || "",
+  });
+
+  const timestamp = String(Math.floor(Date.now() / 1000));
+  const requestId = uuidv4();
+
+  const payloadJson = JSON.stringify({
+    version: "v1",
+    requestId,
+    info,
+    cosyVersion: QODER_IDE_VERSION,
+    ideVersion: "",
+  });
+  const payloadB64 = Buffer.from(payloadJson, "utf8").toString("base64");
+
+  const sigPath = computeSigPath(requestUrl);
+  const sigInput = `${payloadB64}\n${cosyKey}\n${timestamp}\n${bodyBuf.toString("latin1")}\n${sigPath}`;
+  const sig = md5Hex(Buffer.from(sigInput, "latin1"));
+
+  const machineId = creds.machineId || generateMachineId();
+  const bodyHash = md5Hex(bodyBuf);
+  const bodyLength = String(bodyBuf.length);
+
+  return {
+    Authorization: `Bearer COSY.${payloadB64}.${sig}`,
+    "Cosy-Key": cosyKey,
+    "Cosy-User": creds.userId,
+    "Cosy-Date": timestamp,
+    "Cosy-Version": QODER_IDE_VERSION,
+    "Cosy-Machineid": machineId,
+    "Cosy-Machinetoken": machineId,
+    "Cosy-Machinetype": QODER_MACHINE_TYPE,
+    "Cosy-Machineos": QODER_MACHINE_OS,
+    "Cosy-Clienttype": QODER_CLIENT_TYPE,
+    "Cosy-Clientip": "127.0.0.1",
+    "Cosy-Bodyhash": bodyHash,
+    "Cosy-Bodylength": bodyLength,
+    "Cosy-Sigpath": sigPath,
+    "Cosy-Data-Policy": QODER_DATA_POLICY,
+    "Cosy-Organization-Id": "",
+    "Cosy-Organization-Tags": "",
+    "Login-Version": QODER_LOGIN_VERSION,
+    "X-Request-Id": uuidv4(),
+  };
+}

package/app/open-sse/shared/qoder/encoding.js

@@ -0,0 +1,55 @@
+/**
+ * Qoder body encoding ported from qoder2api's QoderEncoding.java (via the
+ * CLIProxyAPIPlus qoder-provider branch).
+ *
+ * Algorithm:
+ *   1. base64-encode the plaintext bytes (standard alphabet).
+ *   2. Rearrange: split into thirds, reorder as [tail][mid][head].
+ *   3. Substitute each character via a custom alphabet mapping.
+ *
+ * The encoded body must be sent with `&Encode=1` appended to the URL so the
+ * server decodes in reverse. The obfuscation prevents Alibaba Cloud WAF from
+ * pattern-matching the plaintext request body.
+ */
+
+const QODER_STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const QODER_CUSTOM_ALPHABET = "_doRTgHZBKcGVjlvpC,@aFSx#DPuNJme&i*MzLOEn)sUrthbf%Y^w.(kIQyXqWA!";
+
+const QODER_S2C = (() => {
+  const table = new Int16Array(128).fill(-1);
+  for (let i = 0; i < 64; i++) {
+    table[QODER_STD_ALPHABET.charCodeAt(i)] = QODER_CUSTOM_ALPHABET.charCodeAt(i);
+  }
+  table["=".charCodeAt(0)] = "$".charCodeAt(0);
+  return table;
+})();
+
+/**
+ * Encode plaintext bytes/string using Qoder's WAF-bypass scheme.
+ * @param {Buffer|Uint8Array|string} plaintext
+ * @returns {string} encoded string
+ */
+export function qoderEncodeBody(plaintext) {
+  const buf = Buffer.isBuffer(plaintext)
+    ? plaintext
+    : typeof plaintext === "string"
+      ? Buffer.from(plaintext, "utf8")
+      : Buffer.from(plaintext);
+
+  const std = buf.toString("base64");
+  const n = std.length;
+  const a = Math.floor(n / 3);
+  // [tail][mid][head]
+  const rearranged = std.slice(n - a) + std.slice(a, n - a) + std.slice(0, a);
+
+  const out = Buffer.alloc(n);
+  for (let i = 0; i < n; i++) {
+    const c = rearranged.charCodeAt(i);
+    if (c < 128 && QODER_S2C[c] >= 0) {
+      out[i] = QODER_S2C[c];
+    } else {
+      out[i] = c;
+    }
+  }
+  return out.toString("latin1");
+}

package/app/open-sse/translator/concerns/chunk.js

@@ -0,0 +1,11 @@
+// Build OpenAI chat.completion.chunk. Caller supplies id/created/model so each
+// translator keeps its exact id-generation + created semantics (no Date.now here).
+export function buildChunk({ id, created, model }, delta, finishReason = null) {
+  return {
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  };
+}

package/app/open-sse/translator/concerns/finishReason.js

@@ -0,0 +1,63 @@
+// Concern #6: finish_reason / stop_reason mapping.
+// One entry per direction; switch by special format, default handles common providers.
+import { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "../schema/finishReasons.js";
+
+// upstream finish/stop reason → OpenAI finish_reason
+export function toOpenAIFinish(reason, format) {
+  switch (format) {
+    case "claude":
+      switch (reason) {
+        case CLAUDE_STOP.END_TURN: return OPENAI_FINISH.STOP;
+        case CLAUDE_STOP.MAX_TOKENS: return OPENAI_FINISH.LENGTH;
+        case CLAUDE_STOP.TOOL_USE: return OPENAI_FINISH.TOOL_CALLS;
+        case CLAUDE_STOP.STOP_SEQUENCE: return OPENAI_FINISH.STOP;
+        default: return OPENAI_FINISH.STOP;
+      }
+    case "commandcode":
+      switch (reason) {
+        case "stop": return OPENAI_FINISH.STOP;
+        case "length": return OPENAI_FINISH.LENGTH;
+        case "tool-calls":
+        case "tool_use": return OPENAI_FINISH.TOOL_CALLS;
+        case "content-filter": return OPENAI_FINISH.CONTENT_FILTER;
+        case "error": return OPENAI_FINISH.STOP;
+        default: return reason || OPENAI_FINISH.STOP;
+      }
+    case "gemini":
+      switch (String(reason).toUpperCase()) {
+        case GEMINI_FINISH.STOP: return OPENAI_FINISH.STOP;
+        case GEMINI_FINISH.MAX_TOKENS: return OPENAI_FINISH.LENGTH;
+        case GEMINI_FINISH.SAFETY:
+        case GEMINI_FINISH.RECITATION:
+        case GEMINI_FINISH.BLOCKLIST:
+        case GEMINI_FINISH.PROHIBITED_CONTENT: return OPENAI_FINISH.CONTENT_FILTER;
+        default: return OPENAI_FINISH.STOP;
+      }
+    case "kiro":
+    case "ollama":
+      switch (reason) {
+        case "tool_calls":
+        case "tool_use": return OPENAI_FINISH.TOOL_CALLS;
+        case "length":
+        case "max_tokens": return OPENAI_FINISH.LENGTH;
+        default: return OPENAI_FINISH.STOP;
+      }
+    default:
+      return reason || OPENAI_FINISH.STOP;
+  }
+}
+
+// OpenAI finish_reason → upstream stop reason
+export function fromOpenAIFinish(reason, format) {
+  switch (format) {
+    case "claude":
+      switch (reason) {
+        case OPENAI_FINISH.STOP: return CLAUDE_STOP.END_TURN;
+        case OPENAI_FINISH.LENGTH: return CLAUDE_STOP.MAX_TOKENS;
+        case OPENAI_FINISH.TOOL_CALLS: return CLAUDE_STOP.TOOL_USE;
+        default: return CLAUDE_STOP.END_TURN;
+      }
+    default:
+      return reason;
+  }
+}

package/app/open-sse/translator/concerns/image.js

@@ -0,0 +1,124 @@
+// Build a base64 data URI from mime + base64 payload
+export function encodeDataUri(mimeType, base64) {
+  return `data:${mimeType};base64,${base64}`;
+}
+
+// Parse a base64 data URI → { mimeType, base64 }, or null if not a data URI.
+// [\s\S] tolerates newlines inside the base64 payload.
+const DATA_URI_RE = /^data:([^;]+);base64,([\s\S]+)$/;
+export function parseDataUri(url) {
+  if (typeof url !== "string") return null;
+  const m = url.match(DATA_URI_RE);
+  return m ? { mimeType: m[1], base64: m[2] } : null;
+}
+
+import { lookup } from "node:dns/promises";
+import { Agent } from "undici";
+import { MAX_IMAGE_BYTES, FETCH_TIMEOUT_MS, IMAGE_SIGNATURES, BLOCKED_HOSTS } from "../../config/mediaConfig.js";
+
+// True if an IPv4/IPv6 address is private/reserved (SSRF target).
+function isPrivateIp(ip) {
+  if (!ip) return true;
+  // IPv6 loopback / unique-local / link-local
+  if (ip === "::1" || ip.startsWith("fc") || ip.startsWith("fd") || ip.startsWith("fe80")) return true;
+  // IPv4-mapped IPv6 (::ffff:a.b.c.d) -> extract tail
+  const v4 = ip.includes(".") ? ip.split(":").pop() : ip;
+  const parts = v4.split(".").map((n) => Number.parseInt(n, 10));
+  if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) return ip.includes(":") ? false : true;
+  const [a, b] = parts;
+  if (a === 10 || a === 127 || a === 0) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  if (a === 169 && b === 254) return true; // link-local + cloud metadata
+  if (a === 100 && b >= 64 && b <= 127) return true; // CGNAT
+  return false;
+}
+
+// Resolve host once and return only public IPs (SSRF guard).
+// Rejects if any resolved record is private/reserved (defeats multi-A tricks).
+async function resolvePinnedIps(hostname) {
+  if (!hostname || BLOCKED_HOSTS.has(hostname.toLowerCase())) return null;
+  try {
+    const records = await lookup(hostname, { all: true });
+    if (!records.length || records.some((r) => isPrivateIp(r.address))) return null;
+    return records;
+  } catch {
+    return null;
+  }
+}
+
+// Verify buffer magic bytes match a known image signature; return its mime or null.
+function detectImageMime(buf) {
+  for (const { sig, offset, mime, verifyWebp } of IMAGE_SIGNATURES) {
+    if (buf.length < offset + sig.length) continue;
+    let match = true;
+    for (let i = 0; i < sig.length; i++) {
+      if (buf[offset + i] !== sig[i]) { match = false; break; }
+    }
+    if (!match) continue;
+    // WEBP: RIFF....WEBP — bytes 8..11 must be "WEBP".
+    if (verifyWebp && !(buf.length >= 12 && buf[8] === 0x57 && buf[9] === 0x45 && buf[10] === 0x42 && buf[11] === 0x50)) continue;
+    return mime;
+  }
+  return null;
+}
+
+/**
+ * Fetch a remote image URL and return it as a base64 data URI.
+ * Hardened against SSRF (private/metadata IPs), memory DoS (size cap),
+ * and disguised non-image payloads (magic-byte verification).
+ * Returns null on any failure or rejection.
+ *
+ * @param {string} imageUrl - HTTP(S) URL of the image
+ * @param {object} options - { signal, timeoutMs, maxBytes }
+ * @returns {Promise<{url: string, mimeType: string}|null>}
+ */
+export async function fetchImageAsBase64(imageUrl, options = {}) {
+  const { signal, timeoutMs = FETCH_TIMEOUT_MS, maxBytes = MAX_IMAGE_BYTES } = options;
+  if (!imageUrl || (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://"))) {
+    return null;
+  }
+
+  let url;
+  try { url = new URL(imageUrl); } catch { return null; }
+  const pinnedIps = await resolvePinnedIps(url.hostname);
+  if (!pinnedIps) return null;
+
+  const controller = new AbortController();
+  const timeout = signal ? null : setTimeout(() => controller.abort(), timeoutMs);
+  const fetchSignal = signal || controller.signal;
+
+  // Pin connect to the validated IP so no second DNS resolution can rebind (TOCTOU fix).
+  const dispatcher = new Agent({
+    connect: { lookup: (_h, _o, cb) => cb(null, [{ address: pinnedIps[0].address, family: pinnedIps[0].family }]) },
+  });
+
+  try {
+    // redirect:"manual" prevents a public URL redirecting to a private one (SSRF bypass).
+    const response = await fetch(imageUrl, { signal: fetchSignal, redirect: "manual", dispatcher });
+    if (!response.ok || !response.body) return null;
+
+    // Stream-read with a hard byte cap to avoid loading huge payloads into memory.
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > maxBytes) { try { await reader.cancel(); } catch { /* ignore */ } return null; }
+      chunks.push(value);
+    }
+
+    const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+    const mimeType = detectImageMime(buf);
+    if (!mimeType) return null; // not a recognized image — reject disguised payloads
+
+    return { url: `data:${mimeType};base64,${buf.toString("base64")}`, mimeType };
+  } catch {
+    return null;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    dispatcher.close().catch(() => {});
+  }
+}

package/app/open-sse/translator/concerns/json.js

@@ -0,0 +1,5 @@
+// Safe JSON.parse: non-string passthrough; on parse error return caller-chosen `fallback`.
+export function safeParseJSON(str, fallback) {
+  if (typeof str !== "string") return str;
+  try { return JSON.parse(str); } catch { return fallback; }
+}

package/app/open-sse/translator/concerns/message.js

@@ -0,0 +1,7 @@
+import { OPENAI_BLOCK } from "../schema/index.js";
+
+// Collapse an OpenAI content-part array: a lone text part becomes a plain string,
+// otherwise the array is returned as-is. Matches existing translator behavior.
+export function collapseTextParts(parts) {
+  return parts.length === 1 && parts[0].type === OPENAI_BLOCK.TEXT ? parts[0].text : parts;
+}