qwenproxy-cli 1.0.32 → 1.2.0

package/src/routes/chat/context.ts

@@ -1,4 +1,4 @@
-import { config, type ChatMode } from "../../core/config.ts";
+import { config, type ChatMode, isStatelessChatMode } from "../../core/config.ts";
 import { ContextLengthExceededError, ValidationError } from "../../core/errors.ts";
 import { getModelContextWindow } from "../../core/model-registry.ts";
 import {
@@ -61,16 +61,16 @@ export async function buildFinalContext(
 
   const modelContextWindow = getModelContextWindow(modelId);
   const useThreadNative = true;
-  const isTempMode = chatMode === "temp";
+  const isStateless = isStatelessChatMode(chatMode);
   // A continuation is ANY evidence of a prior turn, not just a plain
   // role:"assistant" message. Tool-loop clients (Zed/Cline) can send history
   // with tool/function responses or assistant tool_calls but WITHOUT a plain
   // assistant entry; misclassifying those as a new session forced the FULL
   // history to be re-sent on every request (and every chat_in_progress retry)
   // instead of the thread-native delta.
-  // In temp mode EVERY request is a new (ephemeral) chat, so the whole history
-  // is always sent and no thread state is ever consulted.
-  const isNewSession = isTempMode
+  // In stateless modes (stateless, stateless-temp, temp) EVERY request is a
+  // new chat, so the whole history is always sent and no thread state is consulted.
+  const isNewSession = isStateless
     ? true
     : !messages.some(isContinuationMessage);
   const completeInstructions = [systemPrompt.trim(), toolInstructions.trim()]
@@ -83,7 +83,7 @@ export async function buildFinalContext(
   //    OR: this is a continuation (has assistant messages in history)
   // This prevents new IDE chats from accidentally reusing old Qwen chats
   // while still allowing continuations without explicit session_id
-  const allowThreadReuse = isTempMode
+  const allowThreadReuse = isStateless
     ? false
     : useThreadNative && (hasExplicitConversationKey || !isNewSession); // has assistant messages = continuation of existing chat
 
@@ -91,7 +91,7 @@ export async function buildFinalContext(
   // an explicit conversation key. Otherwise, generate an ephemeral ID for
   // logging/metrics only (not used for thread reuse). Temp mode never persists
   // a thread, so it has no session id.
-  const sessionId = isTempMode
+  const sessionId = isStateless
     ? null
     : (conversationKey || useThreadNative)
       ? deriveSessionId(
@@ -110,7 +110,7 @@ export async function buildFinalContext(
   // Thread-native: send full history when Qwen has no context yet, but preserve
   // tool-result deltas because the upstream parent chain already owns the call.
   // Temp mode: always send the FULL history (OpenAI standard).
-  const baseActivePrompt = isTempMode
+  const baseActivePrompt = isStateless
     ? prompt
     : (!existingThread && !hasTrailingToolResult ? prompt : currentPrompt) ||
       prompt;
@@ -179,7 +179,7 @@ export async function buildFinalContext(
     isNewSession,
     useThreadNative,
     // Thread state is only persisted in thread mode (temp chats are ephemeral).
-    updateLogicalThread: isTempMode ? false : useThreadNative,
+    updateLogicalThread: isStateless ? false : useThreadNative,
     chatMode,
     isThinkingModel,
     estimatedTokens,

package/src/routes/chat/index.ts

@@ -20,7 +20,7 @@ import {
   handleChatCompletionsError,
   type AssistantCompleteEvent,
 } from "./streaming.ts";
-import { config, type ChatMode } from "../../core/config.ts";
+import { config, type ChatMode, normalizeChatMode } from "../../core/config.ts";
 import { logger } from "../../core/logger.ts";
 import { metrics } from "../../core/metrics.ts";
 import { getContextMeterHeaders, type ContextMeterMode } from "../../services/context-meter.ts";
@@ -50,11 +50,20 @@ function formatTimingHeader(timings: Record<string, number>): string {
  * else silently uses the configured default.
  */
 function resolveChatMode(headerValue: string | undefined): ChatMode {
-  if (headerValue === "thread" || headerValue === "temp" || headerValue === "temp-thread") {
-    return headerValue;
-  }
-  if (headerValue === "temp_thread") {
-    return "temp-thread";
+  if (headerValue) {
+    const m = headerValue.trim().toLowerCase().replace(/_/g, "-");
+    if (
+      m === "thread" ||
+      m === "thread-temp" ||
+      m === "temp-thread" ||
+      m === "stateless" ||
+      m === "stateles" ||
+      m === "stateless-temp" ||
+      m === "stateles-temp" ||
+      m === "temp"
+    ) {
+      return normalizeChatMode(m);
+    }
   }
   return config.qwen.chatMode;
 }

package/src/services/qwen-chat-pool.ts

@@ -1,6 +1,6 @@
 import crypto from "crypto";
 import { getQwenHeaders, isAuthMockEnabled } from "./auth-playwright.ts";
-import { config, type ChatMode } from "../core/config.ts";
+import { config, type ChatMode, isLocalChatMode, isStatelessChatMode } from "../core/config.ts";
 import { logger, isToolcallDebugEnabled } from "../core/logger.ts";
 import {
   computeQuotaCooldownMs,
@@ -83,9 +83,8 @@ export function buildChatNewBody(
     project_id: "",
     timestamp: Date.now(),
     chat_type: "t2t",
-    // thread → normal (persisted), temp / temp-thread → local (ephemeral, not listed).
-    chat_mode:
-      chatMode === "temp" || chatMode === "temp-thread" ? "local" : "normal",
+    // normal: thread & stateless (persisted in Qwen); local: thread-temp & stateless-temp (ephemeral)
+    chat_mode: isLocalChatMode(chatMode) ? "local" : "normal",
   };
 }
 
@@ -201,7 +200,7 @@ export async function acquireNewQwenChatSession(
   accountId?: string,
   chatMode: ChatMode = "thread",
 ): Promise<{ chatId: string; leasedFromPool: boolean }> {
-  if (isQwenChatPoolEnabled() && chatMode !== "temp") {
+  if (isQwenChatPoolEnabled() && !isStatelessChatMode(chatMode)) {
     const key = chatPoolKey(accountId, model);
     const pooled = precreatedChatSessions.get(key);
     const chatId = pooled?.shift();

package/src/services/qwen.ts

@@ -12,7 +12,7 @@ import {
 } from "../core/errors.ts";
 import { buildQwenRequestHeaders } from "./qwen-headers.ts";
 import { qwenOrigin, qwenUrl } from "./qwen-url.ts";
-import { config, type ChatMode } from "../core/config.ts";
+import { config, type ChatMode, isLocalChatMode } from "../core/config.ts";
 import { logger } from "../core/logger.ts";
 import { estimateTokenCount } from "../utils/context-truncation.ts";
 import type {
@@ -440,6 +440,14 @@ const modelsCache = new Map<
   { models: PublicQwenModel[]; fetchedAt: number }
 >();
 
+export function getAnyCachedQwenModels(): PublicQwenModel[] | undefined {
+  for (const entry of modelsCache.values()) {
+    if (entry.models && entry.models.length > 0) {
+      return entry.models;
+    }
+  }
+  return undefined;
+}
 const nativeToolsDisabled = new Set<string>();
 const disablingNativeToolsInProgress = new Set<string>();
 const lastSyncedPersonalizationHashes = new Map<string, string>();
@@ -492,6 +500,25 @@ function setPersonalizationHashInDb(accountId: string, hash: string): void {
     );
   }
 }
+export function clearPersonalizationDbCache(accountId?: string): number {
+  try {
+    const db = getDatabase();
+    if (accountId) {
+      const info = db
+        .prepare("DELETE FROM personalization_cache WHERE account_id = ?")
+        .run(accountId);
+      lastSyncedPersonalizationHashes.delete(accountId);
+      activePersonalizationByAccount.delete(accountId);
+      return info.changes;
+    }
+    const info = db.prepare("DELETE FROM personalization_cache").run();
+    lastSyncedPersonalizationHashes.clear();
+    activePersonalizationByAccount.clear();
+    return info.changes;
+  } catch {
+    return 0;
+  }
+}
 
 function shortContentHash(value: string): string {
   return crypto.createHash("sha256").update(value).digest("hex").slice(0, 12);
@@ -666,23 +693,14 @@ export function buildQwenSettingsUpdatePayload(
   currentSettings: any,
   instruction: string,
 ): Record<string, unknown> {
-  // The real client (HAR networkv2) POSTs ONLY `{personalization: {...}}` to
-  // /api/v2/users/user/settings/update. Live probes confirmed the personalization
-  // object accepts the GET-personalization spread + enable_for_new_chat, but the
-  // FULL-settings spread this used to send (ui/memory/tools_enabled + every GET
-  // field like tts_speaker_v2, code_settings, manage_cookies) is rejected with
-  // RequestValidationError. Safe-settings are applied by disableNativeTools as
-  // their own combined partial POST (probe-accepted). NOTE: the persistent
-  // RequestValidationError that haunted the sync was NOT the payload — it was a
-  // missing Content-Type header (attemptPost received the raw getQwenHeaders
-  // map); the body was not parsed as a JSON object ("Field '': Input should be
-  // a valid dictionary...").
   const currentPersonalization =
     currentSettings?.personalization &&
     typeof currentSettings.personalization === "object"
       ? currentSettings.personalization
       : {};
 
+  const hasInstruction = instruction.trim().length > 0;
+
   return {
     personalization: {
       ...currentPersonalization,
@@ -693,7 +711,7 @@ export function buildQwenSettingsUpdatePayload(
           : currentPersonalization.description,
       style: null,
       instruction,
-      enable_for_new_chat: true,
+      enable_for_new_chat: hasInstruction,
     },
   };
 }
@@ -1519,7 +1537,12 @@ export async function syncQwenRequestPersonalization(
   }
 
   // 2. Check DB cache (survives restarts) (skipped on forceSync)
-  if (!bypassCache && syncHash && !cachedHash) {
+  const isEmptyInstruction = instruction.trim().length === 0;
+
+  // 2. Check DB cache (survives restarts) (skipped on forceSync)
+  // For empty instructions, do not blindly trust DB cache without verifying
+  // because external agents or web sessions might have altered personalization.
+  if (!bypassCache && syncHash && !cachedHash && !isEmptyInstruction) {
     const dbHash = getPersonalizationHashFromDb(cacheKey);
     if (dbHash === syncHash) {
       lastSyncedPersonalizationHashes.set(cacheKey, syncHash);
@@ -1528,7 +1551,6 @@ export async function syncQwenRequestPersonalization(
       return true;
     }
   }
-
   let existing = { chars: null, bytes: null, hash: null } as ReturnType<
     typeof textSize
   >;
@@ -1544,7 +1566,9 @@ export async function syncQwenRequestPersonalization(
         );
       currentSettings = existingJson?.data ?? null;
       payload = buildQwenSettingsUpdatePayload(currentSettings, instruction);
-      existing = textSize(existingJson?.data?.personalization?.instruction);
+      const existingInstruction = existingJson?.data?.personalization?.instruction;
+      const existingEnabled = existingJson?.data?.personalization?.enable_for_new_chat === true;
+      existing = textSize(existingInstruction);
       const existingSafeSettingsApplied =
         existingJson?.data?.ui?.largeTextAsFile === false &&
         existingJson?.data?.ui?.splitLargeChunks === false &&
@@ -1554,8 +1578,12 @@ export async function syncQwenRequestPersonalization(
         existingJson?.data?.memory?.enable_history_memory === false &&
         existingJson?.data?.tools_enabled?.web_search === false &&
         existingJson?.data?.tools_enabled?.code_interpreter === false;
-      if (existing.hash === sent.hash && existingSafeSettingsApplied) {
-        lastSyncedPersonalizationHashes.set(cacheKey, syncHash);
+      const isEmptyAndCleared =
+        isEmptyInstruction &&
+        (!existingInstruction || existingInstruction.trim().length === 0) &&
+        !existingEnabled;
+      const isContentMatched = existing.hash !== null && existing.hash === sent.hash;
+      if ((isContentMatched || isEmptyAndCleared) && existingSafeSettingsApplied) {
         setPersonalizationHashInDb(cacheKey, syncHash);
         rememberActivePersonalization(
           cacheKey,
@@ -1669,6 +1697,7 @@ export async function syncQwenRequestPersonalization(
     typeof textSize
   >;
 
+  let verifyData: any = null;
   if (config.qwen.personalizationVerifyGet) {
     const { json: verifyJson } =
       await requestQwenPersonalizationInBrowser(
@@ -1677,11 +1706,18 @@ export async function syncQwenRequestPersonalization(
         "/api/v2/users/user/settings",
         requestHeaders,
       );
-    stored = textSize(verifyJson?.data?.personalization?.instruction);
-  }
-
-  const matchReturned = returned.hash !== null && returned.hash === sent.hash;
-  const matchStored = stored.hash === null ? null : stored.hash === sent.hash;
+    verifyData = verifyJson?.data?.personalization;
+    stored = textSize(verifyData?.instruction);
+  }
+
+  const matchReturned =
+    (isEmptyInstruction && (!returnedInstruction || returned.chars === 0)) ||
+    (returned.hash !== null && returned.hash === sent.hash);
+  const matchStored =
+    stored.hash === null
+      ? null
+      : (isEmptyInstruction && (!verifyData?.instruction || stored.chars === 0)) ||
+        stored.hash === sent.hash;
   const applied = matchReturned || matchStored === true;
   if (syncHash && applied) {
     lastSyncedPersonalizationHashes.set(cacheKey, syncHash);
@@ -2757,10 +2793,7 @@ async function createQwenStreamInternal(
     chatId: chatSessionId || null,
     parentId: actualParentId ?? "",
     chat_id: chatSessionId || null,
-    chat_mode:
-      options?.chatMode === "temp" || options?.chatMode === "temp-thread"
-        ? "local"
-        : "normal",
+    chat_mode: isLocalChatMode(options?.chatMode) ? "local" : "normal",
     model: model,
     parent_id: actualParentId,
     messages: [

package/src/sync/claude-code.ts

@@ -33,12 +33,14 @@ export function syncClaudeCode(options: SyncOptions): ClientSyncResult {
       ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3.7-plus",
       ANTHROPIC_DEFAULT_OPUS_MODEL: model,
       CLAUDE_CODE_MAX_CONTEXT_TOKENS: "1000000",
+      CLAUDE_CODE_DISABLE_ARTIFACT: "1",
     };
 
     const updatedSettings = {
       ...existingSettings,
       env,
       model,
+      enableArtifact: false,
     };
 
     fs.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
@@ -63,13 +65,48 @@ export function syncClaudeCode(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreClaudeCode(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      if (data.env && (data.env.ANTHROPIC_BASE_URL?.includes("7936") || data.env.ANTHROPIC_AUTH_TOKEN === "sk-qwenproxy-local" || data.env.ANTHROPIC_MODEL?.includes("qwen"))) {
+        delete data.env.ANTHROPIC_BASE_URL;
+        delete data.env.ANTHROPIC_AUTH_TOKEN;
+        delete data.env.ANTHROPIC_MODEL;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+        delete data.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+        delete data.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+        delete data.env.CLAUDE_CODE_DISABLE_ARTIFACT;
+        delete data.enableArtifact;
+        if (data.model && data.model.toLowerCase().includes("qwen")) {
+          delete data.model;
+        }
+        if (Object.keys(data.env).length === 0) {
+          delete data.env;
+        }
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "claude-code",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Claude Code settings from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Claude Code settings from backup"
+        : "Removed QwenProxy configuration from Claude Code settings"
+      : "Backup file not found",
   };
 }

package/src/sync/cline.ts

@@ -98,13 +98,43 @@ export function syncCline(options: SyncOptions): ClientSyncResult {
 }
 
 export function restoreCline(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      const db = new Database(filePath);
+      const rows = db
+        .prepare("SELECT key, value FROM ItemTable WHERE key = 'saoudrizwan.claude-dev' OR key = 'ZooCodeOrganization.zoo-code'")
+        .all() as Array<{ key: string; value: string }>;
+
+      for (const row of rows) {
+        try {
+          const parsed = JSON.parse(row.value);
+          if (parsed.openAiBaseUrl?.includes("7936") || parsed.openAiModelId?.includes("qwen")) {
+            delete parsed.openAiBaseUrl;
+            delete parsed.openAiApiKey;
+            delete parsed.openAiModelId;
+            db.prepare("UPDATE ItemTable SET value = ? WHERE key = ?").run(JSON.stringify(parsed), row.key);
+            manuallyCleaned = true;
+          }
+        } catch {}
+      }
+      db.close();
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "cline",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Cline settings from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Cline settings from backup"
+        : "Removed QwenProxy configuration from Cline settings"
+      : "Backup file not found",
   };
 }

package/src/sync/codex.ts

@@ -111,13 +111,38 @@ experimental_bearer_token = "${apiKey}"
 }
 
 export function restoreCodex(filePath: string, backupPath?: string): ClientSyncResult {
-  const restored = restoreFromBackup(filePath, backupPath);
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+
+  // If backup was restored but still had qwenproxy (or if no backup was found),
+  // strip the QwenProxy provider block cleanly so the file is guaranteed un-synced.
+  let manuallyCleaned = false;
+  if (fs.existsSync(filePath)) {
+    try {
+      let content = fs.readFileSync(filePath, "utf-8");
+      if (content.includes("[model_providers.qwenproxy]") || /^model_provider\s*=\s*["']qwenproxy["']/m.test(content)) {
+        const providerRegex = /\[model_providers\.qwenproxy\][\s\S]*?(?=(?:^\[|\Z))/m;
+        content = content.replace(providerRegex, "").trimEnd();
+        content = content.replace(/^model_provider\s*=\s*["']qwenproxy["']\r?\n?/m, "");
+        if (/^model\s*=\s*["']qwen/m.test(content)) {
+          content = content.replace(/^model\s*=\s*["']qwen[^"']*["']\r?\n?/m, "");
+        }
+        fs.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {}
+  }
+
+  const success = restoredFromBackup || manuallyCleaned;
   return {
     client: "codex",
     filePath,
     backupPath,
-    success: restored,
-    action: restored ? "restored" : "failed",
-    message: restored ? "Restored Codex config from backup" : "Backup file not found",
+    success,
+    action: success ? "restored" : "failed",
+    message: success
+      ? restoredFromBackup
+        ? "Restored Codex config from backup"
+        : "Removed QwenProxy configuration from Codex config"
+      : "Backup file not found",
   };
 }