@pedrofariasx/qwenproxy 1.2.3 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.2.3",
+  "version": "1.3.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/api/models.ts

@@ -4,6 +4,7 @@ import { getBasicHeaders } from '../services/playwright.js'
 import { loadAccounts } from '../core/accounts.js'
 import { getAccountCooldownInfo } from '../core/account-manager.js'
 import { cache } from '../cache/memory-cache.js'
+import { syncModelContextWindows } from '../core/model-registry.js'
 
 const app = new Hono()
 
@@ -80,7 +81,7 @@ app.get('/v1/models', async (c) => {
       ],
     }
 
-    // Cache the formatted models list for 5 minutes (300 seconds)
+    syncModelContextWindows(formatted.data)
     await cache.set(cacheKey, formatted, 300)
     
     return c.json(formatted)
@@ -163,6 +164,7 @@ app.get('/v1/models/:model', async (c) => {
         ],
       }
 
+      syncModelContextWindows(formatted.data)
       await cache.set(cacheKey, formatted, 300)
       models = formatted.data
     }

package/src/core/model-registry.ts

@@ -1,16 +1,58 @@
 const modelContextWindows: Record<string, number> = {
-  'qwen-max': 32768,
-  'qwen-max-latest': 32768,
-  'qwen-plus': 131072,
-  'qwen-plus-latest': 131072,
-  'qwen-turbo': 131072,
-  'qwen-turbo-latest': 131072,
-  'qwen-long': 1000000,
-  'qwen-coder': 131072,
-  'qwen-coder-plus': 131072,
+  'qwen3.7-plus': 1000000,
+  'qwen3.7-max': 1000000,
+  'qwen3.6-plus': 1000000,
+  'qwen3.6-plus-preview': 1000000,
+  'qwen3.6-max-preview': 262144,
+  'qwen3.6-27b': 262144,
+  'qwen3.6-35b-a3b': 262144,
+  'qwen3.5-plus': 1000000,
+  'qwen3.5-flash': 1000000,
+  'qwen3.5-omni-plus': 262144,
+  'qwen3.5-omni-flash': 262144,
+  'qwen3.5-max-2026-03-08': 262144,
+  'qwen3.5-397b-a17b': 262144,
+  'qwen3.5-122b-a10b': 262144,
+  'qwen3.5-27b': 262144,
+  'qwen3.5-35b-a3b': 262144,
+  'qwen3-max-2026-01-23': 262144,
+  'qwen3-coder-plus': 1048576,
+  'qwen3-vl-plus': 262144,
+  'qwen3-omni-flash-2025-12-01': 65536,
+  'qwen-plus-2025-07-28': 131072,
+  'qwen-latest-series-invite-beta-v24': 262144,
+  'qwen-latest-series-invite-beta-v16': 1000000,
+}
+
+const modelTokenDivisors: Record<string, number> = {
+  'qwen3.7-max': 2.2,
+  'qwen3.6-max-preview': 2.2,
+  'qwen3.5-max-2026-03-08': 2.2,
+  'qwen3-max-2026-01-23': 2.2,
+  'qwen-latest-series-invite-beta-v24': 2.2,
+  'qwen3.7-plus': 2.0,
+  'qwen3.6-plus': 2.0,
+  'qwen3.6-plus-preview': 2.0,
+  'qwen3.5-plus': 2.0,
+  'qwen-plus-2025-07-28': 2.0,
+  'qwen-latest-series-invite-beta-v16': 2.0,
+  'qwen3.5-flash': 1.8,
+  'qwen3.5-omni-plus': 1.8,
+  'qwen3.5-omni-flash': 1.7,
+  'qwen3-omni-flash-2025-12-01': 1.7,
+  'qwen3.5-397b-a17b': 1.9,
+  'qwen3.5-122b-a10b': 1.9,
+  'qwen3.6-35b-a3b': 1.9,
+  'qwen3.5-35b-a3b': 1.9,
+  'qwen3.6-27b': 1.9,
+  'qwen3.5-27b': 1.9,
+  'qwen3-coder-plus': 2.3,
+  'qwen3-vl-plus': 2.1,
 }
 
 const defaultContextWindow = 131072
