qwenproxy-cli 1.5.2 → 1.6.0

package/src/core/daily-usage.ts

@@ -0,0 +1,276 @@
+/**
+ * QwenProxy - Real-time Daily Token & Quota Metrics Engine
+ *
+ * Tracks empirical per-account and pool-wide daily usage (prompt & completion tokens, turn counts)
+ * keyed strictly by UTC date so it resets automatically every day at 00:00 UTC (21:00 BRT).
+ *
+ * INVARIANT: This is PURELY an observability / monitoring metric for the user.
+ * It NEVER throttles, blocks, or rejects requests locally.
+ */
+
+import { getDatabase } from "./database.ts";
+import { loadAccounts } from "./accounts.ts";
+import { mapClientModelToQwen } from "./model-alias.ts";
+
+/**
+ * Calibrated daily output-tokens baseline per account.
+ * Standard baseline is based on the primary coding model (Plus family): 500,000 output tokens.
+ */
+export const STANDARD_DAILY_TOKEN_BASELINE = 500_000;
+export const DAILY_ACCOUNT_TOKEN_BASELINE = STANDARD_DAILY_TOKEN_BASELINE; // backward-compat
+
+export const MODEL_DAILY_OUTPUT_BASELINES: Record<string, number> = {
+  max: 280_000,
+  plus: 500_000,
+  omni: 620_000,
+};
+
+/**
+ * Returns the normalization weight for a model relative to the standard 500k Plus baseline.
+ * - Max models (280k): 500/280 = ~1.7857x (consumes quota faster)
+ * - Plus models (500k): 1.0x (standard baseline)
+ * - Omni/Flash models (620k): 500/620 = ~0.8065x (lasts longer)
+ */
+export function getModelQuotaWeight(model?: string): number {
+  if (!model) return 1.0;
+  const resolved = mapClientModelToQwen(model).toLowerCase();
+  if (resolved.includes("max")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.max;
+  }
+  if (resolved.includes("omni") || resolved.includes("flash")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.omni;
+  }
+  return 1.0;
+}
+
+export interface AccountDailyUsage {
+  accountId: string;
+  dateUtc: string;
+  promptTokens: number;
+  completionTokens: number;
+  weightedTokens: number;
+  totalTokens: number;
+  turnsCount: number;
+  usagePercent: number;
+}
+
+export interface PoolDailyUsageSummary {
+  dateUtc: string;
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalWeightedTokens: number;
+  totalTokens: number;
+  totalTurns: number;
+  poolCapacityTokens: number;
+  poolUsagePercent: number;
+}
+
+/** Formats a timestamp into YYYY-MM-DD in UTC timezone. */
+export function getUtcDateString(timestampMs: number = Date.now()): string {
+  return new Date(timestampMs).toISOString().slice(0, 10);
+}
+
+/**
+ * Records tokens and turn count for a given account on the current UTC date.
+ * Automatically upserts into SQLite `account_daily_usage`.
+ */
+export function recordTurnUsage(
+  accountId: string,
+  usage: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  },
+  modelOrDate?: string,
+  maybeDateUtc?: string,
+): void {
+  if (!accountId || accountId === "global") return;
+
+  let model: string | undefined;
+  let dateUtc: string;
+
+  if (modelOrDate && /^\d{4}-\d{2}-\d{2}$/.test(modelOrDate)) {
+    dateUtc = modelOrDate;
+    model = undefined;
+  } else {
+    model = modelOrDate;
+    dateUtc = maybeDateUtc || getUtcDateString();
+  }
+
+  const prompt = Math.max(0, Number(usage.prompt_tokens) || 0);
+  const completion = Math.max(0, Number(usage.completion_tokens) || 0);
+  const total = Math.max(
+    prompt + completion,
+    Number(usage.total_tokens) || prompt + completion,
+  );
+  const weight = getModelQuotaWeight(model);
+  const weighted = completion * weight;
+
+  try {
+    const db = getDatabase();
+    db.prepare(
+      `
+      INSERT INTO account_daily_usage (
+        account_id, date_utc, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, 1, datetime('now')
+      )
+      ON CONFLICT(account_id, date_utc) DO UPDATE SET
+        prompt_tokens = prompt_tokens + excluded.prompt_tokens,
+        completion_tokens = completion_tokens + excluded.completion_tokens,
+        weighted_tokens = weighted_tokens + excluded.weighted_tokens,
+        total_tokens = total_tokens + excluded.total_tokens,
+        turns_count = turns_count + 1,
+        updated_at = datetime('now')
+    `,
+    ).run(accountId, dateUtc, prompt, completion, weighted, total);
+  } catch (err: any) {
+    // Non-fatal telemetry: never fail a user completion if DB recording fails
+  }
+}
+
+/**
+ * Returns today's usage statistics for a specific account.
+ */
+export function getAccountDailyUsage(
+  accountId: string,
+  dateUtc: string = getUtcDateString(),
+): AccountDailyUsage {
+  try {
+    const db = getDatabase();
+    const row = db
+      .prepare(
+        `SELECT prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE account_id = ? AND date_utc = ?`,
+      )
+      .get(accountId, dateUtc) as any;
+
+    const promptTokens = Number(row?.prompt_tokens) || 0;
+    const completionTokens = Number(row?.completion_tokens) || 0;
+    const weightedTokens = Number(row?.weighted_tokens) || completionTokens;
+    const totalTokens = Number(row?.total_tokens) || 0;
+    const turnsCount = Number(row?.turns_count) || 0;
+
+    const usagePercent = Math.min(
+      100,
+      Math.round((weightedTokens / STANDARD_DAILY_TOKEN_BASELINE) * 100),
+    );
+
+    return {
+      accountId,
+      dateUtc,
+      promptTokens,
+      completionTokens,
+      weightedTokens,
+      totalTokens,
+      turnsCount,
+      usagePercent,
+    };
+  } catch {
+    return {
+      accountId,
+      dateUtc,
+      promptTokens: 0,
+      completionTokens: 0,
+      weightedTokens: 0,
+      totalTokens: 0,
+      turnsCount: 0,
+      usagePercent: 0,
+    };
+  }
+}
+
+/**
+ * Returns daily usage mapped by account_id for the given UTC date.
+ */
+export function getAllAccountsDailyUsage(
+  dateUtc: string = getUtcDateString(),
+): Map<string, AccountDailyUsage> {
+  const result = new Map<string, AccountDailyUsage>();
+  try {
+    const db = getDatabase();
+    const rows = db
+      .prepare(
+        `SELECT account_id, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE date_utc = ?`,
+      )
+      .all(dateUtc) as any[];
+
+    for (const row of rows) {
+      const promptTokens = Number(row.prompt_tokens) || 0;
+      const completionTokens = Number(row.completion_tokens) || 0;
+      const weightedTokens = Number(row.weighted_tokens) || completionTokens;
+      const totalTokens = Number(row.total_tokens) || 0;
+      const turnsCount = Number(row.turns_count) || 0;
+      const usagePercent = Math.min(
+        100,
+        Math.round((weightedTokens / STANDARD_DAILY_TOKEN_BASELINE) * 100),
+      );
+
+      result.set(row.account_id, {
+        accountId: row.account_id,
+        dateUtc,
+        promptTokens,
+        completionTokens,
+        weightedTokens,
+        totalTokens,
+        turnsCount,
+        usagePercent,
+      });
+    }
+  } catch {}
+  return result;
+}
+
+/**
+ * Computes the aggregate pool daily usage and percentage.
+ */
+export function getPoolDailyUsageSummary(
+  targetAccountIds?: string[],
+  dateUtc: string = getUtcDateString(),
+): PoolDailyUsageSummary {
+  const accounts =
+    targetAccountIds && targetAccountIds.length > 0
+      ? targetAccountIds
+      : loadAccounts().map((a) => a.id);
+
+  const accountCount = Math.max(1, accounts.length);
+  const poolCapacityTokens = accountCount * STANDARD_DAILY_TOKEN_BASELINE;
+
+  const usageMap = getAllAccountsDailyUsage(dateUtc);
+
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let totalWeightedTokens = 0;
+  let totalTokens = 0;
+  let totalTurns = 0;
+
+  for (const id of accounts) {
+    const usage = usageMap.get(id);
+    if (usage) {
+      totalPromptTokens += usage.promptTokens;
+      totalCompletionTokens += usage.completionTokens;
+      totalWeightedTokens += usage.weightedTokens;
+      totalTokens += usage.totalTokens;
+      totalTurns += usage.turnsCount;
+    }
+  }
+
+  const poolUsagePercent = Math.min(
+    100,
+    Math.round((totalWeightedTokens / poolCapacityTokens) * 100),
+  );
+
+  return {
+    dateUtc,
+    totalPromptTokens,
+    totalCompletionTokens,
+    totalWeightedTokens,
+    totalTokens,
+    totalTurns,
+    poolCapacityTokens,
+    poolUsagePercent,
+  };
+}

