@fudrouter/fsrouter 0.6.59 → 0.6.60

package/open-sse/executors/qwen-web.js

@@ -1,372 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { makeExecutorErrorResult as makeErrorResult } from "../utils/error.js";
-import { prepareToolMessages, buildToolAwareResult } from "../translator/webTools.ts";
-import { buildQwenCookieHeader, extractQwenToken } from '../../dist/lib/providers/webCookieAuth.js';
-const BASE_URL = "https://chat.qwen.ai";
-const CHATS_NEW_URL = `${BASE_URL}/api/v2/chats/new`;
-const CHAT_COMPLETIONS_URL = `${BASE_URL}/api/v2/chat/completions`;
-const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
-const BX_VERSION = "2.5.36";
-const BX_UMIDTOKEN_FALLBACK = "T2gA0000000000000000000000000000000000000000";
-const QWEN_SPA_VERSION = "0.2.66";
-const MODEL_ALIASES = {
-  // Legacy OmniRoute ids → current upstream catalog (GET /api/models).
-  "qwen-plus": "qwen3.7-plus",
-  "qwen-max": "qwen3.7-max",
-  "qwen-turbo": "qwen3.6-plus",
-  "qwen3-plus": "qwen3.7-plus",
-  "qwen3-max": "qwen3.7-max",
-  "qwen3-flash": "qwen3.6-plus",
-  // Note: `qwen3-coder-plus` is a real upstream model id (Qwen3-Coder) and
-  // must NOT be aliased — the previous `"qwen3-coder-plus": "qwen3.7-max"`
-  // entry silently rewrote valid coder requests to the wrong model.
-  "qwen3-coder-flash": "qwen3.6-plus",
-  qwen: "qwen3.7-max",
-  qwen3: "qwen3.7-max"
-};
-const DEFAULT_MODEL = "qwen3.7-max";
-function mapModel(modelId) {
-  return MODEL_ALIASES[modelId] || modelId;
-}
-function uuid() {
-  return crypto.randomUUID();
-}
-function isWafResponse(status, contentType, bodyText) {
-  if (contentType.includes("text/html")) return true;
-  if (status === 504) return true;
-  return /aliyun_waf|baxia|<html/i.test(bodyText);
-}
-const WAF_ERROR_MESSAGE = "Qwen session expired or blocked by Alibaba's WAF. Re-login at https://chat.qwen.ai and paste a fresh full Cookie header (must include cna, ssxmod_itna and token) \u2014 a bearer token alone is no longer accepted by the v2 endpoint.";
-class QwenWebExecutor extends BaseExecutor {
-  constructor() {
-    super("qwen-web", { id: "qwen-web", baseUrl: BASE_URL });
-  }
-  buildHeaders(token, cookieHeader, chatId) {
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "*/*",
-      "User-Agent": USER_AGENT,
-      Origin: BASE_URL,
-      Referer: chatId ? `${BASE_URL}/c/${chatId}` : `${BASE_URL}/`,
-      source: "web",
-      version: QWEN_SPA_VERSION,
-      "x-request-id": uuid(),
-      "bx-v": BX_VERSION,
-      "bx-umidtoken": BX_UMIDTOKEN_FALLBACK
-    };
-    if (token) headers["Authorization"] = `Bearer ${token}`;
-    if (cookieHeader) headers["Cookie"] = cookieHeader;
-    return headers;
-  }
-  async execute(input) {
-    const { body, credentials, signal, stream: wantStream } = input;
-    const bodyObj = body || {};
-    const rawCred = String(credentials?.apiKey ?? "").trim();
-    const cookieHeader = buildQwenCookieHeader(rawCred);
-    let token = extractQwenToken(rawCred);
-    if (!token && credentials?.accessToken) token = String(credentials.accessToken).trim();
-    const messages = bodyObj.messages || [];
-    const requestedModel = bodyObj.model || DEFAULT_MODEL;
-    const modelId = mapModel(requestedModel);
-    const { hasTools, requestedTools, effectiveMessages } = prepareToolMessages(bodyObj, messages);
-    const prompt = this.foldMessages(effectiveMessages);
-    let chatId;
-    try {
-      const newChatRes = await fetch(CHATS_NEW_URL, {
-        method: "POST",
-        headers: this.buildHeaders(token, cookieHeader),
-        body: JSON.stringify({
-          title: "New Chat",
-          models: [modelId],
-          chat_mode: "normal",
-          chat_type: "t2t",
-          timestamp: Date.now()
-        }),
-        signal
-      });
-      const ct2 = newChatRes.headers.get("content-type") || "";
-      if (!newChatRes.ok || ct2.includes("text/html")) {
-        const text = await newChatRes.text().catch(() => "");
-        if (isWafResponse(newChatRes.status, ct2, text)) {
-          return makeErrorResult(401, WAF_ERROR_MESSAGE, body, CHATS_NEW_URL);
-        }
-        return makeErrorResult(
-          newChatRes.status || 502,
-          `Qwen create-chat failed: ${text.slice(0, 300)}`,
-          body,
-          CHATS_NEW_URL
-        );
-      }
-      const data = await newChatRes.json();
-      chatId = data?.data?.id ?? "";
-      if (!chatId) {
-        return makeErrorResult(502, "Qwen create-chat returned no chat id", body, CHATS_NEW_URL);
-      }
-    } catch (err) {
-      return makeErrorResult(
-        502,
-        `Qwen create-chat error: ${err instanceof Error ? err.message : "unknown"}`,
-        body,
-        CHATS_NEW_URL
-      );
-    }
-    const completionUrl = `${CHAT_COMPLETIONS_URL}?chat_id=${chatId}`;
-    const msgPayload = this.buildMessagePayload(chatId, modelId, prompt, requestedModel);
-    let upstream;
-    try {
-      upstream = await fetch(completionUrl, {
-        method: "POST",
-        headers: this.buildHeaders(token, cookieHeader, chatId),
-        body: JSON.stringify(msgPayload),
-        signal
-      });
-    } catch (err) {
-      return makeErrorResult(
-        502,
-        `Qwen completion fetch failed: ${err instanceof Error ? err.message : "unknown"}`,
-        body,
-        completionUrl
-      );
-    }
-    const ct = upstream.headers.get("content-type") || "";
-    if (!upstream.ok || ct.includes("text/html")) {
-      const errText = await upstream.text().catch(() => "");
-      if (isWafResponse(upstream.status, ct, errText)) {
-        return makeErrorResult(401, WAF_ERROR_MESSAGE, body, completionUrl);
-      }
-      return makeErrorResult(
-        upstream.status || 502,
-        `Qwen error: ${errText.slice(0, 300)}`,
-        body,
-        completionUrl
-      );
-    }
-    if (!wantStream) {
-      const { content } = await this.collectStream(upstream);
-      const finalText = content;
-      if (hasTools) {
-        const {
-          content: toolContent,
-          toolCalls,
-          finishReason
-        } = buildToolAwareResult(finalText, requestedTools, "qwen");
-        const message = { role: "assistant", content: toolContent };
-        if (toolCalls) {
-          message.tool_calls = toolCalls;
-          message.content = null;
-        }
-        return this.jsonResponse(modelId, message, finishReason, completionUrl, msgPayload);
-      }
-      return this.jsonResponse(
-        modelId,
-        { role: "assistant", content: finalText },
-        "stop",
-        completionUrl,
-        msgPayload
-      );
-    }
-    const stream = this.buildClientStream(upstream, modelId, hasTools, requestedTools, signal);
-    return {
-      response: new Response(stream, {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      }),
-      url: completionUrl,
-      headers: this.buildHeaders(token, cookieHeader, chatId),
-      transformedBody: msgPayload
-    };
-  }
-  foldMessages(messages) {
-    let systemContent = "";
-    let userContent = "";
-    for (const m of messages) {
-      const text = String(m.content ?? "");
-      if (m.role === "system") {
-        systemContent += (systemContent ? "\n\n" : "") + text;
-      } else if (m.role === "user") {
-        userContent = text;
-      }
-    }
-    return systemContent ? `${systemContent}
-
-User: ${userContent}` : userContent;
-  }
-  buildMessagePayload(chatId, modelId, prompt, requestedModel) {
-    const fid = uuid();
-    const enableThinking = /think|reason|r1/i.test(requestedModel);
-    const featureConfig = {
-      thinking_enabled: enableThinking,
-      output_schema: "phase",
-      auto_thinking: enableThinking,
-      research_mode: "normal",
-      auto_search: false
-    };
-    return {
-      stream: true,
-      incremental_output: true,
-      chat_id: chatId,
-      chat_mode: "normal",
-      model: modelId,
-      parent_id: null,
-      messages: [
-        {
-          fid,
-          parentId: null,
-          childrenIds: [],
-          role: "user",
-          content: prompt,
-          user_action: "chat",
-          files: [],
-          timestamp: Math.floor(Date.now() / 1e3),
-          models: [modelId],
-          chat_type: "t2t",
-          feature_config: featureConfig,
-          sub_chat_type: "t2t",
-          parent_id: null
-        }
-      ]
-    };
-  }
-  /** Read the whole upstream SSE stream, returning the joined answer + reasoning. */
-  async collectStream(upstream) {
-    const reader = upstream.body?.getReader();
-    const decoder = new TextDecoder();
-    let content = "";
-    let reasoning = "";
-    if (!reader) return { content, reasoning };
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const delta = parseSseDelta(line);
-          if (!delta) continue;
-          if (delta.kind === "answer") content += delta.text;
-          else if (delta.kind === "think") reasoning += delta.text;
-        }
-      }
-    } catch {
-    }
-    return { content, reasoning };
-  }
-  /** Transform the Qwen phase SSE into OpenAI chat.completion.chunk SSE. */
-  buildClientStream(upstream, modelId, hasTools, requestedTools, signal) {
-    const encoder = new TextEncoder();
-    const decoder = new TextDecoder();
-    const id = `chatcmpl-qwen-${Date.now()}`;
-    const created = Math.floor(Date.now() / 1e3);
-    const emitChunk = (delta, finishReason) => `data: ${JSON.stringify({
-      id,
-      object: "chat.completion.chunk",
-      created,
-      model: modelId,
-      choices: [{ index: 0, delta, finish_reason: finishReason }]
-    })}
-
-`;
-    return new ReadableStream({
-      async start(controller) {
-        const reader = upstream.body?.getReader();
-        if (!reader) {
-          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-          controller.close();
-          return;
-        }
-        let buffer = "";
-        let fullContent = "";
-        controller.enqueue(encoder.encode(emitChunk({ role: "assistant", content: "" }, null)));
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-              const delta = parseSseDelta(line);
-              if (!delta || !delta.text) continue;
-              if (delta.kind === "answer") {
-                fullContent += delta.text;
-                if (!hasTools) {
-                  controller.enqueue(encoder.encode(emitChunk({ content: delta.text }, null)));
-                }
-              } else if (delta.kind === "think" && !hasTools) {
-                controller.enqueue(
-                  encoder.encode(emitChunk({ reasoning_content: delta.text }, null))
-                );
-              }
-            }
-          }
-        } catch (err) {
-          if (!signal?.aborted) {
-            controller.error(err);
-            return;
-          }
-        }
-        if (hasTools) {
-          const { content, toolCalls, finishReason } = buildToolAwareResult(
-            fullContent,
-            requestedTools,
-            "qwen"
-          );
-          const delta = toolCalls ? { role: "assistant", content: null, tool_calls: toolCalls } : { role: "assistant", content };
-          controller.enqueue(encoder.encode(emitChunk(delta, null)));
-          controller.enqueue(encoder.encode(emitChunk({}, finishReason)));
-        } else {
-          controller.enqueue(encoder.encode(emitChunk({}, "stop")));
-        }
-        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-        controller.close();
-      }
-    });
-  }
-  jsonResponse(modelId, message, finishReason, url, transformedBody) {
-    return {
-      response: new Response(
-        JSON.stringify({
-          id: `chatcmpl-qwen-${Date.now()}`,
-          object: "chat.completion",
-          created: Math.floor(Date.now() / 1e3),
-          model: modelId,
-          choices: [{ index: 0, message, finish_reason: finishReason }]
-        }),
-        { headers: { "Content-Type": "application/json" } }
-      ),
-      url,
-      headers: {},
-      transformedBody
-    };
-  }
-}
-function parseSseDelta(line) {
-  if (!line.startsWith("data:")) return null;
-  const payload = line.slice(5).trim();
-  if (!payload || payload === "[DONE]") return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(payload);
-  } catch {
-    return null;
-  }
-  const delta = parsed?.choices?.[0]?.delta;
-  if (!delta) return null;
-  const phase = delta.phase;
-  const content = typeof delta.content === "string" ? delta.content : "";
-  if (phase === "think" || phase === "thinking_summary") {
-    return { kind: "think", text: content };
-  }
-  if (phase === "answer" || phase === null || phase === void 0) {
-    return { kind: "answer", text: content };
-  }
-  return null;
-}
-export {
-  QwenWebExecutor
-};