+const defaultTokenDivisor = 2.0
+export const MAX_PAYLOAD_SIZE = 10 * 1024 * 1024
 
 export function setModelContextWindow(modelId: string, contextWindow: number): void {
   modelContextWindows[modelId] = contextWindow
@@ -21,6 +63,11 @@ export function getModelContextWindow(modelId: string): number {
   return modelContextWindows[baseId] ?? defaultContextWindow
 }
 
+export function getModelTokenDivisor(modelId: string): number {
+  const baseId = modelId.replace('-no-thinking', '')
+  return modelTokenDivisors[baseId] ?? defaultTokenDivisor
+}
+
 export function syncModelContextWindows(models: Array<{ id: string; context_window?: number }>): void {
   for (const m of models) {
     if (m.context_window) {

package/src/routes/chat.ts

@@ -52,14 +52,6 @@ export function getIncrementalDelta(oldStr: string, newStr: string, prevLength:
     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,
@@ -72,14 +64,6 @@ export function getIncrementalDelta(oldStr: string, newStr: string, prevLength:
   // 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,
-        contentLength: newStr.length,
-        contentSuffix: newStr.slice(-64)
-      };
-    }
     return { 
       delta, 
       matchedContent: newStr,
@@ -263,12 +247,12 @@ export async function chatCompletions(c: Context) {
 
     const modelId = body.model.replace('-no-thinking', '');
     const modelContextWindow = getModelContextWindow(modelId)
-    const estimatedTokens = estimateTokenCount(systemPrompt + prompt);
+    const estimatedTokens = estimateTokenCount(systemPrompt + prompt, modelId);
     const hasTools = Array.isArray(bodyAny.tools) && bodyAny.tools.length > 0;
     
     let finalPrompt: string;
     if (estimatedTokens > modelContextWindow - 1000) {
-      const truncated = truncateMessages(messages, modelContextWindow, systemPrompt);
+      const truncated = truncateMessages(messages, modelContextWindow, systemPrompt, modelId);
       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 {
@@ -672,7 +656,9 @@ export async function chatCompletions(c: Context) {
                 }
               }
             } catch (e) {
-              // parse error, ignore partial chunk
+              if (dataStr.length > 10) {
+                console.warn(`[Chat] SSE parse error for chunk (${dataStr.length} chars):`, (e as Error).message);
+              }
             }
           }
 

package/src/services/playwright.ts

@@ -68,6 +68,49 @@ const REFRESH_THRESHOLD = 0.7;
 
 const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
+function getStealthScript(): string {
+  return `
+    Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
+    Object.defineProperty(navigator, 'plugins', {
+      get: () => [1, 2, 3, 4, 5],
+    });
+    Object.defineProperty(navigator, 'languages', {
+      get: () => ['pt-BR', 'pt', 'en-US', 'en'],
+    });
+    Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8 });
+    Object.defineProperty(navigator, 'deviceMemory', { get: () => 8 });
+    Object.defineProperty(navigator, 'platform', { get: () => 'Win32' });
+    Object.defineProperty(screen, 'colorDepth', { get: () => 24 });
+    Object.defineProperty(screen, 'pixelDepth', { get: () => 24 });
+    window.chrome = {
+      runtime: {},
+      loadTimes: function() {},
+      csi: function() {},
+      app: {},
+    };
+    const originalQuery = window.navigator.permissions.query;
+    window.navigator.permissions.query = (parameters) =>
+      parameters.name === 'notifications'
+        ? Promise.resolve({ state: Notification.permission })
+        : originalQuery(parameters);
+    const getParameter = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(parameter) {
+      if (parameter === 37445) return 'Intel Inc.';
+      if (parameter === 37446) return 'Intel Iris OpenGL Engine';
+      return getParameter.apply(this, arguments);
+    };
+    Object.defineProperty(navigator, 'connection', {
+      get: () => ({
+        effectiveType: '4g',
+        rtt: 50,
+        downlink: 10,
+        saveData: false,
+      }),
+    });
+    delete navigator.__proto__.webdriver;
+  `;
+}
+
 export class Mutex {
   private queue: (() => void)[] = [];
   private locked = false;
@@ -169,15 +212,15 @@ export async function initPlaywright(headless = true, browserType: BrowserType =
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
-      '--disable-blink-features=AutomationControlled'
+      '--disable-blink-features=AutomationControlled',
+      '--disable-features=IsolateOrigins,site-per-process',
+      '--disable-infobars',
+      '--no-first-run',
+      '--no-default-browser-check',
     ]
   });
 
-  await context.addInitScript(() => {
-    Object.defineProperty(navigator, 'webdriver', {
-      get: () => undefined,
-    });
-  });
+  await context.addInitScript(getStealthScript());
 
   activePage = await context.newPage();
 
@@ -302,7 +345,9 @@ export async function getQwenHeaders(forceNew = false, accountId?: string): Prom
     if (age < HEADERS_TTL) {
       if (age > HEADERS_TTL * REFRESH_THRESHOLD && !cache.refreshInProgress) {
         cache.refreshInProgress = true;
-        getQwenHeaders(true, accountId).finally(() => {
+        getQwenHeaders(true, accountId).catch((err) => {
+          console.warn(`[Playwright] Background header refresh failed for ${cacheKey}:`, (err as Error).message);
+        }).finally(() => {
           cache.refreshInProgress = false;
         });
       }
@@ -584,15 +629,15 @@ export async function initPlaywrightForAccount(account: QwenAccount, headless =
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
-      '--disable-blink-features=AutomationControlled'
+      '--disable-blink-features=AutomationControlled',
+      '--disable-features=IsolateOrigins,site-per-process',
+      '--disable-infobars',
+      '--no-first-run',
+      '--no-default-browser-check',
     ]
   });
 
-  await acctContext.addInitScript(() => {
-    Object.defineProperty(navigator, 'webdriver', {
-      get: () => undefined,
-    });
-  });
+  await acctContext.addInitScript(getStealthScript());
 
   const acctPage = await acctContext.newPage();
   accountContexts.set(account.id, acctContext);
@@ -616,15 +661,15 @@ export async function launchManualLoginAccount(accountId: string, browserType: B
     userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
     ignoreDefaultArgs: ['--enable-automation'],
     args: [
-      '--disable-blink-features=AutomationControlled'
+      '--disable-blink-features=AutomationControlled',
+      '--disable-features=IsolateOrigins,site-per-process',
+      '--disable-infobars',
+      '--no-first-run',
+      '--no-default-browser-check',
     ]
   });
 
-  await acctContext.addInitScript(() => {
-    Object.defineProperty(navigator, 'webdriver', {
-      get: () => undefined,
-    });
-  });
+  await acctContext.addInitScript(getStealthScript());
 
   const acctPage = await acctContext.newPage();
   await acctPage.goto('https://chat.qwen.ai/auth', { waitUntil: 'domcontentloaded' });

package/src/services/qwen.ts

@@ -1,7 +1,24 @@
 import { getQwenHeaders, getBasicHeaders } from './playwright.js';
+import { MAX_PAYLOAD_SIZE } from '../core/model-registry.js';
 import crypto from 'crypto';
 
 const CACHED_TIMEZONE = new Date().toString().split(' (')[0];
+const BASE_TIMEOUT_MS = 120000;
+const TIMEOUT_PER_MB = 30000;
+
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+function getClientHintsHeaders(): Record<string, string> {
+  return {
+    'sec-ch-ua': '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"Windows"',
+  };
+}
+
+function getRandomDelay(): number {
+  return 200 + Math.floor(Math.random() * 600);
+}
 
 export class RetryableQwenStreamError extends Error {
   readonly retryAfterMs: number;
@@ -80,11 +97,13 @@ function cleanupStalePool(accountId: string) {
 }
 
 async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, string>> {
-  const { cookie, userAgent, bxV } = await getBasicHeaders(accountId);
+  const { cookie, userAgent, bxV, bxUa, bxUmidtoken } = await getBasicHeaders(accountId);
   return {
     cookie,
     'user-agent': userAgent,
     'bx-v': bxV,
+    'bx-ua': bxUa || '',
+    'bx-umidtoken': bxUmidtoken || '',
   };
 }
 
@@ -101,6 +120,9 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       'user-agent': header['user-agent'],
       'x-request-id': crypto.randomUUID(),
       'bx-v': header['bx-v'],
+      'bx-ua': header['bx-ua'] || '',
+      'bx-umidtoken': header['bx-umidtoken'] || '',
+      ...getClientHintsHeaders(),
     },
     body: JSON.stringify({
       title: 'Nova Conversa',
@@ -129,7 +151,19 @@ async function refillPoolForAccount(accountId: string) {
 
   let headers: Record<string, string>;
   try {
-    headers = await getBasicQwenHeaders(accountId === 'global' ? undefined : accountId);
+    const acctId = accountId === 'global' ? undefined : accountId;
+    try {
+      const { headers: fullHeaders } = await getQwenHeaders(false, acctId);
+      headers = {
+        cookie: fullHeaders['cookie'] || '',
+        'user-agent': fullHeaders['user-agent'] || '',
+        'bx-v': fullHeaders['bx-v'] || '',
+        'bx-ua': fullHeaders['bx-ua'] || '',
+        'bx-umidtoken': fullHeaders['bx-umidtoken'] || '',
+      };
+    } catch {
+      headers = await getBasicQwenHeaders(acctId);
+    }
   } catch (err) {
     console.error(`[WarmPool] header fetch failed for ${accountId}:`, (err as Error).message);
     return;
@@ -162,7 +196,15 @@ export async function getWarmedChat(accountId?: string) {
     }
     await refillPromises.get(key);
   }
-  if (pool.length === 0) throw new Error(`Warm pool empty for ${key}`);
+  if (pool.length === 0) {
+    // Retry once with short backoff if pool is still empty after first refill attempt
+    await new Promise(r => setTimeout(r, 1000));
+    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 after retry for ${key}`);
   return pool.shift()!;
 }
 
@@ -284,7 +326,7 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
     return cachedModels;
   }
 
-  const { cookie, userAgent, bxV } = await getBasicHeaders(accountId);
+  const { cookie, userAgent, bxV, bxUa, bxUmidtoken } = await getBasicHeaders(accountId);
 
   const response = await fetch('https://chat.qwen.ai/api/models', {
     headers: {
@@ -295,8 +337,11 @@ export async function fetchQwenModels(accountId?: string): Promise<any[]> {
       'user-agent': userAgent,
       'x-request-id': crypto.randomUUID(),
       'bx-v': bxV,
+      'bx-ua': bxUa || '',
+      'bx-umidtoken': bxUmidtoken || '',
       'timezone': CACHED_TIMEZONE,
-      'source': 'web'
+      'source': 'web',
+      ...getClientHintsHeaders(),
     }
   });
 
@@ -395,6 +440,7 @@ export async function createQwenStream(
       }
     } catch (err: any) {
       console.error('[Qwen] Failed to process multimodal uploads:', err.message);
+      throw new Error(`Multimodal upload failed: ${err.message}`);
     }
   }
 
@@ -443,9 +489,18 @@ export async function createQwenStream(
     timestamp: timestamp + 1
   };
 
+  const payloadJson = JSON.stringify(payload);
+  const payloadSize = Buffer.byteLength(payloadJson);
+  if (payloadSize > MAX_PAYLOAD_SIZE) {
+    throw new Error(`Payload too large: ${payloadSize} bytes exceeds limit of ${MAX_PAYLOAD_SIZE} bytes`);
+  }
+  const payloadMB = payloadSize / (1024 * 1024);
+  const timeoutMs = BASE_TIMEOUT_MS + Math.ceil(payloadMB * TIMEOUT_PER_MB);
+
   const url = `https://chat.qwen.ai/api/v2/chat/completions?chat_id=${chatId}`;
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 120000);
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  await sleep(getRandomDelay());
   const response = await fetch(url, {
     method: 'POST',
     headers: {
@@ -463,12 +518,82 @@ export async function createQwenStream(
       'x-accel-buffering': 'no',
       'x-request-id': crypto.randomUUID(),
       'bx-v': chatHeaders['bx-v'],
+      'bx-ua': chatHeaders['bx-ua'] || '',
+      'bx-umidtoken': chatHeaders['bx-umidtoken'] || '',
+      ...getClientHintsHeaders(),
     },
-    body: JSON.stringify(payload),
+    body: payloadJson,
     signal: controller.signal
   });
   clearTimeout(timeoutId);
 
+  const responseContentType = response.headers.get('content-type') || '';
+  if (response.ok && responseContentType.includes('application/json') && response.body) {
+    const cloned = response.clone();
+    const peekText = await cloned.text().catch(() => '');
+    if (peekText.includes('FAIL_SYS_USER_VALIDATE') || peekText.includes('_____tmd_____') || peekText.includes('RGV587_ERROR')) {
+      console.warn('[Qwen] TMD challenge detected, refreshing headers and retrying...');
+      try {
+        const { headers: freshHeaders } = await getQwenHeaders(true, accountId);
+        await sleep(1000 + Math.floor(Math.random() * 2000));
+        const retryController = new AbortController();
+        const retryTimeoutId = setTimeout(() => retryController.abort(), timeoutMs);
+        const retryResponse = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'accept': 'application/json',
+            'accept-language': 'pt-BR,pt;q=0.9',
+            'content-type': 'application/json',
+            'cookie': freshHeaders['cookie'],
+            'origin': 'https://chat.qwen.ai',
+            'referer': `https://chat.qwen.ai/c/${chatId}`,
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-origin',
+            'timezone': CACHED_TIMEZONE,
+            'user-agent': freshHeaders['user-agent'],
+            'x-accel-buffering': 'no',
+            'x-request-id': crypto.randomUUID(),
+            'bx-v': freshHeaders['bx-v'],
+            'bx-ua': freshHeaders['bx-ua'] || '',
+            'bx-umidtoken': freshHeaders['bx-umidtoken'] || '',
+            ...getClientHintsHeaders(),
+          },
+          body: payloadJson,
+          signal: retryController.signal
+        });
+        clearTimeout(retryTimeoutId);
+
+        const retryContentType = retryResponse.headers.get('content-type') || '';
+        if (retryResponse.ok && retryContentType.includes('text/event-stream') && retryResponse.body) {
+          return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: chatEntry.accountId };
+        }
+
+        const retryPeek = await retryResponse.clone().text().catch(() => '');
+        if (retryPeek.includes('FAIL_SYS_USER_VALIDATE') || retryPeek.includes('_____tmd_____')) {
+          throw new QwenUpstreamError(
+            'Qwen TMD challenge persists after header refresh. The account may need manual captcha resolution.',
+            'FAIL_SYS_USER_VALIDATE',
+            403,
+          );
+        }
+
+        if (retryResponse.ok && retryResponse.body) {
+          return { stream: retryResponse.body, headers: freshHeaders, uiSessionId: chatId, controller: retryController, accountId: chatEntry.accountId };
+        }
+      } catch (retryErr) {
+        if (retryErr instanceof QwenUpstreamError) throw retryErr;
+        console.error('[Qwen] TMD retry failed:', (retryErr as Error).message);
+      }
+
+      throw new QwenUpstreamError(
+        'Qwen TMD anti-bot challenge detected. Headers were refreshed but the challenge persists.',
+        'FAIL_SYS_USER_VALIDATE',
+        403,
+      );
+    }
+  }
+
   if (!response.ok || !response.body) {
     const errText = await response.text().catch(() => '');
     const contentType = response.headers.get('content-type') || '';

package/src/tests/jsonFix.test.ts

@@ -108,3 +108,20 @@ test('robustParseJSON: handles boolean and null values', () => {
   assert.strictEqual(result.deleted, false);
   assert.strictEqual(result.data, null);
 });
+
+test('robustParseJSON: handles unquoted string value after colon', () => {
+  const result = robustParseJSON('{"name": "bash", "arguments": {"command":export CI=true GIT_PAGER=cat npm run build, "description": "Build"}}');
+  assert.ok(result);
+  assert.strictEqual(result.name, 'bash');
+  assert.ok(typeof result.arguments.command === 'string');
+  assert.ok(result.arguments.command.includes('export CI=true'));
+  assert.strictEqual(result.arguments.description, 'Build');
+});
+
+test('robustParseJSON: handles unquoted string value with special chars', () => {
+  const result = robustParseJSON('{"name": "bash", "arguments": {"command":git add -A && git commit -m "fix"}}');
+  assert.ok(result);
+  assert.strictEqual(result.name, 'bash');
+  assert.ok(typeof result.arguments.command === 'string');
+  assert.ok(result.arguments.command.includes('git add'));
+});

package/src/tests/parser.test.ts

@@ -2,10 +2,12 @@ import { test } from 'node:test';
 import assert from 'node:assert';
 import { StreamingToolParser } from '../tools/parser.js';
 
+const TC_OPEN = '<tool_' + 'call>';
+const TC_CLOSE = '</tool_' + 'call>';
+
 test('StreamingToolParser: basic tool call', () => {
   const parser = new StreamingToolParser();
-  
-  const result = parser.feed('Hello! <tool_call>{"name": "t1", "arguments": {"a": 1}}</tool_call>');
+  const result = parser.feed(`Hello! ${TC_OPEN}{"name": "t1", "arguments": {"a": 1}}${TC_CLOSE}`);
   assert.strictEqual(result.text, 'Hello! ');
   assert.strictEqual(result.toolCalls.length, 1);
   assert.strictEqual(result.toolCalls[0].name, 't1');
@@ -13,8 +15,7 @@ test('StreamingToolParser: basic tool call', () => {
 
 test('StreamingToolParser: multiple tool calls', () => {
   const parser = new StreamingToolParser();
-  
-  const result = parser.feed('<tool_call>{"name": "t2", "arguments": {}}</tool_call><tool_call>{"name": "t3", "arguments": {}}</tool_call>');
+  const result = parser.feed(`${TC_OPEN}{"name": "t2", "arguments": {}}${TC_CLOSE}${TC_OPEN}{"name": "t3", "arguments": {}}${TC_CLOSE}`);
   assert.strictEqual(result.text, '');
   assert.strictEqual(result.toolCalls.length, 2);
   assert.strictEqual(result.toolCalls[0].name, 't2');
@@ -23,11 +24,9 @@ test('StreamingToolParser: multiple tool calls', () => {
 
 test('StreamingToolParser: fragmented tool call', () => {
   const parser = new StreamingToolParser();
-  
   assert.strictEqual(parser.feed('Text <tool_').text, 'Text ');
   assert.strictEqual(parser.feed('call>{"name": ').text, '');
-  const final = parser.feed('"frag", "arguments": {}}</tool_call> trailing');
-  
+  const final = parser.feed(`"frag", "arguments": {}}${TC_CLOSE} trailing`);
   assert.strictEqual(final.toolCalls.length, 1);
   assert.strictEqual(final.toolCalls[0].name, 'frag');
   assert.strictEqual(final.text, ' trailing');
@@ -35,26 +34,24 @@ test('StreamingToolParser: fragmented tool call', () => {
 
 test('StreamingToolParser: flush partial content', () => {
   const parser = new StreamingToolParser();
-  
   parser.feed('Unfinished tag <tool_');
   assert.strictEqual(parser.flush().text, '<tool_');
 
   const parser2 = new StreamingToolParser();
-  parser2.feed('Broken tool <tool_call>{"name": "healable"');
+  parser2.feed(`${TC_OPEN}{"name": "healable"`);
   const flushed = parser2.flush();
   assert.strictEqual(flushed.toolCalls.length, 1);
   assert.strictEqual(flushed.toolCalls[0].name, 'healable');
-  
+
   const parser3 = new StreamingToolParser();
-  parser3.feed('Invalid <tool_call>NOT_JSON');
+  parser3.feed(`Invalid ${TC_OPEN}NOT_JSON`);
   const flushed2 = parser3.flush();
-  assert.strictEqual(flushed2.text, '<tool_call>NOT_JSON</tool_call>');
+  assert.strictEqual(flushed2.text, `${TC_OPEN}NOT_JSON${TC_CLOSE}`);
 });
 
 test('StreamingToolParser: robust parsing of malformed JSON', () => {
   const parser = new StreamingToolParser();
-  
-  const res = parser.feed('<tool_call>{"name": "broken", "arguments": {"a": 1}</tool_call>');
+  const res = parser.feed(`${TC_OPEN}{"name": "broken", "arguments": {"a": 1}${TC_CLOSE}`);
   assert.strictEqual(res.toolCalls.length, 1);
   assert.strictEqual(res.toolCalls[0].name, 'broken');
   assert.deepStrictEqual(res.toolCalls[0].arguments, { a: 1 });
@@ -62,25 +59,22 @@ test('StreamingToolParser: robust parsing of malformed JSON', () => {
 
 test('StreamingToolParser: preserves tags in non-tool text', () => {
   const parser = new StreamingToolParser();
-  
-  const res1 = parser.feed('Fake: <tool_call> { "only_args": 1 } </tool_call> ');
-  assert.ok(res1.text.includes('<tool_call>'), 'Should contain start tag');
-  assert.ok(res1.text.includes('</tool_call>'), 'Should contain end tag');
+  const res1 = parser.feed(`Fake: ${TC_OPEN} { "only_args": 1 } ${TC_CLOSE} `);
+  assert.ok(res1.text.includes(TC_OPEN), 'Should contain start tag');
+  assert.ok(res1.text.includes(TC_CLOSE), 'Should contain close tag');
   assert.strictEqual(res1.toolCalls.length, 0);
 
-  const res2 = parser.feed('Real: <tool_call>{"name":"r"}</tool_call>');
+  const res2 = parser.feed(`Real: ${TC_OPEN}{"name":"r"}${TC_CLOSE}`);
   assert.strictEqual(res2.toolCalls.length, 1);
   assert.strictEqual(res2.toolCalls[0].name, 'r');
 });
 
 test('StreamingToolParser: handles multiple tool calls in array format', () => {
   const parser = new StreamingToolParser();
-  
-  const chunk = `<tool_call>[
+  const chunk = `${TC_OPEN}[
   {"name": "bash", "arguments": {"command": "ls", "description": "List files"}},
   {"name": "read", "arguments": {"path": "test.txt"}}
-]</tool_call>`;
-  
+]${TC_CLOSE}`;
   const result = parser.feed(chunk);
   assert.strictEqual(result.toolCalls.length, 2, 'Should extract both tool calls');
   assert.strictEqual(result.toolCalls[0].name, 'bash');
@@ -90,8 +84,7 @@ test('StreamingToolParser: handles multiple tool calls in array format', () => {
 
 test('StreamingToolParser: double-escaped quotes in JSON', () => {
   const parser = new StreamingToolParser();
-  
-  const input = '<tool_call>{\\"name\\": \\"edit\\", \\"arguments\\": {\\"filePath\\": \\"/tmp/test.txt\\", \\"content\\": \\"hello\\"}}</tool_call>';
+  const input = `${TC_OPEN}{\\"name\\": \\"edit\\", \\"arguments\\": {\\"filePath\\": \\"/tmp/test.txt\\", \\"content\\": \\"hello\\"}}${TC_CLOSE}`;
   const res = parser.feed(input);
   assert.strictEqual(res.toolCalls.length, 1);
   assert.strictEqual(res.toolCalls[0].name, 'edit');
@@ -100,8 +93,7 @@ test('StreamingToolParser: double-escaped quotes in JSON', () => {
 
 test('StreamingToolParser: double-escaped quotes in XML parameters', () => {
   const parser = new StreamingToolParser();
-  
-  const input = '<tool_call>\n<name>write</name>\n<parameter name=\\"content\\">&lt;div&gt;hello &amp; world&lt;/div&gt;</parameter>\n</tool_call>';
+  const input = `${TC_OPEN}\n<name>write</name>\n<parameter name=\\"content\\">&lt;div&gt;hello &amp; world&lt;/div&gt;</parameter>\n${TC_CLOSE}`;
   const res = parser.feed(input);
   assert.strictEqual(res.toolCalls.length, 1);
   assert.strictEqual(res.toolCalls[0].name, 'write');
@@ -110,8 +102,7 @@ test('StreamingToolParser: double-escaped quotes in XML parameters', () => {
 
 test('StreamingToolParser: truncated JSON with unclosed string', () => {
   const parser = new StreamingToolParser();
-  
-  const res = parser.feed('<tool_call>{"name": "bash", "arguments": {"command": "echo hello</tool_call>');
+  const res = parser.feed(`${TC_OPEN}{"name": "bash", "arguments": {"command": "echo hello${TC_CLOSE}`);
   assert.strictEqual(res.toolCalls.length, 1);
   assert.strictEqual(res.toolCalls[0].name, 'bash');
   assert.strictEqual(typeof res.toolCalls[0].arguments.command, 'string');
@@ -119,9 +110,60 @@ test('StreamingToolParser: truncated JSON with unclosed string', () => {
 
 test('StreamingToolParser: flush double-escaped tool call', () => {
   const parser = new StreamingToolParser();
-  
-  parser.feed('<tool_call>{\\"name\\": \\"recover\\",\\"arguments\\": {\\"a\\": \\"val');
+  parser.feed(`${TC_OPEN}{\\"name\\": \\"recover\\",\\"arguments\\": {\\"a\\": \\"val`);
   const flushed = parser.flush();
   assert.strictEqual(flushed.toolCalls.length, 1);
   assert.strictEqual(flushed.toolCalls[0].name, 'recover');
 });
+
+test('StreamingToolParser: handles literal close tag inside JSON string', () => {
+  const parser = new StreamingToolParser();
+  const toolCallJson = JSON.stringify({
+    name: "edit",
+    arguments: {
+      filePath: "/tmp/test.ts",
+      oldString: `some code with ${TC_CLOSE} inside a string value`,
+      newString: "replacement code"
+    }
+  });
+  const fullInput = `${TC_OPEN}${toolCallJson}${TC_CLOSE}`;
+  const res = parser.feed(fullInput);
+  assert.strictEqual(res.toolCalls.length, 1, 'Should parse the tool call despite to literal close tag in string');
+  assert.strictEqual(res.toolCalls[0].name, 'edit');
+  assert.strictEqual(res.toolCalls[0].arguments.filePath, '/tmp/test.ts');
+  assert.ok(
+    (res.toolCalls[0].arguments.oldString as string).includes(TC_CLOSE),
+    'oldString should contain the literal close tag'
+  );
+});
+
+test('StreamingToolParser: unquoted arguments key with nested string values containing colons', () => {
+  const parser = new StreamingToolParser();
+  const input = `${TC_OPEN}{"name":"todowrite",arguments:{"todos":[{"content":"Add versions/activeVersionIndex to DB schema with migration","status":"completed","priority":"high"},{"content":"Update dbService to handle versions","status":"completed","priority":"high"},{"content":"Update ChatStore types and add regenerateMessage + switchVersion methods","status":"in_progress","priority":"high"},{"content":"Update Chat.tsx handleRegenerate to use new regenerateMessage","status":"pending"}]}}${TC_CLOSE}`;
+  const res = parser.feed(input);
+  assert.strictEqual(res.toolCalls.length, 1);
+  assert.strictEqual(res.toolCalls[0].name, 'todowrite');
+  assert.strictEqual((res.toolCalls[0].arguments.todos as any[]).length, 4);
+  assert.strictEqual((res.toolCalls[0].arguments.todos as any[])[2].status, 'in_progress');
+});
+
+test('StreamingToolParser: handles literal close tag in streamed chunks', () => {
+  const parser = new StreamingToolParser();
+  const toolCallJson = JSON.stringify({
+    name: "edit",
+    arguments: {
+      filePath: "/tmp/app.ts",
+      oldString: `function foo() { return "${TC_CLOSE}"; }`,
+      newString: "function bar() {}"
+    }
+  });
+  const fullInput = `${TC_OPEN}${toolCallJson}${TC_CLOSE}`;
+  const mid = Math.floor(fullInput.length / 2);
+  const chunk1 = fullInput.substring(0, mid);
+  const chunk2 = fullInput.substring(mid);
+
+  parser.feed(chunk1);
+  const res = parser.feed(chunk2);
+  assert.strictEqual(res.toolCalls.length, 1, 'Should parse across chunk boundaries');
+  assert.strictEqual(res.toolCalls[0].name, 'edit');
+});

package/src/tools/parser.ts

@@ -184,6 +184,8 @@ function findToolEndIndex(buffer: string): number {
   return -1;
 }
 
+
+
 // ─── Partial Tag Detection ─────────────────────────────────────────────────────
 
 const TOOL_START_LITERAL = '<tool_call>';
@@ -283,8 +285,9 @@ export class StreamingToolParser {
           break;
         }
        } else {
-         const endIdx = this.buffer.indexOf(TOOL_END);
-        if (endIdx !== -1) {
+        let endIdx = findToolEndIndex(this.buffer);
+         if (endIdx === -1) endIdx = this.buffer.indexOf(TOOL_END);
+         if (endIdx !== -1) {
           const content = this.buffer.substring(0, endIdx);
           this.buffer = this.buffer.substring(endIdx + TOOL_END.length);
           this.processToolContent(content, result);
@@ -292,7 +295,7 @@ export class StreamingToolParser {
           this.currentOpenTag = TOOL_START_LITERAL;
           if (this.buffer.length > 0) {
             const nextMatch = this.buffer.match(TOOL_OPEN_RE);
-              if (nextMatch && nextMatch.index !== undefined) {
+            if (nextMatch && nextMatch.index !== undefined) {
               result.text += this.buffer.substring(0, nextMatch.index);
               this.insideTool = true;
               this.currentOpenTag = nextMatch[0];
@@ -305,7 +308,7 @@ export class StreamingToolParser {
             }
           }
         } else {
-          break; // Wait for more data
+          break;
         }
       }
     }

package/src/utils/context-truncation.ts

@@ -1,8 +1,8 @@
-export function estimateTokenCount(text: string): number {
-  // 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);
+import { getModelTokenDivisor } from '../core/model-registry.js'
+
+export function estimateTokenCount(text: string, modelId?: string): number {
+  const divisor = modelId ? getModelTokenDivisor(modelId) : 2.0
+  return Math.ceil(text.length / divisor)
 }
 
 function truncateSemantically(content: string, maxChars: number): string {
@@ -33,9 +33,11 @@ function truncateSemantically(content: string, maxChars: number): string {
 export function truncateMessages(
   messages: Array<{ role: string; content: string | null | any[] | Record<string, unknown> }>,
   maxContextLength: number,
-  systemPrompt: string = ''
+  systemPrompt: string = '',
+  modelId?: string
 ): Array<{ role: string; content: string }> {
-  const systemTokens = estimateTokenCount(systemPrompt);
+  const divisor = modelId ? getModelTokenDivisor(modelId) : 2.0
+  const systemTokens = estimateTokenCount(systemPrompt, modelId);
   const availableTokens = maxContextLength - systemTokens - 500;
   
   if (availableTokens <= 0) {
@@ -59,7 +61,7 @@ export function truncateMessages(
   
   for (let i = normalizedMessages.length - 1; i >= 0; i--) {
     const msg = normalizedMessages[i];
-    const msgTokens = estimateTokenCount(msg.content);
+    const msgTokens = estimateTokenCount(msg.content, modelId);
     
     if (usedTokens + msgTokens <= availableTokens) {
       result.push(msg);
@@ -67,7 +69,7 @@ export function truncateMessages(
     } else {
       const remainingTokens = availableTokens - usedTokens;
       if (remainingTokens > 100) {
-        const maxChars = Math.floor(remainingTokens * 2.5);
+        const maxChars = Math.floor(remainingTokens * divisor);
         const truncatedContent = truncateSemantically(msg.content, maxChars);
         result.push({ role: msg.role, content: `[Truncated] ${truncatedContent}` });
       }
@@ -77,7 +79,7 @@ export function truncateMessages(
   
   if (result.length === 0 && normalizedMessages.length > 0) {
     const lastMsg = normalizedMessages[normalizedMessages.length - 1];
-    const maxChars = Math.max(200, Math.floor(availableTokens * 2.5));
+    const maxChars = Math.max(200, Math.floor(availableTokens * divisor));
     const truncatedContent = truncateSemantically(lastMsg.content, maxChars);
     result.push({ role: lastMsg.role, content: `[Truncated] ${truncatedContent}` });
   }

package/src/utils/json.ts

@@ -59,6 +59,124 @@ function closeBraces(input: string, openBraces: number, openBrackets: number, in
   return out;
 }
 
+function quoteUnquotedStringValues(input: string): string {
+  let out = '';
+  let i = 0;
+  let inString = false;
+  let escaped = false;
+
+  while (i < input.length) {
+    const ch = input[i];
+
+    if (escaped) { out += ch; escaped = false; i++; continue; }
+    if (ch === '\\' && inString) { out += ch; escaped = true; i++; continue; }
+    if (ch === '"') { inString = !inString; out += ch; i++; continue; }
+    if (inString) { out += ch; i++; continue; }
+
+    if (ch === ':') {
+      out += ch;
+      i++;
+      let ws = '';
+      while (i < input.length && /\s/.test(input[i])) { ws += input[i]; i++; }
+      out += ws;
+      if (i >= input.length) break;
+
+      const next = input[i];
+      if (next === '"' || next === '{' || next === '[' || next === '-' || /[0-9]/.test(next)) {
+        continue;
+      }
+      const rest = input.substring(i);
+      if (/^(true|false|null)\b/.test(rest)) {
+        continue;
+      }
+
+      let val = '';
+      let depthBrace = 0;
+      let depthBracket = 0;
+      let j = i;
+      while (j < input.length) {
+        const c = input[j];
+        if (c === '{') depthBrace++;
+        else if (c === '}') {
+          if (depthBrace === 0) break;
+          depthBrace--;
+        } else if (c === '[') depthBracket++;
+        else if (c === ']') {
+          if (depthBracket === 0) break;
+          depthBracket--;
+        } else if (c === ',' && depthBrace === 0 && depthBracket === 0) {
+          break;
+        }
+        val += c;
+        j++;
+      }
+
+      if (val.length > 0) {
+        const escapedVal = val.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+        out += '"' + escapedVal + '"';
+      }
+      i = j;
+      continue;
+    }
+
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
+function quoteUnquotedKeys(input: string): string {
+  let out = '';
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+
+    if (escaped) {
+      out += ch;
+      escaped = false;
+      continue;
+    }
+
+    if (ch === '\\') {
+      out += ch;
+      escaped = true;
+      continue;
+    }
+
+    if (ch === '"') {
+      inString = !inString;
+      out += ch;
+      continue;
+    }
+
+    if (inString) {
+      out += ch;
+      continue;
+    }
+
+    if (/[a-zA-Z_]/.test(ch)) {
+      let j = i;
+      while (j < input.length && /[a-zA-Z0-9_]/.test(input[j])) j++;
+      const ident = input.slice(i, j);
+      let k = j;
+      while (k < input.length && /\s/.test(input[k])) k++;
+      if (k < input.length && input[k] === ':') {
+        out += '"' + ident + '"';
+      } else {
+        out += ident;
+      }
+      i = j - 1;
+      continue;
+    }
+
+    out += ch;
+  }
+
+  return out;
+}
+
 export function robustParseJSON(str: string): any {
   let sanitized = str.trim();
   sanitized = sanitized.replace(/^```json\s*/, '').replace(/```$/, '').trim();
@@ -69,7 +187,8 @@ export function robustParseJSON(str: string): any {
   let jsonPart = sanitized.substring(firstBrace);
   try { return JSON.parse(jsonPart); } catch (e) { /* continue */ }
 
-  let currentJson = jsonPart.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)(\s*:)/g, '$1"$2"$3');
+  let currentJson = quoteUnquotedKeys(jsonPart);
+  currentJson = quoteUnquotedStringValues(currentJson);
   currentJson = currentJson.replace(/([{,]\s*)"([a-zA-Z0-9_]+)"\s*:\s*"\2"\s*:/g, '$1"$2":');
   currentJson = currentJson.replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:\s*\2\s*:/g, '$1$2:');
 
@@ -106,7 +225,7 @@ export function robustParseJSON(str: string): any {
 
   try { return JSON.parse(tempJson); } catch (e) {
     let aggressive = fixedJson.trim();
-    if (aggressive.endsWith(',')) aggressive = aggressive.slice(0, -1);
+    aggressive = aggressive.replace(/,\s*([}\]])/g, '$1');
     const { result: aggFixed, openBraces: ob, openBrackets: bk, inString: aggInString } = sanitizeAndBalance(aggressive);
   try { return JSON.parse(closeBraces(aggFixed, ob, bk, aggInString)); } catch {
     return null;