package/src/core/database.ts

@@ -170,8 +170,28 @@ function runMigrations(db: Database.Database): void {
       instruction_hash TEXT NOT NULL,
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS account_daily_usage (
+      account_id TEXT NOT NULL,
+      date_utc TEXT NOT NULL,
+      prompt_tokens INTEGER NOT NULL DEFAULT 0,
+      completion_tokens INTEGER NOT NULL DEFAULT 0,
+      weighted_tokens REAL NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      turns_count INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (account_id, date_utc)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_daily_usage_date ON account_daily_usage(date_utc);
   `);
 
+  try {
+    db.exec(`ALTER TABLE account_daily_usage ADD COLUMN weighted_tokens REAL DEFAULT 0;`);
+  } catch (err) {
+    if (!isDuplicateColumnError(err)) throw err;
+  }
+
   // Cooldown persistence columns — wrapped in try-catch because
   // SQLite doesn't support IF NOT EXISTS for ALTER TABLE ADD COLUMN.
   try {
@@ -341,7 +361,11 @@ export function saveAuthSession(
     ) VALUES (
       ?, ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
-      ?, ?, ?, ?, datetime('now')
+      COALESCE(?, (SELECT user_id FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      COALESCE(?, (SELECT refresh_token FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      datetime('now')
     )
   `);
   stmt.run(
@@ -356,8 +380,10 @@ export function saveAuthSession(
     session.secChUaPlatform || null,
     session.version || null,
     session.userId || null,
+    accountId,
     session.tokenExpiresAt || null,
     session.refreshToken || null,
+    accountId,
     session.capturedAt ?? Date.now(),
   );
 }

package/src/core/version.ts

@@ -17,6 +17,6 @@ export function getAppVersion(): string {
       }
     }
   } catch {}
