Add marked package, update Qwen executor for OAuth handling, and enhance changelog styles

open-sse/executors/qwen.js

@@ -1,60 +1,68 @@
-import { platform, arch } from "os";
 import { DefaultExecutor } from "./default.js";
+import { PROVIDERS } from "../config/providers.js";
+import { OAUTH_ENDPOINTS } from "../config/appConstants.js";
 
-/** portal.qwen.ai */
-const qwenCodeVersion = "0.13.2";
-const qwenStainless = {
-  runtimeVersion: "v22.17.0",
+/** 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: "0",
-  runtime: "node"
+  retryCount: "1"
 };
-const qwenDefaultSystemMessage = {
+const QWEN_DEFAULT_SYSTEM_MESSAGE = {
   role: "system",
   content: [{ type: "text", text: "", cache_control: { type: "ephemeral" } }]
 };
 
-function qwenStainlessOsLabel() {
-  const p = platform();
-  if (p === "darwin") return "MacOS";
-  if (p === "win32") return "Windows";
-  if (p === "linux") return "Linux";
-  return p;
-}
-
-function qwenUserAgent() {
-  return `QwenCode/${qwenCodeVersion} (${platform()}; ${arch()})`;
-}
-
 function ensureQwenSystemMessage(body) {
   if (!body || typeof body !== "object") return body;
   const next = { ...body };
   if (Array.isArray(next.messages)) {
-    next.messages = [qwenDefaultSystemMessage, ...next.messages];
+    next.messages = [QWEN_DEFAULT_SYSTEM_MESSAGE, ...next.messages];
   } else {
-    next.messages = [qwenDefaultSystemMessage];
+    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 ua = qwenUserAgent();
   const headers = {
     "Content-Type": "application/json",
     Authorization: `Bearer ${token}`,
-    "User-Agent": ua,
-    "X-DashScope-UserAgent": ua,
-    "X-Stainless-Runtime-Version": qwenStainless.runtimeVersion,
-    "X-Stainless-Lang": qwenStainless.lang,
-    "X-Stainless-Arch": arch(),
-    "X-Stainless-Package-Version": qwenStainless.packageVersion,
-    "X-DashScope-CacheControl": "enable",
-    "X-Stainless-Retry-Count": qwenStainless.retryCount,
-    "X-Stainless-Os": qwenStainlessOsLabel(),
+    "User-Agent": QWEN_USER_AGENT,
     "X-DashScope-AuthType": "qwen-oauth",
-    "X-Stainless-Runtime": qwenStainless.runtime
+    "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;
@@ -65,17 +73,57 @@ export class QwenExecutor extends DefaultExecutor {
     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) {
-    const next = body && typeof body === "object" ? { ...body } : body;
+    let next = body && typeof body === "object" ? { ...body } : body;
     if (stream && next?.messages && !next.stream_options) {
       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;