package/open-sse/executors/qwen.js

@@ -1,129 +0,0 @@
-import { DefaultExecutor } from "./default.js";
-import { PROVIDERS } from "../config/providers.js";
-import { OAUTH_ENDPOINTS } from "../config/appConstants.js";
-
-/** portal.qwen.ai — static fingerprint matching stable Qwen Code release */
-const QWEN_USER_AGENT = "QwenCode/0.12.3 (linux; x64)";
-const QWEN_STAINLESS = {
-  os: "Linux",
-  arch: "x64",
-  lang: "js",
-  runtime: "node",
-  runtimeVersion: "v18.19.1",
-  packageVersion: "5.11.0",
-  retryCount: "1"
-};
-const QWEN_DEFAULT_SYSTEM_MESSAGE = {
-  role: "system",
-  content: [{ type: "text", text: "", cache_control: { type: "ephemeral" } }]
-};
-
-function ensureQwenSystemMessage(body) {
-  if (!body || typeof body !== "object") return body;
-  const next = { ...body };
-  if (Array.isArray(next.messages)) {
-    next.messages = [QWEN_DEFAULT_SYSTEM_MESSAGE, ...next.messages];
-  } else {
-    next.messages = [QWEN_DEFAULT_SYSTEM_MESSAGE];
-  }
-  return next;
-}
-
-function isQwenThinkingActive(body) {
-  const thinking = body?.thinking;
-  if (thinking === true || body?.enable_thinking === true) return true;
-  return typeof thinking === "object" && thinking !== null && !Array.isArray(thinking) && thinking.type === "enabled";
-}
-
-// Qwen rejects tool_choice="required" or object forms when thinking is active; neutralize to "auto".
-function sanitizeQwenThinkingToolChoice(body) {
-  if (!isQwenThinkingActive(body)) return body;
-  const tc = body.tool_choice;
-  const incompatible = tc === "required" || (typeof tc === "object" && tc !== null);
-  if (!incompatible) return body;
-  return { ...body, tool_choice: "auto" };
-}
-
-function buildQwenUpstreamHeaders(credentials, stream = true) {
-  const token = credentials?.apiKey || credentials?.accessToken || "";
-  const headers = {
-    "Content-Type": "application/json",
-    Authorization: `Bearer ${token}`,
-    "User-Agent": QWEN_USER_AGENT,
-    "X-DashScope-AuthType": "qwen-oauth",
-    "X-DashScope-CacheControl": "enable",
-    "X-DashScope-UserAgent": QWEN_USER_AGENT,
-    "X-Stainless-Arch": QWEN_STAINLESS.arch,
-    "X-Stainless-Lang": QWEN_STAINLESS.lang,
-    "X-Stainless-Os": QWEN_STAINLESS.os,
-    "X-Stainless-Package-Version": QWEN_STAINLESS.packageVersion,
-    "X-Stainless-Retry-Count": QWEN_STAINLESS.retryCount,
-    "X-Stainless-Runtime": QWEN_STAINLESS.runtime,
-    "X-Stainless-Runtime-Version": QWEN_STAINLESS.runtimeVersion,
-    Connection: "keep-alive",
-    "Accept-Language": "*",
-    "Sec-Fetch-Mode": "cors"
-  };
-  headers.Accept = stream ? "text/event-stream" : "application/json";
-  return headers;
-}
-
-export class QwenExecutor extends DefaultExecutor {
-  constructor() {
-    super("qwen");
-  }
-
-  // Qwen tokens are bound to a resource_url returned at OAuth time.
-  // Using portal.qwen.ai when the token is issued for another shard returns 401/403.
-  buildUrl(model, stream, urlIndex = 0, credentials = null) {
-    const resourceUrl = credentials?.providerSpecificData?.resourceUrl;
-    const host = resourceUrl ? resourceUrl.replace(/^https?:\/\//, "").replace(/\/$/, "") : "portal.qwen.ai";
-    return `https://${host}/v1/chat/completions`;
-  }
-
-  buildHeaders(credentials, stream = true) {
-    return buildQwenUpstreamHeaders(credentials, stream);
-  }
-
-  transformRequest(model, body, stream, credentials) {
-    let next = body && typeof body === "object" ? { ...body } : body;
-    if (stream && next?.messages && !next.stream_options && !next.thinking && !next.enable_thinking && next.stream !== false) {
-      next.stream_options = { include_usage: true };
-    }
-    next = sanitizeQwenThinkingToolChoice(next);
-    return ensureQwenSystemMessage(next);
-  }
-
-  // Override to capture resource_url from refresh response (required for buildUrl).
-  async refreshCredentials(credentials, log) {
-    if (!credentials?.refreshToken) return null;
-    try {
-      const response = await fetch(OAUTH_ENDPOINTS.qwen.token, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
-        body: new URLSearchParams({
-          grant_type: "refresh_token",
-          refresh_token: credentials.refreshToken,
-          client_id: PROVIDERS.qwen.clientId
-        })
-      });
-      if (!response.ok) return null;
-      const tokens = await response.json();
-      log?.info?.("TOKEN", "qwen refreshed");
-      return {
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token || credentials.refreshToken,
-        expiresIn: tokens.expires_in,
-        providerSpecificData: {
-          ...(credentials.providerSpecificData || {}),
-          ...(tokens.resource_url ? { resourceUrl: tokens.resource_url } : {})
-        }
-      };
-    } catch (error) {
-      log?.error?.("TOKEN", `qwen refresh error: ${error.message}`);
-      return null;
-    }
-  }
-}
-
-export default QwenExecutor;