opencode-qwen-cli-auth 2.2.3 → 2.2.4

package/dist/index.js

@@ -14,7 +14,297 @@ import { logError, logInfo, logWarn, LOGGING_ENABLED } from "./lib/logger.js";
 const CHAT_REQUEST_TIMEOUT_MS = 30000;
 const CHAT_MAX_RETRIES = 0;
 const MAX_CONSECUTIVE_POLL_FAILURES = 3;
+const QUOTA_DEGRADE_MAX_TOKENS = 1024;
 const PLUGIN_USER_AGENT = "opencode-qwen-cli-auth/2.2.1";
+const CLIENT_ONLY_BODY_FIELDS = new Set([
+    "providerID",
+    "provider",
+    "sessionID",
+    "modelID",
+    "requestBodyValues",
+    "metadata",
+    "options",
+    "debug",
+]);
+function makeFailFastErrorResponse(status, code, message) {
+    return new Response(JSON.stringify({
+        error: {
+            message,
+            type: "invalid_request_error",
+            param: null,
+            code,
+        },
+    }), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function createRequestSignalWithTimeout(sourceSignal, timeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(new Error("request_timeout")), timeoutMs);
+    const onSourceAbort = () => controller.abort(sourceSignal?.reason);
+    if (sourceSignal) {
+        if (sourceSignal.aborted) {
+            controller.abort(sourceSignal.reason);
+        }
+        else {
+            sourceSignal.addEventListener("abort", onSourceAbort, { once: true });
+        }
+    }
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timeoutId);
+            if (sourceSignal) {
+                sourceSignal.removeEventListener("abort", onSourceAbort);
+            }
+        },
+    };
+}
+function getHeaderValue(headers, headerName) {
+    if (!headers) {
+        return undefined;
+    }
+    const normalizedHeader = headerName.toLowerCase();
+    if (headers instanceof Headers) {
+        return headers.get(headerName) ?? headers.get(normalizedHeader) ?? undefined;
+    }
+    if (Array.isArray(headers)) {
+        const pair = headers.find(([name]) => String(name).toLowerCase() === normalizedHeader);
+        return pair ? String(pair[1]) : undefined;
+    }
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === normalizedHeader) {
+            return value === undefined || value === null ? undefined : String(value);
+        }
+    }
+    return undefined;
+}
+function applyJsonRequestBody(requestInit, payload) {
+    requestInit.body = JSON.stringify(payload);
+    if (!requestInit.headers) {
+        requestInit.headers = { "content-type": "application/json" };
+        return;
+    }
+    if (requestInit.headers instanceof Headers) {
+        if (!requestInit.headers.has("content-type")) {
+            requestInit.headers.set("content-type", "application/json");
+        }
+        return;
+    }
+    if (Array.isArray(requestInit.headers)) {
+        const hasContentType = requestInit.headers.some(([name]) => String(name).toLowerCase() === "content-type");
+        if (!hasContentType) {
+            requestInit.headers.push(["content-type", "application/json"]);
+        }
+        return;
+    }
+    let hasContentType = false;
+    for (const name of Object.keys(requestInit.headers)) {
+        if (name.toLowerCase() === "content-type") {
+            hasContentType = true;
+            break;
+        }
+    }
+    if (!hasContentType) {
+        requestInit.headers["content-type"] = "application/json";
+    }
+}
+function parseJsonRequestBody(requestInit) {
+    if (typeof requestInit.body !== "string") {
+        return null;
+    }
+    const contentType = getHeaderValue(requestInit.headers, "content-type");
+    if (contentType && !contentType.toLowerCase().includes("application/json")) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(requestInit.body);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (_error) {
+        return null;
+    }
+}
+function sanitizeOutgoingPayload(payload) {
+    const sanitized = { ...payload };
+    let changed = false;
+    for (const field of CLIENT_ONLY_BODY_FIELDS) {
+        if (field in sanitized) {
+            delete sanitized[field];
+            changed = true;
+        }
+    }
+    if ("stream_options" in sanitized && sanitized.stream !== true) {
+        delete sanitized.stream_options;
+        changed = true;
+    }
+    return changed ? sanitized : payload;
+}
+function createQuotaDegradedPayload(payload) {
+    const degraded = { ...payload };
+    let changed = false;
+    if ("tools" in degraded) {
+        delete degraded.tools;
+        changed = true;
+    }
+    if ("tool_choice" in degraded) {
+        delete degraded.tool_choice;
+        changed = true;
+    }
+    if ("parallel_tool_calls" in degraded) {
+        delete degraded.parallel_tool_calls;
+        changed = true;
+    }
+    if (degraded.stream !== false) {
+        degraded.stream = false;
+        changed = true;
+    }
+    if (typeof degraded.max_tokens !== "number" || degraded.max_tokens > QUOTA_DEGRADE_MAX_TOKENS) {
+        degraded.max_tokens = QUOTA_DEGRADE_MAX_TOKENS;
+        changed = true;
+    }
+    if (typeof degraded.max_completion_tokens === "number" && degraded.max_completion_tokens > QUOTA_DEGRADE_MAX_TOKENS) {
+        degraded.max_completion_tokens = QUOTA_DEGRADE_MAX_TOKENS;
+        changed = true;
+    }
+    return changed ? degraded : null;
+}
+function isInsufficientQuota(text) {
+    if (!text) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        const errorCode = parsed?.error?.code;
+        return typeof errorCode === "string" && errorCode.toLowerCase() === "insufficient_quota";
+    }
+    catch (_error) {
+        return text.toLowerCase().includes("insufficient_quota");
+    }
+}
+function makeQuotaFailFastResponse(text, sourceHeaders, context) {
+    const headers = new Headers(sourceHeaders);
+    headers.set("content-type", "application/json");
+    const body = text || JSON.stringify({
+        error: {
+            message: "Qwen quota/rate limit reached",
+            type: "invalid_request_error",
+            param: null,
+            code: "insufficient_quota",
+        },
+    });
+    if (LOGGING_ENABLED) {
+        logWarn("Qwen request failed with 429", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: context.modelID,
+            status: 429,
+            body: body.slice(0, 300),
+        });
+    }
+    return new Response(body, {
+        status: 400,
+        headers,
+    });
+}
+async function sendWithTimeout(input, requestInit) {
+    const composed = createRequestSignalWithTimeout(requestInit.signal, CHAT_REQUEST_TIMEOUT_MS);
+    try {
+        return await fetch(input, {
+            ...requestInit,
+            signal: composed.signal,
+        });
+    }
+    finally {
+        composed.cleanup();
+    }
+}
+async function failFastFetch(input, init) {
+    const requestInit = init ? { ...init } : {};
+    const rawPayload = parseJsonRequestBody(requestInit);
+    const sessionID = typeof rawPayload?.sessionID === "string" ? rawPayload.sessionID : undefined;
+    let payload = rawPayload;
+    if (payload) {
+        const sanitized = sanitizeOutgoingPayload(payload);
+        if (sanitized !== payload) {
+            payload = sanitized;
+            applyJsonRequestBody(requestInit, payload);
+        }
+    }
+    const context = {
+        requestId: getHeaderValue(requestInit.headers, "x-request-id"),
+        sessionID,
+        modelID: typeof payload?.model === "string" ? payload.model : undefined,
+    };
+    if (LOGGING_ENABLED) {
+        logInfo("Qwen request dispatch", {
+            request_id: context.requestId,
+            sessionID: context.sessionID,
+            modelID: context.modelID,
+        });
+    }
+    try {
+        let response = await sendWithTimeout(input, requestInit);
+        if (LOGGING_ENABLED) {
+            logInfo("Qwen request response", {
+                request_id: context.requestId,
+                sessionID: context.sessionID,
+                modelID: context.modelID,
+                status: response.status,
+                attempt: 1,
+            });
+        }
+        if (response.status === 429) {
+            const firstBody = await response.text().catch(() => "");
+            if (payload && isInsufficientQuota(firstBody)) {
+                const degradedPayload = createQuotaDegradedPayload(payload);
+                if (degradedPayload) {
+                    const fallbackInit = { ...requestInit };
+                    applyJsonRequestBody(fallbackInit, degradedPayload);
+                    if (LOGGING_ENABLED) {
+                        logWarn("Retrying once with degraded payload after 429 insufficient_quota", {
+                            request_id: context.requestId,
+                            sessionID: context.sessionID,
+                            modelID: context.modelID,
+                            attempt: 2,
+                        });
+                    }
+                    response = await sendWithTimeout(input, fallbackInit);
+                    if (LOGGING_ENABLED) {
+                        logInfo("Qwen request response", {
+                            request_id: context.requestId,
+                            sessionID: context.sessionID,
+                            modelID: context.modelID,
+                            status: response.status,
+                            attempt: 2,
+                        });
+                    }
+                    if (response.status !== 429) {
+                        return response;
+                    }
+                    const fallbackBody = await response.text().catch(() => "");
+                    return makeQuotaFailFastResponse(fallbackBody, response.headers, context);
+                }
+            }
+            return makeQuotaFailFastResponse(firstBody, response.headers, context);
+        }
+        return response;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const lowered = message.toLowerCase();
+        if (lowered.includes("aborted") || lowered.includes("timeout")) {
+            logWarn("Qwen request timeout (fail-fast)", { timeoutMs: CHAT_REQUEST_TIMEOUT_MS, message });
+            return makeFailFastErrorResponse(400, "request_timeout", `Qwen request timed out after ${CHAT_REQUEST_TIMEOUT_MS}ms`);
+        }
+        logError("Qwen upstream fetch failed", { message });
+        return makeFailFastErrorResponse(400, "upstream_unavailable", "Qwen upstream request failed");
+    }
+}
 /**
  * Get valid access token from SDK auth state, refresh if expired.
  * Uses getAuth() from SDK instead of reading file directly.
@@ -122,6 +412,7 @@ export const QwenAuthPlugin = async (_input) => {
                     baseURL,
                     timeout: CHAT_REQUEST_TIMEOUT_MS,
                     maxRetries: CHAT_MAX_RETRIES,
+                    fetch: failFastFetch,
                 };
             },
             methods: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-qwen-cli-auth",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "description": "Qwen OAuth authentication plugin for opencode - use your Qwen account instead of API keys",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",