@pedrofariasx/qwenproxy 1.2.3 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrofariasx/qwenproxy",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "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

@@ -302,7 +302,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;
         });
       }

package/src/services/qwen.ts

@@ -1,7 +1,10 @@
 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;
 
 export class RetryableQwenStreamError extends Error {
   readonly retryAfterMs: number;
@@ -162,7 +165,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()!;
 }
 
@@ -395,6 +406,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 +455,17 @@ 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);
   const response = await fetch(url, {
     method: 'POST',
     headers: {
@@ -464,7 +484,7 @@ export async function createQwenStream(
       'x-request-id': crypto.randomUUID(),
       'bx-v': chatHeaders['bx-v'],
     },
-    body: JSON.stringify(payload),
+    body: payloadJson,
     signal: controller.signal
   });
   clearTimeout(timeoutId);

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;