@pedrofariasx/qwenproxy 1.2.1 → 1.2.3

package/README.md

@@ -39,7 +39,7 @@ graph TD
     Playwright --> Browser2[Browser - Conta 2]
     Playwright --> BrowserN[Browser - Conta N]
     Handler --> QwenAPI[chat.qwen.ai]
-    Handler --> Tools[Tool Executor]
+    Handler --> Tools[Tool Parser]
 
     subgraph "Persistência"
         Accounts
@@ -233,24 +233,14 @@ qwenproxy/
 │   │   ├── model-registry.ts    # Registro de modelos e context windows
 │   │   ├── stream-registry.ts   # Tracking de streams ativos
 │   │   └── watchdog.ts          # Health monitoring
-│   ├── linter/
-│   │   ├── bar.ts               # Facade
-│   │   ├── extraction-engine.ts # Extraction engine
-│   │   ├── foo.ts               # Exports
-│   │   ├── index.ts             # Main public API
-│   │   ├── repair-normalize.ts  # Repair and normalize
-│   │   ├── safety-gate.ts       # Safety gate
-│   │   ├── streaming-state-machine.ts # Streaming state machine
-│   │   ├── structural-parser.ts # Structural parser
-│   │   └── types.ts             # Types
 │   ├── routes/
-│   │   └── chat.ts              # Handler /v1/chat/completions
+│   │   ├── chat.ts              # Handler /v1/chat/completions
+│   │   └── upload.ts            # Handler /v1/upload (multimodal)
 │   ├── services/
 │   │   ├── playwright.ts        # Automação de navegador
 │   │   └── qwen.ts              # Integração com API do Qwen
 │   ├── tests/                   # Testes automatizados
 │   ├── tools/
-│   │   ├── executor.ts          # Execução de ferramentas
 │   │   ├── parser.ts            # Parser de <tool_call> tags
 │   │   ├── registry.ts          # Registro de tools
 │   │   ├── schema.ts            # Validação JSON Schema

package/package.json

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

package/src/api/server.ts

@@ -70,10 +70,10 @@ app.notFound((c) => c.json({ error: 'Not found' }, 404))
 export async function startServer(): Promise<void> {
   await cache.connect()
 
-  const { loadAccounts } = await import('../core/accounts.ts')
+  const { loadAccounts } = await import('../core/accounts.js')
   const accounts = loadAccounts()
 
-  const { initPlaywright, initPlaywrightForAccount, getQwenHeaders } = await import('../services/playwright.ts')
+  const { initPlaywright, initPlaywrightForAccount, getQwenHeaders } = await import('../services/playwright.js')
   
   await initPlaywright(config.browser.headless)
   
@@ -87,7 +87,7 @@ export async function startServer(): Promise<void> {
       )
     )
     console.log('[Server] Pre-fetching headers for all accounts in background...')
-    const { warmAllPools } = await import('../services/qwen.ts')
+    const { warmAllPools } = await import('../services/qwen.js')
     warmAllPools(accounts.map(a => a.id)).catch(() => {})
   }
 
