@oevortex/opencode-qwen-auth 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1534 @@
+// src/constants.ts
+var QWEN_OAUTH_BASE_URL = "https://chat.qwen.ai";
+var QWEN_OAUTH_TOKEN_ENDPOINT = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/token`;
+var QWEN_OAUTH_CLIENT_ID = "f0304373b74a44d2b584a3fb70ca9e56";
+var QWEN_DIR = ".qwen";
+var QWEN_CREDENTIAL_FILENAME = "oauth_creds.json";
+var QWEN_DEFAULT_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+var QWEN_INTL_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1";
+var QWEN_PORTAL_BASE_URL = "https://portal.qwen.ai/v1";
+var TOKEN_REFRESH_BUFFER_MS = 30 * 1e3;
+var HTTP_OK = 200;
+var HTTP_UNAUTHORIZED = 401;
+var QWEN_PROVIDER_ID = "qwencode";
+var QWEN_CALLBACK_PORT = 36743;
+var QWEN_REDIRECT_URI = `http://localhost:${QWEN_CALLBACK_PORT}/oauth-callback`;
+var RATE_LIMIT_BACKOFF_BASE_MS = 1e3;
+var RATE_LIMIT_BACKOFF_MAX_MS = 60 * 60 * 1e3;
+var RATE_LIMIT_MAX_RETRIES = 5;
+var REQUEST_TIMEOUT_MS = 720 * 1e3;
+var ENV_CONSOLE_LOG = "OPENCODE_QWEN_CONSOLE_LOG";
+
+// src/plugin/auth.ts
+var ACCESS_TOKEN_EXPIRY_BUFFER_MS = 60 * 1e3;
+var PARTS_SEPARATOR = "|";
+function isOAuthAuth(auth) {
+  return auth.type === "oauth";
+}
+function parseRefreshParts(refresh) {
+  const [refreshToken = "", resourceUrl = ""] = (refresh ?? "").split(PARTS_SEPARATOR);
+  return {
+    refreshToken,
+    resourceUrl: resourceUrl || void 0
+  };
+}
+function formatRefreshParts(parts) {
+  const base = parts.refreshToken;
+  return parts.resourceUrl ? `${base}${PARTS_SEPARATOR}${parts.resourceUrl}` : base;
+}
+function accessTokenExpired(auth) {
+  if (!auth.access || typeof auth.expires !== "number") {
+    return true;
+  }
+  return auth.expires <= Date.now() + ACCESS_TOKEN_EXPIRY_BUFFER_MS;
+}
+function createAuthDetails(accessToken, refreshToken, expiresAt, resourceUrl) {
+  const parts = {
+    refreshToken,
+    resourceUrl
+  };
+  return {
+    type: "oauth",
+    access: accessToken,
+    refresh: formatRefreshParts(parts),
+    expires: expiresAt
+  };
+}
+
+// src/plugin/logger.ts
+var pluginClient = null;
+function initLogger(client) {
+  pluginClient = client;
+}
+function isConsoleLogEnabled() {
+  const value = process.env[ENV_CONSOLE_LOG];
+  return value === "1" || value === "true";
+}
+function formatMessage(prefix, message, meta) {
+  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+  return `[${prefix}] ${message}${metaStr}`;
+}
+function printQwenConsole(level, message, meta) {
+  if (!isConsoleLogEnabled()) {
+    return;
+  }
+  const formattedMessage = formatMessage("qwen-auth", message, meta);
+  switch (level) {
+    case "debug":
+      console.debug(formattedMessage);
+      break;
+    case "info":
+      console.info(formattedMessage);
+      break;
+    case "warn":
+      console.warn(formattedMessage);
+      break;
+    case "error":
+      console.error(formattedMessage);
+      break;
+  }
+}
+function createLogger(prefix) {
+  const log7 = (level, message, meta) => {
+    printQwenConsole(level, `[${prefix}] ${message}`, meta);
+    if (pluginClient?.log) {
+      const clientLog = pluginClient.log;
+      const formattedMessage = `[${prefix}] ${message}`;
+      switch (level) {
+        case "debug":
+          clientLog.debug(formattedMessage, meta);
+          break;
+        case "info":
+          clientLog.info(formattedMessage, meta);
+          break;
+        case "warn":
+          clientLog.warn(formattedMessage, meta);
+          break;
+        case "error":
+          clientLog.error(formattedMessage, meta);
+          break;
+      }
+    }
+  };
+  return {
+    debug: (message, meta) => log7("debug", message, meta),
+    info: (message, meta) => log7("info", message, meta),
+    warn: (message, meta) => log7("warn", message, meta),
+    error: (message, meta) => log7("error", message, meta)
+  };
+}
+var log = createLogger("qwen");
+
+// src/plugin/token.ts
+var log2 = createLogger("token");
+function encodeFormData(data) {
+  return Object.entries(data).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+async function refreshAccessToken(auth, client) {
+  const parts = parseRefreshParts(auth.refresh);
+  if (!parts.refreshToken) {
+    log2.error("No refresh token available for token refresh");
+    await client.tui.showToast({
+      body: {
+        message: "No refresh token available. Please re-authenticate.",
+        variant: "error"
+      }
+    });
+    return null;
+  }
+  log2.debug("Refreshing access token...");
+  try {
+    const bodyData = {
+      grant_type: "refresh_token",
+      refresh_token: parts.refreshToken,
+      client_id: QWEN_OAUTH_CLIENT_ID
+    };
+    const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+      },
+      body: encodeFormData(bodyData)
+    });
+    if (response.status !== HTTP_OK) {
+      const errorText = await response.text();
+      log2.error("Token refresh failed", {
+        status: response.status,
+        statusText: response.statusText,
+        error: errorText.slice(0, 200)
+      });
+      await client.tui.showToast({
+        body: {
+          message: `Token refresh failed: ${response.status} ${response.statusText}`,
+          variant: "error"
+        }
+      });
+      return null;
+    }
+    let tokenData;
+    try {
+      tokenData = await response.json();
+    } catch (parseError) {
+      const text = await response.text();
+      log2.error("Failed to parse token response", {
+        error: parseError instanceof Error ? parseError.message : String(parseError),
+        responsePreview: text.slice(0, 200)
+      });
+      await client.tui.showToast({
+        body: {
+          message: "Failed to parse token refresh response",
+          variant: "error"
+        }
+      });
+      return null;
+    }
+    if (tokenData.error) {
+      log2.error("Token refresh returned error", {
+        error: tokenData.error,
+        description: tokenData.error_description
+      });
+      await client.tui.showToast({
+        body: {
+          message: `Token refresh error: ${tokenData.error}`,
+          variant: "error"
+        }
+      });
+      return null;
+    }
+    const expiresAt = Date.now() + tokenData.expires_in * 1e3;
+    const newRefreshToken = tokenData.refresh_token || parts.refreshToken;
+    log2.info("Token refreshed successfully", {
+      expiresIn: tokenData.expires_in,
+      hasNewRefreshToken: !!tokenData.refresh_token
+    });
+    const updatedParts = {
+      refreshToken: newRefreshToken,
+      resourceUrl: parts.resourceUrl
+    };
+    return {
+      type: "oauth",
+      access: tokenData.access_token,
+      refresh: formatRefreshParts(updatedParts),
+      expires: expiresAt
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log2.error("Token refresh failed with exception", { error: errorMessage });
+    await client.tui.showToast({
+      body: {
+        message: `Token refresh failed: ${errorMessage}`,
+        variant: "error"
+      }
+    });
+    return null;
+  }
+}
+function needsTokenRefresh(auth) {
+  if (!auth.access || typeof auth.expires !== "number") {
+    return true;
+  }
+  return auth.expires <= Date.now() + TOKEN_REFRESH_BUFFER_MS;
+}
+async function ensureValidToken(auth, client) {
+  if (!needsTokenRefresh(auth)) {
+    return auth;
+  }
+  log2.debug("Token needs refresh, refreshing...");
+  return refreshAccessToken(auth, client);
+}
+
+// src/plugin/fetch-wrapper.ts
+var log3 = createLogger("fetch-wrapper");
+var rateLimitState = {
+  consecutive429: 0,
+  lastAt: 0
+};
+function computeExponentialBackoffMs(attempt, baseMs = RATE_LIMIT_BACKOFF_BASE_MS, maxMs = RATE_LIMIT_BACKOFF_MAX_MS) {
+  const safeAttempt = Math.max(1, Math.floor(attempt));
+  const multiplier = 2 ** (safeAttempt - 1);
+  return Math.min(maxMs, Math.max(0, Math.floor(baseMs * multiplier)));
+}
+function toUrlString(value) {
+  if (value instanceof URL) {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.url ?? value.toString();
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
+      return;
+    }
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      cleanup();
+      reject(signal?.reason instanceof Error ? signal.reason : new Error("Aborted"));
+    };
+    const cleanup = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function sleepWithBackoff(totalMs, signal) {
+  const stepsMs = [3e3, 5e3, 1e4, 2e4, 3e4];
+  let remainingMs = Math.max(0, totalMs);
+  let stepIndex = 0;
+  while (remainingMs > 0) {
+    const stepMs = stepsMs[stepIndex] ?? stepsMs[stepsMs.length - 1] ?? 3e4;
+    const waitMs = Math.min(remainingMs, stepMs);
+    await sleep(waitMs, signal);
+    remainingMs -= waitMs;
+    stepIndex++;
+  }
+}
+function formatWaitTimeMs(ms) {
+  const totalSeconds = Math.max(1, Math.ceil(ms / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
+  }
+  if (minutes > 0) {
+    return seconds > 0 ? `${minutes}m${seconds}s` : `${minutes}m`;
+  }
+  return `${seconds}s`;
+}
+function isQwenApiRequest(input) {
+  const urlString = toUrlString(input);
+  return urlString.includes("dashscope.aliyuncs.com") || urlString.includes("portal.qwen.ai") || urlString.includes("chat.qwen.ai") || urlString.includes("/v1/chat/completions") || urlString.includes("/compatible-mode/v1");
+}
+function getBaseUrl(auth) {
+  const parts = parseRefreshParts(auth.refresh);
+  let baseUrl = parts.resourceUrl || QWEN_PORTAL_BASE_URL;
+  if (!baseUrl.startsWith("http://") && !baseUrl.startsWith("https://")) {
+    baseUrl = `https://${baseUrl}`;
+  }
+  baseUrl = baseUrl.replace(/\/+$/, "");
+  if (!baseUrl.endsWith("/v1")) {
+    baseUrl = `${baseUrl}/v1`;
+  }
+  return baseUrl;
+}
+function parseRetryAfterMs(response) {
+  const retryAfterMsHeader = response.headers.get("retry-after-ms");
+  const retryAfterSecondsHeader = response.headers.get("retry-after");
+  if (retryAfterMsHeader) {
+    const parsed = parseInt(retryAfterMsHeader, 10);
+    if (!Number.isNaN(parsed) && parsed >= 0) {
+      return Math.min(parsed, RATE_LIMIT_BACKOFF_MAX_MS);
+    }
+  }
+  if (retryAfterSecondsHeader) {
+    const parsed = parseInt(retryAfterSecondsHeader, 10);
+    if (!Number.isNaN(parsed) && parsed >= 0) {
+      return Math.min(parsed * 1e3, RATE_LIMIT_BACKOFF_MAX_MS);
+    }
+  }
+  return null;
+}
+function getRateLimitDelay(serverRetryAfterMs) {
+  const now = Date.now();
+  const attempt = rateLimitState.consecutive429 + 1;
+  const backoffMs = computeExponentialBackoffMs(attempt);
+  const delayMs = serverRetryAfterMs !== null ? Math.max(serverRetryAfterMs, backoffMs) : backoffMs;
+  rateLimitState.consecutive429 = attempt;
+  rateLimitState.lastAt = now;
+  return { attempt, serverRetryAfterMs, delayMs };
+}
+function resetRateLimitState() {
+  rateLimitState.consecutive429 = 0;
+  rateLimitState.lastAt = 0;
+}
+function prepareHeaders(init, accessToken) {
+  const headers = new Headers(init?.headers);
+  headers.set("Authorization", `Bearer ${accessToken}`);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (!headers.has("Accept")) {
+    headers.set("Accept", "application/json");
+  }
+  return headers;
+}
+function transformRequestUrl(input, baseUrl) {
+  const urlString = toUrlString(input);
+  if (urlString.includes("generativelanguage.googleapis.com")) {
+    const path = urlString.split("/v1")[1] || "/chat/completions";
+    return `${baseUrl}${path}`;
+  }
+  if (urlString.startsWith("/")) {
+    return `${baseUrl}${urlString}`;
+  }
+  if (isQwenApiRequest(urlString)) {
+    return urlString;
+  }
+  if (!urlString.includes("/chat/completions")) {
+    return `${baseUrl}/chat/completions`;
+  }
+  return urlString;
+}
+function createQwenFetch(getAuth, client) {
+  return async (input, init) => {
+    const auth = await getAuth();
+    if (!isOAuthAuth(auth)) {
+      return fetch(input, init);
+    }
+    const urlString = toUrlString(input);
+    if (!isQwenApiRequest(urlString) && !urlString.includes("googleapis.com")) {
+      return fetch(input, init);
+    }
+    let currentAuth = auth;
+    if (accessTokenExpired(currentAuth)) {
+      log3.debug("Access token expired, refreshing...");
+      const refreshed = await refreshAccessToken(currentAuth, client);
+      if (!refreshed) {
+        throw new Error("Failed to refresh access token");
+      }
+      currentAuth = refreshed;
+      try {
+        await client.auth.set({
+          path: { id: QWEN_PROVIDER_ID },
+          body: {
+            type: "oauth",
+            access: refreshed.access,
+            refresh: refreshed.refresh,
+            expires: refreshed.expires
+          }
+        });
+      } catch (saveError) {
+        log3.warn("Failed to save refreshed auth", {
+          error: saveError instanceof Error ? saveError.message : String(saveError)
+        });
+      }
+    }
+    const accessToken = currentAuth.access;
+    if (!accessToken) {
+      throw new Error("No access token available");
+    }
+    const baseUrl = getBaseUrl(currentAuth);
+    const requestUrl = transformRequestUrl(input, baseUrl);
+    const headers = prepareHeaders(init, accessToken);
+    const abortSignal = init?.signal;
+    let retryCount = 0;
+    while (retryCount <= RATE_LIMIT_MAX_RETRIES) {
+      try {
+        log3.debug("Making Qwen API request", {
+          url: requestUrl,
+          method: init?.method || "GET",
+          retry: retryCount
+        });
+        const response = await fetch(requestUrl, {
+          ...init,
+          headers
+        });
+        if (response.status === HTTP_UNAUTHORIZED && retryCount === 0) {
+          log3.info("Received 401, refreshing token and retrying...");
+          const refreshed = await refreshAccessToken(currentAuth, client);
+          if (!refreshed) {
+            return response;
+          }
+          currentAuth = refreshed;
+          headers.set("Authorization", `Bearer ${refreshed.access}`);
+          try {
+            await client.auth.set({
+              path: { id: QWEN_PROVIDER_ID },
+              body: {
+                type: "oauth",
+                access: refreshed.access,
+                refresh: refreshed.refresh,
+                expires: refreshed.expires
+              }
+            });
+          } catch {
+          }
+          retryCount++;
+          continue;
+        }
+        if (response.status === 429) {
+          const serverRetryAfterMs = parseRetryAfterMs(response);
+          const { attempt, delayMs } = getRateLimitDelay(serverRetryAfterMs);
+          if (attempt > RATE_LIMIT_MAX_RETRIES) {
+            log3.warn("Max rate limit retries exceeded", { attempt });
+            return response;
+          }
+          printQwenConsole(
+            "error",
+            `Rate limited (429). Retrying after ${formatWaitTimeMs(delayMs)} (attempt ${attempt})...`
+          );
+          await client.tui.showToast({
+            body: {
+              message: `Rate limited. Retrying in ${formatWaitTimeMs(delayMs)}...`,
+              variant: "warning"
+            }
+          });
+          await sleepWithBackoff(delayMs, abortSignal);
+          retryCount++;
+          continue;
+        }
+        if (response.status >= 500 && retryCount < RATE_LIMIT_MAX_RETRIES) {
+          log3.warn("Server error, retrying...", { status: response.status });
+          const delayMs = computeExponentialBackoffMs(retryCount + 1);
+          await sleep(delayMs, abortSignal);
+          retryCount++;
+          continue;
+        }
+        if (response.ok) {
+          resetRateLimitState();
+        }
+        return response;
+      } catch (error) {
+        if (retryCount < RATE_LIMIT_MAX_RETRIES) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          log3.warn("Request failed, retrying...", { error: errorMessage, retry: retryCount });
+          const delayMs = computeExponentialBackoffMs(retryCount + 1);
+          await sleep(delayMs, abortSignal);
+          retryCount++;
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error("Max retries exceeded");
+  };
+}
+
+// src/plugin/server.ts
+import { createServer } from "http";
+var log4 = createLogger("server");
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var SUCCESS_HTML = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Authentication Complete</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    }
+    .container {
+      text-align: center;
+      padding: 40px;
+      background: white;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      max-width: 400px;
+    }
+    .checkmark {
+      width: 80px;
+      height: 80px;
+      background: #4CAF50;
+      border-radius: 50%;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      margin: 0 auto 20px;
+    }
+    .checkmark::after {
+      content: '\u2713';
+      font-size: 40px;
+      color: white;
+    }
+    h1 {
+      color: #333;
+      margin-bottom: 10px;
+    }
+    p {
+      color: #666;
+      margin: 0;
+    }
+    .close-note {
+      margin-top: 20px;
+      font-size: 14px;
+      color: #999;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="checkmark"></div>
+    <h1>Authentication Complete</h1>
+    <p>You have successfully authenticated with Qwen.</p>
+    <p class="close-note">You can close this window and return to OpenCode.</p>
+  </div>
+</body>
+</html>
+`;
+var ERROR_HTML = (message) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Authentication Failed</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f44336 0%, #d32f2f 100%);
+    }
+    .container {
+      text-align: center;
+      padding: 40px;
+      background: white;
+      border-radius: 16px;
+      box-shadow: 0 20px 60px rgba(0,0,0,0.3);
+      max-width: 400px;
+    }
+    .error-icon {
+      width: 80px;
+      height: 80px;
+      background: #f44336;
+      border-radius: 50%;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      margin: 0 auto 20px;
+    }
+    .error-icon::after {
+      content: '\u2715';
+      font-size: 40px;
+      color: white;
+    }
+    h1 {
+      color: #333;
+      margin-bottom: 10px;
+    }
+    p {
+      color: #666;
+      margin: 0;
+    }
+    .error-message {
+      background: #ffebee;
+      padding: 10px;
+      border-radius: 8px;
+      margin-top: 15px;
+      font-family: monospace;
+      font-size: 13px;
+      color: #c62828;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="error-icon"></div>
+    <h1>Authentication Failed</h1>
+    <p>There was a problem authenticating with Qwen.</p>
+    <div class="error-message">${escapeHtml(message)}</div>
+  </div>
+</body>
+</html>
+`;
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+async function startOAuthListener(port = QWEN_CALLBACK_PORT) {
+  return new Promise((resolve, reject) => {
+    let callbackResolve = null;
+    let callbackReject = null;
+    let timeoutId = null;
+    const server = createServer((req, res) => {
+      const url = new URL(req.url || "/", `http://localhost:${port}`);
+      log4.debug("Received request", { path: url.pathname, search: url.search });
+      if (url.pathname !== "/oauth-callback") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+      const error = url.searchParams.get("error");
+      if (error) {
+        const errorDescription = url.searchParams.get("error_description") || error;
+        log4.error("OAuth callback received error", { error, errorDescription });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(ERROR_HTML(errorDescription));
+        if (callbackReject) {
+          callbackReject(new Error(`OAuth error: ${errorDescription}`));
+          callbackReject = null;
+          callbackResolve = null;
+        }
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      if (!code) {
+        const message = "Missing authorization code in callback";
+        log4.error(message);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(ERROR_HTML(message));
+        if (callbackReject) {
+          callbackReject(new Error(message));
+          callbackReject = null;
+          callbackResolve = null;
+        }
+        return;
+      }
+      log4.info("OAuth callback received successfully", { hasCode: true, hasState: !!state });
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_HTML);
+      if (callbackResolve) {
+        callbackResolve(url);
+        callbackResolve = null;
+        callbackReject = null;
+      }
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    });
+    server.on("error", (err) => {
+      log4.error("Server error", { error: err.message });
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${port} is already in use. Cannot start OAuth callback server.`));
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      log4.info("OAuth callback server started", { port });
+      const listener = {
+        port,
+        waitForCallback: (timeoutMs = DEFAULT_TIMEOUT_MS) => {
+          return new Promise((resolveCallback, rejectCallback) => {
+            callbackResolve = resolveCallback;
+            callbackReject = rejectCallback;
+            timeoutId = setTimeout(() => {
+              if (callbackReject) {
+                callbackReject(new Error(`OAuth callback timeout after ${timeoutMs / 1e3} seconds`));
+                callbackReject = null;
+                callbackResolve = null;
+              }
+            }, timeoutMs);
+          });
+        },
+        close: async () => {
+          return new Promise((resolveClose, rejectClose) => {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            if (callbackReject) {
+              callbackReject(new Error("OAuth listener closed"));
+              callbackReject = null;
+              callbackResolve = null;
+            }
+            server.close((err) => {
+              if (err) {
+                log4.warn("Error closing server", { error: err.message });
+                rejectClose(err);
+              } else {
+                log4.debug("OAuth callback server closed");
+                resolveClose();
+              }
+            });
+          });
+        }
+      };
+      resolve(listener);
+    });
+  });
+}
+
+// src/plugin/browser.ts
+var log5 = createLogger("browser");
+async function openBrowser(url) {
+  log5.debug("Opening browser", { url: url.slice(0, 100) + "..." });
+  try {
+    const open = await import("open");
+    await open.default(url);
+    log5.info("Browser opened successfully");
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log5.error("Failed to open browser", { error: errorMessage });
+    throw new Error(`Failed to open browser: ${errorMessage}`);
+  }
+}
+function isHeadless() {
+  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY) {
+    return true;
+  }
+  if (process.env.OPENCODE_HEADLESS === "1" || process.env.OPENCODE_HEADLESS === "true") {
+    return true;
+  }
+  if (process.env.CI === "true" || process.env.GITHUB_ACTIONS === "true" || process.env.GITLAB_CI === "true" || process.env.JENKINS_URL || process.env.TRAVIS === "true" || process.env.CIRCLECI === "true") {
+    return true;
+  }
+  if (process.env.DOCKER_CONTAINER || process.env.container) {
+    return true;
+  }
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    return true;
+  }
+  return false;
+}
+
+// src/plugin.ts
+var log6 = createLogger("plugin");
+function generateState() {
+  const array = new Uint8Array(32);
+  crypto.getRandomValues(array);
+  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
+    ""
+  );
+}
+function generateAuthorizationUrl(state, redirectUri) {
+  const params = new URLSearchParams({
+    response_type: "code",
+    client_id: QWEN_OAUTH_CLIENT_ID,
+    redirect_uri: redirectUri,
+    state,
+    scope: "openid profile"
+  });
+  return `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/authorize?${params.toString()}`;
+}
+async function exchangeCodeForTokens(code, state, redirectUri) {
+  try {
+    const tokenUrl = `${QWEN_OAUTH_BASE_URL}/api/v1/oauth2/token`;
+    const bodyData = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      client_id: QWEN_OAUTH_CLIENT_ID,
+      redirect_uri: redirectUri,
+      state
+    });
+    const response = await fetch(tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+      },
+      body: bodyData.toString()
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      log6.error("Token exchange failed", {
+        status: response.status,
+        error: errorText.slice(0, 200)
+      });
+      return {
+        type: "failed",
+        error: `Token exchange failed: ${response.status} ${response.statusText}`
+      };
+    }
+    const tokenData = await response.json();
+    if (tokenData.error) {
+      return {
+        type: "failed",
+        error: `${tokenData.error}: ${tokenData.error_description || "Unknown error"}`
+      };
+    }
+    const expiresAt = Date.now() + tokenData.expires_in * 1e3;
+    const refreshParts = {
+      refreshToken: tokenData.refresh_token,
+      resourceUrl: QWEN_PORTAL_BASE_URL
+    };
+    return {
+      type: "success",
+      access: tokenData.access_token,
+      refresh: formatRefreshParts(refreshParts),
+      expires: expiresAt,
+      resourceUrl: QWEN_PORTAL_BASE_URL
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    log6.error("Token exchange exception", { error: errorMessage });
+    return {
+      type: "failed",
+      error: `Token exchange failed: ${errorMessage}`
+    };
+  }
+}
+async function authenticateWithOAuth(client) {
+  const headless = isHeadless();
+  const state = generateState();
+  const redirectUri = QWEN_REDIRECT_URI;
+  const authUrl = generateAuthorizationUrl(state, redirectUri);
+  let listener = null;
+  if (!headless) {
+    try {
+      listener = await startOAuthListener(QWEN_CALLBACK_PORT);
+      log6.info("OAuth callback server started", { port: listener.port });
+    } catch (error) {
+      log6.warn("Could not start callback listener", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      await client.tui.showToast({
+        body: {
+          message: "Couldn't start callback listener. Falling back to manual copy/paste.",
+          variant: "warning"
+        }
+      });
+    }
+  }
+  if (!headless) {
+    try {
+      await openBrowser(authUrl);
+      log6.info("Browser opened for authentication");
+    } catch {
+      await client.tui.showToast({
+        body: {
+          message: "Could not open browser automatically. Please copy/paste the URL.",
+          variant: "warning"
+        }
+      });
+    }
+  }
+  if (listener) {
+    await client.tui.showToast({
+      body: {
+        message: "Waiting for browser authentication...",
+        variant: "info"
+      }
+    });
+    try {
+      const callbackUrl = await listener.waitForCallback();
+      const code = callbackUrl.searchParams.get("code");
+      const returnedState = callbackUrl.searchParams.get("state");
+      if (!code) {
+        return {
+          type: "failed",
+          error: "Missing authorization code in callback"
+        };
+      }
+      if (returnedState !== state) {
+        return {
+          type: "failed",
+          error: "State mismatch - possible CSRF attack"
+        };
+      }
+      return exchangeCodeForTokens(code, state, redirectUri);
+    } catch (error) {
+      return {
+        type: "failed",
+        error: error instanceof Error ? error.message : "Unknown callback error"
+      };
+    } finally {
+      try {
+        await listener.close();
+      } catch {
+      }
+    }
+  } else {
+    console.log("\n=== Qwen OAuth Setup ===");
+    console.log(`Open this URL in your browser:
+${authUrl}
+`);
+    const readlineModule = await import("readline");
+    const rl = readlineModule.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const question = (prompt) => {
+      return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+          resolve(answer);
+        });
+      });
+    };
+    try {
+      const callbackUrlStr = await question(
+        "Paste the full redirect URL here: "
+      );
+      const callbackUrl = new URL(callbackUrlStr);
+      const code = callbackUrl.searchParams.get("code");
+      const returnedState = callbackUrl.searchParams.get("state");
+      if (!code) {
+        return {
+          type: "failed",
+          error: "Missing authorization code in callback URL"
+        };
+      }
+      if (returnedState !== state) {
+        return {
+          type: "failed",
+          error: "State mismatch - possible CSRF attack"
+        };
+      }
+      return exchangeCodeForTokens(code, state, redirectUri);
+    } catch (error) {
+      return {
+        type: "failed",
+        error: error instanceof Error ? error.message : "Failed to parse callback URL"
+      };
+    } finally {
+      rl.close();
+    }
+  }
+}
+async function QwenOAuthPlugin({
+  client
+}) {
+  initLogger(client);
+  log6.info("Qwen OAuth Plugin initialized");
+  let cachedGetAuth = null;
+  return {
+    auth: {
+      provider: QWEN_PROVIDER_ID,
+      /**
+       * Loader function called when the provider is used.
+       * Returns configuration for API calls.
+       */
+      loader: async (getAuth, provider) => {
+        cachedGetAuth = getAuth;
+        const auth = await getAuth();
+        if (!isOAuthAuth(auth)) {
+          return {};
+        }
+        log6.debug("Loading Qwen provider configuration");
+        if (provider.models) {
+          for (const model of Object.values(provider.models)) {
+            if (model) {
+              model.cost = { input: 0, output: 0 };
+            }
+          }
+        }
+        let currentAuth = auth;
+        if (accessTokenExpired(currentAuth)) {
+          log6.info("Access token expired, refreshing...");
+          const refreshed = await refreshAccessToken(currentAuth, client);
+          if (refreshed) {
+            currentAuth = refreshed;
+            try {
+              await client.auth.set({
+                path: { id: QWEN_PROVIDER_ID },
+                body: {
+                  type: "oauth",
+                  access: refreshed.access,
+                  refresh: refreshed.refresh,
+                  expires: refreshed.expires
+                }
+              });
+            } catch (error) {
+              log6.warn("Failed to save refreshed auth", {
+                error: error instanceof Error ? error.message : String(error)
+              });
+            }
+          }
+        }
+        const parts = parseRefreshParts(currentAuth.refresh);
+        let baseUrl = parts.resourceUrl || QWEN_PORTAL_BASE_URL;
+        if (!baseUrl.endsWith("/v1")) {
+          baseUrl = baseUrl.replace(/\/+$/, "") + "/v1";
+        }
+        const qwenFetch = createQwenFetch(getAuth, client);
+        return {
+          apiKey: "",
+          // Empty - using OAuth
+          baseUrl,
+          fetch: qwenFetch
+        };
+      },
+      /**
+       * Authentication methods available to the user.
+       */
+      methods: [
+        {
+          label: "OAuth with Qwen (Alibaba Cloud)",
+          type: "oauth",
+          authorize: async () => {
+            const result = await authenticateWithOAuth(client);
+            if (result.type === "failed") {
+              await client.tui.showToast({
+                body: {
+                  message: `Authentication failed: ${result.error}`,
+                  variant: "error"
+                }
+              });
+            } else {
+              await client.tui.showToast({
+                body: {
+                  message: "Successfully authenticated with Qwen!",
+                  variant: "success"
+                }
+              });
+            }
+            return {
+              url: "",
+              instructions: result.type === "success" ? "Authentication complete!" : result.error || "Authentication failed",
+              method: "auto",
+              callback: async () => result
+            };
+          }
+        },
+        {
+          label: "Manually enter API Key",
+          type: "api",
+          prompts: [
+            {
+              type: "text",
+              message: "Enter your DashScope API Key",
+              key: "apiKey"
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+
+// src/qwen/oauth.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+function getQwenCachedCredentialPath(customPath) {
+  if (customPath) {
+    if (customPath.startsWith("~/")) {
+      return join(homedir(), customPath.slice(2));
+    }
+    return customPath;
+  }
+  return join(homedir(), QWEN_DIR, QWEN_CREDENTIAL_FILENAME);
+}
+function objectToUrlEncoded(data) {
+  return Object.entries(data).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+var QwenOAuthManager = class {
+  oauthPath;
+  credentials = null;
+  refreshLock = false;
+  constructor(oauthPath) {
+    this.oauthPath = oauthPath;
+  }
+  /**
+   * Load OAuth credentials from the cached file.
+   */
+  loadCachedCredentials() {
+    const keyFile = getQwenCachedCredentialPath(this.oauthPath);
+    if (!existsSync(keyFile)) {
+      throw new Error(
+        `Qwen OAuth credentials not found at ${keyFile}. Please login using the Qwen Code CLI first: qwen-code auth login`
+      );
+    }
+    try {
+      const content = readFileSync(keyFile, "utf-8");
+      const data = JSON.parse(content);
+      if (!data.access_token || !data.refresh_token || !data.expiry_date) {
+        throw new Error("Missing required fields in credentials file");
+      }
+      return {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        token_type: data.token_type || "Bearer",
+        expiry_date: data.expiry_date,
+        resource_url: data.resource_url
+      };
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new Error(`Invalid Qwen OAuth credentials file: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Refresh the OAuth access token.
+   */
+  async refreshAccessToken(credentials) {
+    if (this.refreshLock) {
+      while (this.refreshLock) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      return this.credentials || credentials;
+    }
+    this.refreshLock = true;
+    try {
+      if (!credentials.refresh_token) {
+        throw new Error("No refresh token available in credentials.");
+      }
+      const bodyData = {
+        grant_type: "refresh_token",
+        refresh_token: credentials.refresh_token,
+        client_id: QWEN_OAUTH_CLIENT_ID
+      };
+      const response = await fetch(QWEN_OAUTH_TOKEN_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Accept": "application/json",
+          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+        },
+        body: objectToUrlEncoded(bodyData)
+      });
+      if (response.status !== HTTP_OK) {
+        const errorText = await response.text();
+        throw new Error(
+          `Token refresh failed: ${response.status} ${response.statusText}. Response: ${errorText}`
+        );
+      }
+      let tokenData;
+      try {
+        tokenData = await response.json();
+      } catch {
+        const text = await response.text();
+        throw new Error(
+          `Token refresh failed: Invalid JSON response from OAuth endpoint. Response: ${text.slice(0, 200)}`
+        );
+      }
+      if (tokenData.error) {
+        throw new Error(
+          `Token refresh failed: ${tokenData.error} - ${tokenData.error_description || "Unknown error"}`
+        );
+      }
+      const newCredentials = {
+        access_token: tokenData.access_token,
+        token_type: tokenData.token_type || "Bearer",
+        refresh_token: tokenData.refresh_token || credentials.refresh_token,
+        expiry_date: Date.now() + tokenData.expires_in * 1e3,
+        resource_url: credentials.resource_url
+      };
+      this.saveCredentials(newCredentials);
+      this.credentials = newCredentials;
+      return newCredentials;
+    } finally {
+      this.refreshLock = false;
+    }
+  }
+  /**
+   * Save credentials to the cache file.
+   */
+  saveCredentials(credentials) {
+    const filePath = getQwenCachedCredentialPath(this.oauthPath);
+    try {
+      const dir = join(filePath, "..");
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(
+        filePath,
+        JSON.stringify(
+          {
+            access_token: credentials.access_token,
+            refresh_token: credentials.refresh_token,
+            token_type: credentials.token_type,
+            expiry_date: credentials.expiry_date,
+            resource_url: credentials.resource_url
+          },
+          null,
+          2
+        ),
+        "utf-8"
+      );
+    } catch (error) {
+      console.warn(`Warning: Failed to save refreshed credentials: ${error}`);
+    }
+  }
+  /**
+   * Check if the access token is still valid.
+   */
+  isTokenValid(credentials) {
+    if (!credentials.expiry_date) {
+      return false;
+    }
+    return Date.now() < credentials.expiry_date - TOKEN_REFRESH_BUFFER_MS;
+  }
+  /**
+   * Invalidate cached credentials to force a refresh on next request.
+   */
+  invalidateCredentials() {
+    this.credentials = null;
+  }
+  /**
+   * Ensure we have valid authentication credentials.
+   * @returns Tuple of [access_token, base_url]
+   */
+  async ensureAuthenticated(forceRefresh = false) {
+    this.credentials = this.loadCachedCredentials();
+    if (forceRefresh || !this.isTokenValid(this.credentials)) {
+      this.credentials = await this.refreshAccessToken(this.credentials);
+    }
+    return [this.credentials.access_token, this.getBaseUrl(this.credentials)];
+  }
+  /**
+   * Get the API base URL from credentials.
+   */
+  getBaseUrl(credentials) {
+    let baseUrl = credentials.resource_url || QWEN_DEFAULT_BASE_URL;
+    if (!baseUrl.startsWith("http://") && !baseUrl.startsWith("https://")) {
+      baseUrl = `https://${baseUrl}`;
+    }
+    baseUrl = baseUrl.replace(/\/+$/, "");
+    if (!baseUrl.endsWith("/v1")) {
+      baseUrl = `${baseUrl}/v1`;
+    }
+    return baseUrl;
+  }
+  /**
+   * Get the current credentials, refreshing if needed.
+   */
+  async getCredentials() {
+    await this.ensureAuthenticated();
+    if (!this.credentials) {
+      throw new Error("Failed to get credentials");
+    }
+    return this.credentials;
+  }
+};
+function hasQwenCredentials(customPath) {
+  const keyFile = getQwenCachedCredentialPath(customPath);
+  return existsSync(keyFile);
+}
+
+// src/qwen/thinking-parser.ts
+var ThinkingBlockParser = class {
+  inThinkingBlock = false;
+  buffer = "";
+  /**
+   * Reset the parser state.
+   * Call this when starting a new message/response.
+   */
+  reset() {
+    this.inThinkingBlock = false;
+    this.buffer = "";
+  }
+  /**
+   * Check if currently inside a thinking block.
+   */
+  isInThinkingBlock() {
+    return this.inThinkingBlock;
+  }
+  /**
+   * Parse text and separate thinking content from regular content.
+   *
+   * This method is designed for streaming - call it with each chunk
+   * of text as it arrives, and it will return the parsed content.
+   *
+   * @param text - The text chunk to parse
+   * @returns Object containing regular and reasoning content
+   */
+  parse(text) {
+    let regularContent = "";
+    let reasoningContent = "";
+    this.buffer += text;
+    while (true) {
+      if (this.inThinkingBlock) {
+        const endIdx = this.buffer.indexOf("</think>");
+        if (endIdx !== -1) {
+          reasoningContent += this.buffer.slice(0, endIdx);
+          this.buffer = this.buffer.slice(endIdx + 8);
+          this.inThinkingBlock = false;
+        } else {
+          reasoningContent += this.buffer;
+          this.buffer = "";
+          break;
+        }
+      } else {
+        const startIdx = this.buffer.indexOf("<think>");
+        if (startIdx !== -1) {
+          regularContent += this.buffer.slice(0, startIdx);
+          this.buffer = this.buffer.slice(startIdx + 7);
+          this.inThinkingBlock = true;
+        } else {
+          const partialTag = this.findPartialOpenTag();
+          if (partialTag > 0) {
+            regularContent += this.buffer.slice(0, -partialTag);
+            this.buffer = this.buffer.slice(-partialTag);
+          } else {
+            regularContent += this.buffer;
+            this.buffer = "";
+          }
+          break;
+        }
+      }
+    }
+    return { regularContent, reasoningContent };
+  }
+  /**
+   * Find if there's a partial opening tag at the end of the buffer.
+   * Returns the length of the partial tag, or 0 if none found.
+   */
+  findPartialOpenTag() {
+    const tag = "<think>";
+    for (let len = Math.min(tag.length - 1, this.buffer.length); len > 0; len--) {
+      const suffix = this.buffer.slice(-len);
+      if (tag.startsWith(suffix)) {
+        return len;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Flush any remaining content in the buffer.
+   * Call this when the stream is complete.
+   *
+   * @returns Any remaining content based on current state
+   */
+  flush() {
+    const result = {
+      regularContent: "",
+      reasoningContent: ""
+    };
+    if (this.buffer.length > 0) {
+      if (this.inThinkingBlock) {
+        result.reasoningContent = this.buffer;
+      } else {
+        result.regularContent = this.buffer;
+      }
+      this.buffer = "";
+    }
+    return result;
+  }
+};
+function parseThinkingBlocks(text) {
+  const parser = new ThinkingBlockParser();
+  const result = parser.parse(text);
+  const flushed = parser.flush();
+  return {
+    regularContent: result.regularContent + flushed.regularContent,
+    reasoningContent: result.reasoningContent + flushed.reasoningContent
+  };
+}
+function stripThinkingBlocks(text) {
+  return parseThinkingBlocks(text).regularContent;
+}
+function extractThinkingContent(text) {
+  return parseThinkingBlocks(text).reasoningContent;
+}
+function hasThinkingBlocks(text) {
+  return text.includes("<think>") || text.includes("</think>");
+}
+
+// src/models.ts
+var QWEN_CODE_MODELS = {
+  // Primary models
+  "qwen3-coder-plus": {
+    id: "qwen3-coder-plus",
+    name: "Qwen3 Coder Plus",
+    context_window: 1e6,
+    max_output: 65536,
+    input_price: 0,
+    output_price: 0,
+    supports_native_tools: true,
+    supports_thinking: true
+  },
+  "qwen3-coder-flash": {
+    id: "qwen3-coder-flash",
+    name: "Qwen3 Coder Flash",
+    context_window: 1e6,
+    max_output: 65536,
+    input_price: 0,
+    output_price: 0,
+    supports_native_tools: true,
+    supports_thinking: true
+  }
+};
+var MODEL_ALIASES = {
+  "qwen-coder-plus": "qwen3-coder-plus",
+  "qwen-coder-flash": "qwen3-coder-flash"
+};
+var DEFAULT_MODEL = "qwen3-coder-plus";
+function getModelInfo(modelIdOrAlias) {
+  if (modelIdOrAlias in QWEN_CODE_MODELS) {
+    return QWEN_CODE_MODELS[modelIdOrAlias];
+  }
+  const resolvedId = MODEL_ALIASES[modelIdOrAlias];
+  if (resolvedId && resolvedId in QWEN_CODE_MODELS) {
+    return QWEN_CODE_MODELS[resolvedId];
+  }
+  return void 0;
+}
+function resolveModelId(modelIdOrAlias) {
+  return MODEL_ALIASES[modelIdOrAlias] || modelIdOrAlias;
+}
+function getAllModelIds() {
+  return [
+    ...Object.keys(QWEN_CODE_MODELS),
+    ...Object.keys(MODEL_ALIASES)
+  ];
+}
+function isValidModel(modelIdOrAlias) {
+  return getModelInfo(modelIdOrAlias) !== void 0;
+}
+function generateProviderConfig() {
+  const models = {};
+  for (const [id, info] of Object.entries(QWEN_CODE_MODELS)) {
+    models[id] = {
+      id: info.id,
+      name: info.name,
+      limit: {
+        context: info.context_window,
+        output: info.max_output
+      },
+      cost: {
+        input: info.input_price,
+        output: info.output_price
+      }
+    };
+  }
+  for (const [alias, targetId] of Object.entries(MODEL_ALIASES)) {
+    const targetInfo = QWEN_CODE_MODELS[targetId];
+    if (targetInfo) {
+      models[alias] = {
+        id: targetInfo.id,
+        name: `${targetInfo.name} (Alias)`,
+        limit: {
+          context: targetInfo.context_window,
+          output: targetInfo.max_output
+        },
+        cost: {
+          input: targetInfo.input_price,
+          output: targetInfo.output_price
+        }
+      };
+    }
+  }
+  return {
+    qwencode: {
+      npm: "@ai-sdk/openai-compatible",
+      options: {
+        baseURL: "https://portal.qwen.ai/v1"
+      },
+      models
+    }
+  };
+}
+export {
+  DEFAULT_MODEL,
+  MODEL_ALIASES,
+  QWEN_CODE_MODELS,
+  QWEN_DEFAULT_BASE_URL,
+  QWEN_INTL_BASE_URL,
+  QWEN_OAUTH_BASE_URL,
+  QWEN_PORTAL_BASE_URL,
+  QWEN_PROVIDER_ID,
+  QwenOAuthManager,
+  QwenOAuthPlugin,
+  ThinkingBlockParser,
+  accessTokenExpired,
+  createAuthDetails,
+  QwenOAuthPlugin as default,
+  ensureValidToken,
+  extractThinkingContent,
+  formatRefreshParts,
+  generateProviderConfig,
+  getAllModelIds,
+  getModelInfo,
+  getQwenCachedCredentialPath,
+  hasQwenCredentials,
+  hasThinkingBlocks,
+  isOAuthAuth,
+  isValidModel,
+  needsTokenRefresh,
+  parseRefreshParts,
+  parseThinkingBlocks,
+  refreshAccessToken,
+  resolveModelId,
+  stripThinkingBlocks
+};