-  cachedVersion = "v1.5.2";
+  cachedVersion = "v1.6.0";
   return cachedVersion;
 }

package/src/routes/chat/account.ts

@@ -271,8 +271,13 @@ export function resolveInitialAccount(
 
 		// Explicit preferred account (sticky / same-account retry)
 		if (typeof preferredAccountId === "string" && preferredAccountId) {
+			const needle = preferredAccountId.toLowerCase();
 			const preferred = configuredAccounts.find(
-				(candidate) => candidate.id === preferredAccountId,
+				(candidate) =>
+					candidate.id === preferredAccountId ||
+					candidate.id.toLowerCase().startsWith(needle) ||
+					candidate.email.toLowerCase() === needle ||
+					candidate.email.toLowerCase().includes(needle),
 			);
 			if (preferred && !getAccountCooldownInfo(preferred.id)) {
 				return { account: preferred, configuredAccounts };
@@ -939,7 +944,12 @@ async function tryCreateStreamWithRetry(
 	accountEmail: string,
 ): Promise<CreateStreamSuccess | CreateStreamFailure> {
 	const maxAttempts = Math.max(1, config.retry.maxAttempts);
-	const maxAccountSwitches = Math.max(0, config.retry.maxAccountSwitches);
+	const accounts = loadAccounts();
+	const configuredAccountCount = accounts.length;
+	const maxAccountSwitches = Math.max(
+		config.retry.maxAccountSwitches,
+		Math.min(configuredAccountCount - 1, 6),
+	);
 	let attemptsLeft = maxAttempts;
 	let retryDelay = config.retry.baseDelayMs;
 	let attempt = 0;
@@ -956,7 +966,6 @@ async function tryCreateStreamWithRetry(
 	let chatInProgressOriginAccountEmail: string | null = null;
 	let lastAttemptError: any = null;
 	let invalidInputSameAccountRetried = false;
-	const accounts = loadAccounts();
 	const isSingleAccount = accounts.length <= 1;
 	let currentAccountId = accountId;
 	let currentAccountEmail = accountEmail;
@@ -1268,7 +1277,18 @@ async function tryCreateStreamWithRetry(
 				const acquireDeadlineMs = config.concurrency.acquireDeadlineMs;
 				let acquireDeadlineTimer: NodeJS.Timeout | undefined;
 				const acquireDeadline = new Promise<never>((_, reject) => {
-					acquireDeadlineTimer = setTimeout(() => {
+					const checkDeadline = async () => {
+						try {
+							const { isCaptchaRecoveryActive } = await import(
+								"../../services/captcha-coordinator.ts"
+							);
+							if (currentAccountId && isCaptchaRecoveryActive(currentAccountId)) {
+								// Captcha solver is actively solving puzzle in background; extend deadline by 30s
+								acquireDeadlineTimer = setTimeout(checkDeadline, 30_000);
+								acquireDeadlineTimer.unref?.();
+								return;
+							}
+						} catch {}
 						// Abort the losing createQwenStream (it is still queued on the
 						// stream lock or mid-create); the post-lock signal re-check in
 						// createQwenStream then throws instead of letting the orphan
@@ -1279,7 +1299,8 @@ async function tryCreateStreamWithRetry(
 						) as Error & { code?: string };
 						err.code = "acquire_deadline";
 						reject(err);
-					}, acquireDeadlineMs);
+					};
+					acquireDeadlineTimer = setTimeout(checkDeadline, acquireDeadlineMs);
 					acquireDeadlineTimer.unref?.();
 				});
 				result = await Promise.race([
@@ -1487,19 +1508,24 @@ async function tryCreateStreamWithRetry(
 			};
 		}
 
-		if (
+		const isSessionExpired =
 			err instanceof QwenSessionExpiredError ||
-			err.name === "QwenSessionExpiredError"
-		) {
+			err?.name === "QwenSessionExpiredError" ||
+			(err instanceof Error &&
+				(err.message.toLowerCase().includes("token has expired") ||
+					err.message.toLowerCase().includes("session expired") ||
+					err.message.toLowerCase().includes("401 não autorizado") ||
+					err.message.toLowerCase().includes("unauthorized")));
+
+		if (isSessionExpired) {
 			console.warn(
-				`🔄 [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting re-login...`,
+				`🔄 [Chat] Session expired for ${currentAccountEmail} (${currentAccountId}). Attempting silent token refresh/re-login...`,
 			);
 			const reLoginOk = await attemptRelogin(
 				currentAccountId,
 				currentAccountEmail,
 			);
 			if (reLoginOk) continue;
-			return { success: false, error: err };
 		}
 
 
@@ -1735,6 +1761,13 @@ async function tryCreateStreamWithRetry(
 				currentAccountId = nextAccount.id;
 				currentAccountEmail = maskEmail(nextAccount.email);
 				accountSwitches++;
+				const isRealQuotaError =
+					policy.reason === "quota_or_rate_limit" &&
+					(policy.accountCooldownReason === "RateLimited" ||
+						policy.accountCooldownReason === "QuotaExceeded");
+				if (isRealQuotaError) {
+					attemptsLeft = Math.max(attemptsLeft, 1);
+				}
 
 				// Account switch always rebuilds a fresh upstream chat with full history.
 				// Do NOT persist sticky binding until create succeeds — premature empty

package/src/routes/chat/index.ts

@@ -242,7 +242,7 @@ export async function chatCompletions(c: Context) {
       updateLogicalThread: parallelEscape ? false : ctx.updateLogicalThread,
       allowThreadReuse: ctx.allowThreadReuse,
       forceNewChat: parallelEscape,
-      preferredAccountId: undefined,
+      preferredAccountId: c.req.header("x-qwenproxy-account") || undefined,
       messageCount: msgCount,
       fullMessageCount: parsed.messageCount,
       toolsCount: declaredTools.length || undefined,

package/src/routes/chat/streaming.ts

@@ -18,6 +18,7 @@ import {
   setToolCapNotice,
 } from "../../services/qwen.ts";
 import { acquireUpstreamStream } from "./account.ts";
+import { loadAccounts } from "../../core/accounts.ts";
 import { markAccountRateLimited, computeQuotaCooldownMs } from "../../core/account-manager.ts";
 import {
   clearTemporaryBusy,
@@ -60,6 +61,7 @@ import {
   logTokenEstimationSample,
   type TokenEstimationContext,
 } from "../../services/token-estimation-metrics.ts";
+import { recordTurnUsage } from "../../core/daily-usage.ts";
 import {
   enrichUsageWithContextMeter,
   getContextMeterHeaders,
@@ -781,6 +783,10 @@ export async function processNonStreamingResponse(
       context: currentTokenEstimationContext,
     });
 
+    if (activeAccountId && usage) {
+      recordTurnUsage(activeAccountId, usage, body.model);
+    }
+
     // The response was fully processed: persist the next-turn parent.
     if (pendingParentId) {
       rememberParent(pendingParentId);
@@ -900,6 +906,8 @@ export async function processStreamingResponse(
     let activeReader: ReadableStreamDefaultReader<Uint8Array> | null = null;
     let invalidInputSameAccountRetries = 0;
     let chatInProgressSameAccountRetries = 0;
+    const totalConfiguredAccounts = loadAccounts().length;
+    let quotaRotationsLeft = Math.min(Math.max(1, totalConfiguredAccounts - 1), 6);
     // Set when the terminal [DONE] reached the client. The `| recovered`
     // suffix on Stream done must only appear for attempts that COMPLETED after
     // a mid-stream retry, not for failed attempts that consumed retries.
@@ -1372,7 +1380,6 @@ export async function processStreamingResponse(
           !normalizedError ||
           (clientDisconnected && !gracePending) ||
           c.req.raw.signal.aborted ||
-          retryContext.retriesLeft <= 0 ||
           !midStreamRetry ||
           emittedModelOutput
         ) {
@@ -1384,6 +1391,19 @@ export async function processStreamingResponse(
         });
         if (!policy.retryable) return false;
 
+        const isRealQuotaError =
+          policy.reason === "quota_or_rate_limit" &&
+          (policy.accountCooldownReason === "RateLimited" ||
+            policy.accountCooldownReason === "QuotaExceeded");
+
+        const hasBudget = isRealQuotaError
+          ? quotaRotationsLeft > 0
+          : retryContext.retriesLeft > 0;
+
+        if (!hasBudget) {
+          return false;
+        }
+
         // Full recovery decision — same rationale as the create-path policy
         // log: the failure line shows the error, this line shows WHY the
         // chosen action (retry same / switch / new chat / cooldown) was taken.
@@ -1397,9 +1417,13 @@ export async function processStreamingResponse(
           invalidateLogicalThreadParent(midStreamRetry.sessionId);
         }
 
-        retryContext.retriesLeft--;
+        if (isRealQuotaError) {
+          quotaRotationsLeft--;
+        } else {
+          retryContext.retriesLeft--;
+        }
         console.warn(
-          `🔄 [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${retryContext.retriesLeft}`,
+          `🔄 [Chat] Stream recovery | account=${currentAccountId} | reason=${policy.reason} | error=${normalizedError.message.substring(0, 150)} | retries_left=${isRealQuotaError ? quotaRotationsLeft : retryContext.retriesLeft}`,
         );
 
         const retryInvalidInputOnSameAccount =
@@ -2566,6 +2590,10 @@ export async function processStreamingResponse(
           mode: "stream",
           context: currentTokenEstimationContext,
         });
+
+        if (activeAccountId && usage) {
+          recordTurnUsage(activeAccountId, usage, body.model);
+        }
       } else {
         if (isToolcallDebugEnabled()) {
           logger.debug(

package/src/services/captcha-coordinator.ts

@@ -21,6 +21,11 @@ const CHALLENGE_PATH_MARKER = "_____tmd_____";
  */
 const FAILED_RECOVERY_BACKOFF_MS = 30_000;
 const lastFailedRecoveryAt = new Map<string, number>();
+const activeCaptchaRecoveries = new Set<string>();
+
+export function isCaptchaRecoveryActive(accountId: string): boolean {
+  return activeCaptchaRecoveries.has(accountId);
+}
 
 async function gotoBestEffort(page: Page, url: string): Promise<void> {
   // A WAF-blocked navigation can time out while still having rendered the
@@ -105,13 +110,6 @@ export async function recoverBaxiaCaptcha(
 
   metrics.increment("captcha.challenges.detected", 1, { solver });
 
-  const challengeUrl = options.challengeBody
-    ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl)
-    : null;
-
-  // The slider itself waits up to 5s for each attempt. Keep the page
-  // operation alive for the full bounded solver budget so a slow challenge
-  // cannot be mistaken for a stuck browser. Do not clamp to timeouts.page.
   // Two navigations (open the challenge, return to the chat page) are part of
   // the recovery, so their budget belongs in the same total.
   const solverOperationTimeoutMs = Math.max(
@@ -122,6 +120,11 @@ export async function recoverBaxiaCaptcha(
       2 * CHALLENGE_NAVIGATION_TIMEOUT_MS,
   );
 
+  const challengeUrl = options.challengeBody
+    ? extractBaxiaChallengeUrl(options.challengeBody, config.qwen.baseUrl)
+    : null;
+
+  activeCaptchaRecoveries.add(accountId);
   try {
     // recoverOnTimeout: false ensures that if the captcha solve times out,
     // withAccountPage does NOT destructively kill the browser context, which
@@ -160,5 +163,7 @@ export async function recoverBaxiaCaptcha(
       detail,
     });
     return false;
+  } finally {
+    activeCaptchaRecoveries.delete(accountId);
   }
 }