@@ -111,9 +111,7 @@ export async function startServer(): Promise<void> {
     await cache.close()
     const { closePlaywright } = await import('../services/playwright.js')
     await closePlaywright()
-    const { cleanupAllAccountMutexes } = await import('../routes/chat.js')
-    cleanupAllAccountMutexes()
-    const { closeDatabase } = await import('../core/database.ts')
+    const { closeDatabase } = await import('../core/database.js')
     closeDatabase()
     server?.close()
     process.exit(0)

package/src/cache/memory-cache.ts

@@ -21,6 +21,7 @@ export class MemoryCache {
   private cleanupInterval: NodeJS.Timeout | null
   private maxEntries: number
   private totalBytes: number
+  private scanRegexCache: Map<string, RegExp>
 
   constructor(options?: { prefix?: string; defaultTTL?: number; maxEntries?: number }) {
     this.prefix = options?.prefix || 'qwenproxy:'
@@ -29,12 +30,14 @@ export class MemoryCache {
     this.store = new Map()
     this.totalBytes = 0
     this.cleanupInterval = null
+    this.scanRegexCache = new Map()
 
     this.startCleanup()
   }
 
   private entryByteSize(key: string, value: any): number {
-    return Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value))
+    const valueStr = typeof value === 'string' ? value : JSON.stringify(value)
+    return Buffer.byteLength(key) + Buffer.byteLength(valueStr || '')
   }
 
   private evictLRU(): void {
@@ -63,7 +66,6 @@ export class MemoryCache {
   }
 
   async set<T>(key: CacheKey, value: T, ttl?: number): Promise<void> {
-    const serialized = JSON.stringify(value)
     const effectiveTTL = ttl || this.defaultTTL
     const fullKey = this.prefix + key
     const entrySize = this.entryByteSize(fullKey, value)
@@ -84,7 +86,7 @@ export class MemoryCache {
     this.totalBytes += entrySize
     
     metrics.increment('cache.set')
-    metrics.histogram('cache.value.size', Buffer.byteLength(serialized))
+    metrics.histogram('cache.value.size', entrySize)
   }
 
   async get<T>(key: CacheKey): Promise<T | null> {

package/src/core/account-manager.ts

@@ -1,4 +1,4 @@
-import { QwenAccount, loadAccounts } from './accounts.ts'
+import { QwenAccount, loadAccounts } from './accounts.js'
 import { config } from './config.js'
 
 let currentIndex = 0

package/src/core/accounts.ts

@@ -1,5 +1,5 @@
 import crypto from 'crypto'
-import { getDatabase } from './database.ts'
+import { getDatabase } from './database.js'
 import { config } from './config.js'
 
 export interface QwenAccount {

package/src/login.ts

@@ -1,5 +1,5 @@
-import { addAccount, removeAccount, listAccounts, getAccountCredentials, QwenAccount } from './core/accounts.ts'
-import { initPlaywrightForAccount, closePlaywrightForAccount, BrowserType, launchManualLoginAccount, extractAccountInfoFromContext } from './services/playwright.ts'
+import { addAccount, removeAccount, listAccounts, getAccountCredentials, QwenAccount } from './core/accounts.js'
+import { initPlaywrightForAccount, closePlaywrightForAccount, BrowserType, launchManualLoginAccount, extractAccountInfoFromContext } from './services/playwright.js'
 import * as readline from 'readline'
 import * as dotenv from 'dotenv'
 

package/src/routes/chat.ts

@@ -10,48 +10,85 @@
 
 import { Context } from 'hono';
 import { stream as honoStream } from 'hono/streaming';
-import { v4 as uuidv4 } from 'uuid';
-import { createQwenStream, updateSessionParent } from '../services/qwen.ts';
-import { OpenAIRequest, ChoiceDelta, Message } from '../utils/types.ts';
-import { registry } from '../tools/registry.ts';
-import type { FunctionToolDefinition } from '../tools/types.ts';
-import { robustParseJSON } from '../utils/json.ts';
-import { StreamingToolParser } from '../tools/parser.ts';
-import { QwenStreamParser, ParsedChunkResult } from '../utils/qwen-stream-parser.ts';
-import { RetryableQwenStreamError } from '../services/qwen.ts';
+import crypto from 'crypto';
+import { createQwenStream, updateSessionParent, RetryableQwenStreamError } from '../services/qwen.js';
+import { OpenAIRequest, ChoiceDelta, Message } from '../utils/types.js';
+import { registry } from '../tools/registry.js';
+import type { FunctionToolDefinition } from '../tools/types.js';
+import { robustParseJSON } from '../utils/json.js';
+import { StreamingToolParser } from '../tools/parser.js';
+import { QwenStreamParser, ParsedChunkResult } from '../utils/qwen-stream-parser.js';
 import { getModelContextWindow } from '../core/model-registry.js'
-import { truncateMessages, estimateTokenCount } from '../utils/context-truncation.ts';
-import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAccountCooldownInfo } from '../core/account-manager.ts';
-import { registerStream, removeStream, getStream } from '../core/stream-registry.ts';
+import { truncateMessages, estimateTokenCount } from '../utils/context-truncation.js';
+import { getNextAccount, getNextAvailableAccount, markAccountRateLimited, getAccountCooldownInfo } from '../core/account-manager.js';
+import { registerStream, removeStream, getStream } from '../core/stream-registry.js';
 import { metrics } from '../core/metrics.js'
 
-export function cleanupAllAccountMutexes(): void {
-  // No-op - kept for backward compatibility
-}
-
 export interface DeltaResult {
   delta: string;
   matchedContent: string;
+  contentLength: number;
+  contentSuffix: string;
 }
 
-export function getIncrementalDelta(oldStr: string, newStr: string): DeltaResult {
+export function getIncrementalDelta(oldStr: string, newStr: string, prevLength: number = 0, prevSuffix: string = ''): DeltaResult {
   if (!oldStr) {
-    return { delta: newStr, matchedContent: newStr };
+    return { 
+      delta: newStr, 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
   if (newStr === oldStr) {
-    return { delta: '', matchedContent: oldStr };
+    return { delta: '', matchedContent: oldStr, contentLength: prevLength, contentSuffix: prevSuffix };
   }
 
-  // Fast path: incremental SSE streams append to oldStr most of the time
+  // Ultra-fast path: use length tracking to avoid O(n) startsWith on large strings
+  if (newStr.length > prevLength && prevLength > 0) {
+    const delta = newStr.slice(prevLength);
+    const checkLen = Math.min(64, prevLength);
+    const expectedSuffix = prevSuffix.slice(-checkLen);
+    const actualSuffix = newStr.slice(prevLength - checkLen, prevLength);
+    
+    if (expectedSuffix === actualSuffix) {
+      if (delta.length <= 4 && oldStr.length > 2000) {
+        return { 
+          delta: newStr, 
+          matchedContent: oldStr + newStr,
+          contentLength: newStr.length,
+          contentSuffix: newStr.slice(-64)
+        };
+      }
+      return { 
+        delta, 
+        matchedContent: newStr,
+        contentLength: newStr.length,
+        contentSuffix: newStr.slice(-64)
+      };
+    }
+  }
+
+  // Fallback: startsWith check for edge cases
   if (newStr.startsWith(oldStr)) {
     const delta = newStr.slice(oldStr.length);
     if (delta.length <= 4 && oldStr.length > 2000) {
-      return { delta: newStr, matchedContent: oldStr + newStr };
+      return { 
+        delta: newStr, 
+        matchedContent: oldStr + newStr,
+        contentLength: newStr.length,
+        contentSuffix: newStr.slice(-64)
+      };
     }
-    return { delta, matchedContent: newStr };
+    return { 
+      delta, 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
 
-  // Fallback: segment-based prefix matching
+  // Segment-based prefix matching (rare path)
   const scanWindow = Math.min(2000, oldStr.length);
   const maxLen = Math.min(scanWindow, newStr.length);
 
@@ -65,17 +102,27 @@ export function getIncrementalDelta(oldStr: string, newStr: string): DeltaResult
     commonPrefixLen += segmentLen;
   }
 
-  // Fine-grained scan within the mismatching segment
   while (commonPrefixLen < maxLen && oldStr[commonPrefixLen] === newStr[commonPrefixLen]) {
     commonPrefixLen++;
   }
 
   const threshold = Math.min(scanWindow, 4);
   if (commonPrefixLen >= threshold) {
-    return { delta: newStr.substring(commonPrefixLen), matchedContent: newStr };
+    return { 
+      delta: newStr.substring(commonPrefixLen), 
+      matchedContent: newStr,
+      contentLength: newStr.length,
+      contentSuffix: newStr.slice(-64)
+    };
   }
 
-  return { delta: newStr, matchedContent: oldStr + newStr };
+  const combined = oldStr + newStr;
+  return { 
+    delta: newStr, 
+    matchedContent: combined,
+    contentLength: combined.length,
+    contentSuffix: combined.slice(-64)
+  };
 }
 
 function parseQwenErrorPayload(raw: string): { message: string; status: number } | null {
@@ -119,29 +166,26 @@ export async function chatCompletions(c: Context) {
       const msg = messages[i];
       let contentStr = '';
       if (Array.isArray(msg.content)) {
-        // Handle multimodal content (text + images + videos + audio + files)
-        const multimodalParts = msg.content.filter(
-          (p: any) =>
+        // Single-pass: extract text and multimodal parts in one iteration
+        const textParts: string[] = [];
+        const multimodalParts: Array<{ type: string; text?: string; image_url?: { url: string }; video_url?: { url: string }; audio_url?: { url: string }; file_url?: { url: string } }> = [];
+        
+        for (const p of msg.content as any[]) {
+          if (p.type === "text" && p.text) {
+            textParts.push(p.text);
+          } else if (
             (p.type === "image_url" && p.image_url?.url) ||
             (p.type === "video_url" && p.video_url?.url) ||
             (p.type === "audio_url" && p.audio_url?.url) ||
-            (p.type === "file_url" && p.file_url?.url),
-        );
-
+            (p.type === "file_url" && p.file_url?.url)
+          ) {
+            multimodalParts.push(p);
+          }
+        }
+        
+        contentStr = textParts.join("\n");
         if (multimodalParts.length > 0) {
-          // Defer processing to after account selection to reuse cached headers
           pendingMultimodal.push(multimodalParts);
-          // Extract text parts for prompt building
-          contentStr = msg.content
-            .filter((p: any) => p.type === "text")
-            .map((p: any) => p.text)
-            .join("\n");
-        } else {
-          // No multimodal parts, just extract text
-          contentStr = msg.content
-            .filter((p: any) => p.type === "text")
-            .map((p: any) => p.text)
-            .join("\n");
         }
       } else if (typeof msg.content === 'object' && msg.content !== null) {
         contentStr = JSON.stringify(msg.content);
@@ -244,12 +288,12 @@ export async function chatCompletions(c: Context) {
 
     // Account selection with fallback on rate-limit/failure
     let account = getNextAccount();
-    let triedAccountIds = new Set<string>();
+    const triedAccountIds = new Set<string>();
     let lastError: any = null;
 
     let stream: ReadableStream | undefined;
     let uiSessionId = '';
-    const completionId = 'chatcmpl-' + uuidv4();
+    const completionId = 'chatcmpl-' + crypto.randomUUID();
 
     while (account) {
       const accountId = account.id;
@@ -350,7 +394,6 @@ export async function chatCompletions(c: Context) {
 
       const toolCallsOut: any[] = [];
       let buffer = '';
-      const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
 
       const qwenParser = new QwenStreamParser(uiSessionId, {
         tools: hasTools ? bodyAny.tools : [],
@@ -476,10 +519,18 @@ export async function chatCompletions(c: Context) {
           finish_reason: finishReason
         });
 
-        // Pre-compute timestamp once before the stream loop
         const createdTimestamp = Math.floor(Date.now() / 1000);
 
-        // Send initial chunk
+        const fastWriteContent = (content: string) => {
+          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
+        };
+
+        const fastWriteReasoning = (content: string) => {
+          const escaped = content.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+          streamWriter.write(`data: {"id":"${completionId}","object":"chat.completion.chunk","created":${createdTimestamp},"model":"${body.model}","choices":[{"index":0,"delta":{"reasoning_content":"${escaped}"},"logprobs":null,"finish_reason":null}]}\n\n`);
+        };
+
         writeEvent({
           id: completionId,
           object: 'chat.completion.chunk',
@@ -493,34 +544,35 @@ export async function chatCompletions(c: Context) {
 
         let reasoningBuffer = '';
         let lastFullContent = '';
+        let contentLength = 0;
+        let contentSuffix = '';
         let targetResponseId: string | null = null;
         let targetResponseIdSet = false;
         let currentThoughtIndex = 0;
-        const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
         const toolParser = hasTools ? new StreamingToolParser(bodyAny.tools) : null;
 
         let buffer = '';
+        let bufferOffset = 0;
         let completionTokens = 0;
         let promptTokens = Math.ceil(finalPrompt.length / 3.5);
 
-        // Real-time flush: send each event immediately to minimize latency
-        let chunkCount = 0;
         while (true) {
           const { done, value } = await reader.read();
           if (done) break;
 
           buffer += decoder.decode(value, { stream: true });
 
-           let startIdx = 0;
-           let newlineIdx: number;
-           while ((newlineIdx = buffer.indexOf('\n', startIdx)) !== -1) {
-             const line = buffer.slice(startIdx, newlineIdx);
-             startIdx = newlineIdx + 1;
+          while (bufferOffset < buffer.length) {
+            const newlineIdx = buffer.indexOf('\n', bufferOffset);
+            if (newlineIdx === -1) break;
+            
+            const line = buffer.slice(bufferOffset, newlineIdx);
+            bufferOffset = newlineIdx + 1;
 
-             const trimmed = line.trim();
-             if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
 
-             const dataStr = trimmed.slice(6);
+            const dataStr = trimmed.slice(6);
              if (dataStr === '[DONE]') {
                streamWriter.write('data: [DONE]\n\n');
                continue;
@@ -569,10 +621,12 @@ export async function chatCompletions(c: Context) {
                   isThinkingChunk = false;
                   if (delta.content !== undefined) {
                     const newContent = delta.content || '';
-                    const result = getIncrementalDelta(lastFullContent, newContent);
+                    const result = getIncrementalDelta(lastFullContent, newContent, contentLength, contentSuffix);
                     vStr = result.delta;
                     if (vStr) {
                       lastFullContent = result.matchedContent;
+                      contentLength = result.contentLength;
+                      contentSuffix = result.contentSuffix;
                       foundStr = true;
                     }
                   }
@@ -584,24 +638,12 @@ export async function chatCompletions(c: Context) {
 
                 if (isThinkingChunk) {
                   reasoningBuffer += vStr;
-                  streamWriter.write(`data: ${JSON.stringify({
-                    id: completionId,
-                    object: 'chat.completion.chunk',
-                    created: createdTimestamp,
-                    model: body.model,
-                    choices: [makeChoice({ reasoning_content: vStr })]
-                  })}\n\n`);
+                  fastWriteReasoning(vStr);
                 } else {
                   if (hasTools && toolParser) {
                     const { text, toolCalls } = toolParser.feed(vStr);
                     if (text) {
-                      streamWriter.write(`data: ${JSON.stringify({
-                        id: completionId,
-                        object: 'chat.completion.chunk',
-                        created: createdTimestamp,
-                        model: body.model,
-                        choices: [makeChoice({ content: text })]
-                      })}\n\n`);
+                      fastWriteContent(text);
                     }
                     for (const tc of toolCalls) {
                       streamWriter.write(`data: ${JSON.stringify({
@@ -624,13 +666,7 @@ export async function chatCompletions(c: Context) {
                     }
                   } else {
                     if (vStr) {
-                      streamWriter.write(`data: ${JSON.stringify({
-                        id: completionId,
-                        object: 'chat.completion.chunk',
-                        created: createdTimestamp,
-                        model: body.model,
-                        choices: [makeChoice({ content: vStr })]
-                      })}\n\n`);
+                      fastWriteContent(vStr);
                     }
                   }
                 }
@@ -640,16 +676,11 @@ export async function chatCompletions(c: Context) {
             }
           }
 
-          // Trim processed portion from buffer
-          if (startIdx > 0) {
-            buffer = buffer.slice(startIdx);
+          if (bufferOffset > 0) {
+            buffer = buffer.slice(bufferOffset);
+            bufferOffset = 0;
           }
 
-          // Periodic yielding to prevent event loop starvation
-          chunkCount++;
-          if (chunkCount % 100 === 0) {
-            await new Promise(r => setTimeout(r, 0));
-          }
         }
 
         const upstreamError = parseQwenErrorPayload(buffer);
@@ -782,7 +813,7 @@ export async function chatCompletionsStop(c: Context) {
         'Sec-Fetch-Mode': 'cors',
         'Sec-Fetch-Site': 'same-origin',
         'User-Agent': stream.headers['user-agent'],
-        'X-Request-Id': uuidv4(),
+        'X-Request-Id': crypto.randomUUID(),
         'bx-ua': stream.headers['bx-ua'],
         'bx-umidtoken': stream.headers['bx-umidtoken'],
         'bx-v': stream.headers['bx-v'],

package/src/routes/upload.ts

@@ -5,8 +5,8 @@
  */
 
 import { Context } from "hono";
-import { getQwenHeaders } from "../services/playwright.ts";
-import { v4 as uuidv4 } from "uuid";
+import { getQwenHeaders } from "../services/playwright.js";
+import crypto from "crypto";
 
 interface STSResponse {
   success: boolean;
@@ -46,7 +46,7 @@ async function getSTSToken(
           Origin: "https://chat.qwen.ai",
           Referer: "https://chat.qwen.ai/",
           "User-Agent": headers["user-agent"],
-          "X-Request-Id": uuidv4(),
+          "X-Request-Id": crypto.randomUUID(),
           "bx-ua": headers["bx-ua"],
           "bx-umidtoken": headers["bx-umidtoken"],
           "bx-v": headers["bx-v"],
@@ -723,11 +723,11 @@ export async function processImagesForQwen(
           greenNet: "success",
           size: fileSize,
           error: "",
-          itemId: uuidv4(),
+          itemId: crypto.randomUUID(),
           file_type: typeInfo.mime,
           showType: typeInfo.showType,
           file_class: typeInfo.fileClass,
-          uploadTaskId: uuidv4(),
+          uploadTaskId: crypto.randomUUID(),
         });
       }
     }