@pedrofariasx/qwenproxy 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Local OpenAI-compatible proxy API that routes requests to Qwen (chat.qwen.ai) via Playwright browser automation.",
   "main": "index.js",
   "scripts": {

package/src/cache/memory-cache.ts

@@ -19,16 +19,34 @@ export class MemoryCache {
   private defaultTTL: number
   private prefix: string
   private cleanupInterval: NodeJS.Timeout | null
+  private maxEntries: number
+  private totalBytes: number
 
-  constructor(options?: { prefix?: string; defaultTTL?: number }) {
+  constructor(options?: { prefix?: string; defaultTTL?: number; maxEntries?: number }) {
     this.prefix = options?.prefix || 'qwenproxy:'
     this.defaultTTL = options?.defaultTTL || config.cache.defaultTTL
+    this.maxEntries = options?.maxEntries || 10000
     this.store = new Map()
+    this.totalBytes = 0
     this.cleanupInterval = null
 
     this.startCleanup()
   }
 
+  private entryByteSize(key: string, value: any): number {
+    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value))
+  }
+
+  private evictLRU(): void {
+    const oldest = this.store.keys().next()
+    if (!oldest.done) {
+      const evicted = this.store.get(oldest.value)
+      if (evicted) this.totalBytes -= this.entryByteSize(oldest.value, evicted.value)
+      this.store.delete(oldest.value)
+      metrics.increment('cache.evicted')
+    }
+  }
+
   private startCleanup(): void {
     this.cleanupInterval = setInterval(() => {
       const now = Date.now()
@@ -48,11 +66,22 @@ export class MemoryCache {
     const serialized = JSON.stringify(value)
     const effectiveTTL = ttl || this.defaultTTL
     const fullKey = this.prefix + key
+    const entrySize = this.entryByteSize(fullKey, value)
+    
+    if (this.store.has(fullKey)) {
+      const oldEntry = this.store.get(fullKey)
+      if (oldEntry) this.totalBytes -= this.entryByteSize(fullKey, oldEntry.value)
+    } else {
+      while (this.store.size >= this.maxEntries) {
+        this.evictLRU()
+      }
+    }
     
     this.store.set(fullKey, {
       value,
       expiresAt: Date.now() + (effectiveTTL * 1000)
     })
+    this.totalBytes += entrySize
     
     metrics.increment('cache.set')
     metrics.histogram('cache.value.size', Buffer.byteLength(serialized))
@@ -66,26 +95,39 @@ export class MemoryCache {
     metrics.histogram('cache.get.latency', Date.now() - start)
 
     if (!entry || entry.expiresAt <= Date.now()) {
-      if (entry) this.store.delete(fullKey)
+      if (entry) {
+        this.totalBytes -= this.entryByteSize(fullKey, entry.value)
+        this.store.delete(fullKey)
+      }
       metrics.increment('cache.miss')
       return null
     }
 
+    this.store.delete(fullKey)
+    this.store.set(fullKey, entry)
+
     metrics.increment('cache.hit')
     return entry.value as T
   }
 
   async delete(key: CacheKey): Promise<void> {
     const fullKey = this.prefix + key
-    this.store.delete(fullKey)
-    metrics.increment('cache.deleted')
+    const entry = this.store.get(fullKey)
+    if (entry) {
+      this.totalBytes -= this.entryByteSize(fullKey, entry.value)
+      this.store.delete(fullKey)
+      metrics.increment('cache.deleted')
+    }
   }
 
   async exists(key: CacheKey): Promise<boolean> {
     const fullKey = this.prefix + key
     const entry = this.store.get(fullKey)
     if (!entry || entry.expiresAt <= Date.now()) {
-      if (entry) this.store.delete(fullKey)
+      if (entry) {
+        this.totalBytes -= this.entryByteSize(fullKey, entry.value)
+        this.store.delete(fullKey)
+      }
       return false
     }
     return true
@@ -157,20 +199,10 @@ export class MemoryCache {
     keysCount?: number
     memoryUsage?: string
   }> {
-    const now = Date.now()
-    let validKeys = 0
-    let totalBytes = 0
-    for (const [key, entry] of this.store.entries()) {
-      if (entry.expiresAt > now) {
-        validKeys++
-        totalBytes += Buffer.byteLength(JSON.stringify(entry.value)) + Buffer.byteLength(key)
-      }
-    }
-    
     return {
       connected: true,
-      keysCount: validKeys,
-      memoryUsage: `${(totalBytes / 1024).toFixed(2)}KB`
+      keysCount: this.store.size,
+      memoryUsage: `${(this.totalBytes / 1024).toFixed(2)}KB`
     }
   }
 
@@ -180,6 +212,7 @@ export class MemoryCache {
       this.cleanupInterval = null
     }
     this.store.clear()
+    this.totalBytes = 0
   }
 }
 

package/src/routes/chat.ts

@@ -209,7 +209,7 @@ export async function chatCompletions(c: Context) {
       });
       const toolsJson = JSON.stringify(formattedTools, null, 2);
       
-      systemPrompt += `\n\n# TOOLS AVAILABLE\nYou have access to the following tools:\n${toolsJson}\n\n# TOOL CALLING FORMAT (MANDATORY)\nTo use a tool, you MUST output a JSON object wrapped EXACTLY in these tags:\n<tool_call>\n{"name": "tool_name", "arguments": {"param_name": "value"}}\n</tool_call>\n\nEXAMPLE OF MULTIPLE TOOL CALLS:\n<tool_call>\n{"name": "read_file", "arguments": {"path": "file1.txt"}}\n</tool_call>\n<tool_call>\n{"name": "read_file", "arguments": {"path": "file2.txt"}}\n</tool_call>\n\nCRITICAL RULES:\n1. ONLY use the tags above for tool calling. NEVER output raw JSON without tags.\n2. You can call multiple tools by outputting multiple <tool_call> blocks consecutively.\n3. Do NOT output any other text (explanations, chat, etc.) after your <tool_call> blocks. Wait for the user to provide the tool response.\n4. The JSON inside the tags MUST be valid and include ALL required braces and the "arguments" field.\n5. If you need to use a tool, do it IMMEDIATELY without preamble.\n\n`;
+      systemPrompt += `\n\n# TOOLS AVAILABLE\nYou have access to the following tools:\n${toolsJson}\n\n# TOOL CALLING FORMAT (MANDATORY)\nTo use a tool, you MUST output a JSON object wrapped EXACTLY in <tool_call> tags:\n\n<tool_call>\n{"name": "tool_name", "arguments": {"param_name": "value"}}\n</tool_call>\n\nEXAMPLE OF MULTIPLE TOOL CALLS:\n<tool_call>\n{"name": "read_file", "arguments": {"path": "file1.txt"}}\n</tool_call>\n<tool_call>\n{"name": "read_file", "arguments": {"path": "file2.txt"}}\n</tool_call>\n\nCRITICAL RULES:\n1. ONLY use the tags above for tool calling. NEVER output raw JSON without tags.\n2. You can call multiple tools by outputting multiple <tool_call> blocks consecutively.\n3. Do NOT output any other text (explanations, chat, etc.) after your <tool_call> blocks. Wait for the user to provide the tool response.\n4. The JSON inside the tags MUST be valid and include ALL required braces and the "arguments" field.\n5. If you need to use a tool, do it IMMEDIATELY without preamble.\n6. NEVER invent, guess, or hallucinate tool names. You MUST ONLY use the exact tool names provided in the 'TOOLS AVAILABLE' list above. Calling an unlisted tool will result in a hard execution error.\n\n`;
       
       if (bodyAny.tool_choice && typeof bodyAny.tool_choice === 'object' && bodyAny.tool_choice.function) {
         const forcedTool = bodyAny.tool_choice.function.name;
@@ -220,15 +220,22 @@ export async function chatCompletions(c: Context) {
     const modelId = body.model.replace('-no-thinking', '');
     const modelContextWindow = getModelContextWindow(modelId)
     const estimatedTokens = estimateTokenCount(systemPrompt + prompt);
+    const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
     
     let finalPrompt: string;
     if (estimatedTokens > modelContextWindow - 1000) {
       const truncated = truncateMessages(messages, modelContextWindow, systemPrompt);
-      finalPrompt = truncated.map(m => `${m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : m.role}: ${m.content}`).join('\n\n');
+      const truncatedBody = truncated.map(m => `${m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : m.role}: ${m.content}`).join('\n\n');
+      finalPrompt = systemPrompt ? `${systemPrompt}\n\n${truncatedBody}` : truncatedBody;
     } else {
       finalPrompt = systemPrompt ? `${systemPrompt}\n${prompt}` : prompt;
     }
 
+    // Reforço de instrução de tool call para contextos longos (mitiga "Lost in the Middle")
+    if (hasTools && estimatedTokens > 15000) {
+      finalPrompt += '\n\n[CRITICAL REMINDER: You MUST use the exact <tool_call> JSON format specified in the system instructions. Do not hallucinate tool names or output raw JSON without the tags.]';
+    }
+
     const isThinkingModel = !body.model.includes('no-thinking');
     
     // A session is new if it doesn't have any assistant messages yet.
@@ -641,7 +648,7 @@ export async function chatCompletions(c: Context) {
           // Periodic yielding to prevent event loop starvation
           chunkCount++;
           if (chunkCount % 100 === 0) {
-            await new Promise(r => setImmediate(r));
+            await new Promise(r => setTimeout(r, 0));
           }
         }
 

package/src/services/qwen.ts

@@ -66,6 +66,9 @@ interface WarmPoolEntry {
 const warmPool: Map<string, WarmPoolEntry[]> = (globalThis as any)._warmPool || new Map();
 (globalThis as any)._warmPool = warmPool;
 
+const refillPromises: Map<string, Promise<void>> = (globalThis as any)._refillPromises || new Map();
+(globalThis as any)._refillPromises = refillPromises;
+
 const WARM_POOL_SIZE = 5;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
 
@@ -128,15 +131,21 @@ async function refillPoolForAccount(accountId: string) {
   if (!pool) { pool = []; warmPool.set(accountId, pool); }
   cleanupStalePool(accountId);
   const need = Math.max(0, WARM_POOL_SIZE - pool.length);
-  for (let i = 0; i < need; i++) {
+  
+  const creationPromises = Array.from({ length: need }, async () => {
     try {
       const headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
       const chatId = await createRealQwenChat(headers);
-      pool.push({ chatId, headers, accountId, timestamp: Date.now() });
+      return { chatId, headers, accountId, timestamp: Date.now() };
     } catch (err) {
       console.error(`[WarmPool] refill failed for ${accountId}:`, (err as Error).message);
-      break;
+      return null;
     }
+  });
+  
+  const results = await Promise.all(creationPromises);
+  for (const entry of results) {
+    if (entry) pool.push(entry);
   }
 }
 
@@ -146,7 +155,10 @@ export async function getWarmedChat(accountId?: string) {
   if (!pool) { pool = []; warmPool.set(key, pool); }
   cleanupStalePool(key);
   if (pool.length === 0) {
-    await refillPoolForAccount(key);
+    if (!refillPromises.has(key)) {
+      refillPromises.set(key, refillPoolForAccount(key).finally(() => refillPromises.delete(key)));
+    }
+    await refillPromises.get(key);
   }
   if (pool.length === 0) throw new Error(`Warm pool empty for ${key}`);
   return pool.shift()!;

package/src/utils/context-truncation.ts

@@ -4,7 +4,35 @@ export interface TruncatedMessage {
 }
 
 export function estimateTokenCount(text: string): number {
-  return Math.ceil(text.length / 3.5);
+  // Divisor conservador (2.5) para evitar estouro silencioso do context window.
+  // Tokenizers modernos (como o do Qwen) usam ~1.5 a 2.5 caracteres por token
+  // para textos mistos (português, código, caracteres especiais).
+  return Math.ceil(text.length / 2.5);
+}
+
+function truncateSemantically(content: string, maxChars: number): string {
+  if (content.length <= maxChars) return content;
+  
+  const truncated = content.slice(0, maxChars);
+  
+  if (truncated.trimStart().startsWith('{') || truncated.trimStart().startsWith('[')) {
+    const lastBrace = Math.max(truncated.lastIndexOf('}'), truncated.lastIndexOf(']'));
+    if (lastBrace > maxChars * 0.7) {
+      return truncated.slice(0, lastBrace + 1) + ' /* truncated */';
+    }
+  }
+  
+  const lastNewline = truncated.lastIndexOf('\n');
+  if (lastNewline > maxChars * 0.8) {
+    return truncated.slice(0, lastNewline) + '\n[Truncated]';
+  }
+  
+  const lastSpace = truncated.lastIndexOf(' ');
+  if (lastSpace > maxChars * 0.9) {
+    return truncated.slice(0, lastSpace) + '... [Truncated]';
+  }
+  
+  return truncated + '... [Truncated]';
 }
 
 export function truncateMessages(
@@ -39,13 +67,14 @@ export function truncateMessages(
     const msgTokens = estimateTokenCount(msg.content);
     
     if (usedTokens + msgTokens <= availableTokens) {
-      result.unshift(msg);
+      result.push(msg);
       usedTokens += msgTokens;
     } else {
       const remainingTokens = availableTokens - usedTokens;
       if (remainingTokens > 100) {
-        const truncatedContent = msg.content.slice(0, remainingTokens * 3.5);
-        result.unshift({ role: msg.role, content: `[Truncated] ${truncatedContent}...` });
+        const maxChars = Math.floor(remainingTokens * 2.5);
+        const truncatedContent = truncateSemantically(msg.content, maxChars);
+        result.push({ role: msg.role, content: `[Truncated] ${truncatedContent}` });
       }
       break;
     }
@@ -53,9 +82,11 @@ export function truncateMessages(
   
   if (result.length === 0 && normalizedMessages.length > 0) {
     const lastMsg = normalizedMessages[normalizedMessages.length - 1];
-    const truncatedContent = lastMsg.content.slice(0, Math.max(200, availableTokens * 3.5));
-    result.push({ role: lastMsg.role, content: `[Truncated] ${truncatedContent}...` });
+    const maxChars = Math.max(200, Math.floor(availableTokens * 2.5));
+    const truncatedContent = truncateSemantically(lastMsg.content, maxChars);
+    result.push({ role: lastMsg.role, content: `[Truncated] ${truncatedContent}` });
   }
   
+  result.reverse();
   return result;
 }