@pedrofariasx/qwenproxy 1.2.2 → 1.3.0

package/src/services/qwen.ts

@@ -1,7 +1,10 @@
-import { getQwenHeaders, getBasicHeaders } from './playwright.ts';
+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;
@@ -28,8 +31,7 @@ interface SessionEntry {
   timestamp: number;
 }
 
-const sessionStates: Map<string, SessionEntry> = (globalThis as any)._sessionStates || new Map();
-(globalThis as any)._sessionStates = sessionStates;
+const sessionStates: Map<string, SessionEntry> = new Map();
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
 
 function cleanupStaleSessions() {
@@ -65,11 +67,9 @@ interface WarmPoolEntry {
   timestamp: number;
 }
 
-const warmPool: Map<string, WarmPoolEntry[]> = (globalThis as any)._warmPool || new Map();
-(globalThis as any)._warmPool = warmPool;
+const warmPool: Map<string, WarmPoolEntry[]> = new Map();
 
-const refillPromises: Map<string, Promise<void>> = (globalThis as any)._refillPromises || new Map();
-(globalThis as any)._refillPromises = refillPromises;
+const refillPromises: Map<string, Promise<void>> = new Map();
 
 const WARM_POOL_SIZE = 5;
 const WARM_POOL_TTL_MS = 10 * 60 * 1000;
@@ -78,9 +78,8 @@ function cleanupStalePool(accountId: string) {
   const pool = warmPool.get(accountId);
   if (!pool) return;
   const now = Date.now();
-  for (let i = pool.length - 1; i >= 0; i--) {
-    if (now - pool[i].timestamp > WARM_POOL_TTL_MS) pool.splice(i, 1);
-  }
+  const filtered = pool.filter(e => now - e.timestamp <= WARM_POOL_TTL_MS);
+  if (filtered.length !== pool.length) warmPool.set(accountId, filtered);
 }
 
 async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, string>> {
@@ -93,8 +92,6 @@ async function getBasicQwenHeaders(accountId?: string): Promise<Record<string, s
 }
 
 async function createRealQwenChat(header: Record<string, string>): Promise<string> {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 30000);
   const response = await fetch('https://chat.qwen.ai/api/v2/chats/new', {
     method: 'POST',
     headers: {
@@ -116,9 +113,8 @@ async function createRealQwenChat(header: Record<string, string>): Promise<strin
       timestamp: Date.now(),
       project_id: '',
     }),
-    signal: controller.signal,
+    signal: AbortSignal.timeout(30000),
   });
-  clearTimeout(timeoutId);
 
   if (!response.ok) throw new Error(`Failed to create chat: ${response.status}`);
   const json = await response.json();
@@ -169,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()!;
 }
 
@@ -402,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}`);
     }
   }
 
@@ -450,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: {
@@ -471,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/concurrency.test.ts

@@ -4,7 +4,7 @@ import assert from 'node:assert';
 process.env.TEST_MOCK_PLAYWRIGHT = 'true';
 
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 test('Concurrent requests are serialized by mutex', async () => {
   const originalFetch = globalThis.fetch;

package/src/tests/concurrentChat.test.ts

@@ -3,7 +3,7 @@ import assert from 'node:assert';
 import net from 'node:net';
 import { serve } from '@hono/node-server';
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 function isPortAvailable(port: number): Promise<boolean> {
   return new Promise((resolve) => {

package/src/tests/contextTruncation.test.ts

@@ -0,0 +1,142 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { estimateTokenCount, truncateMessages } from '../utils/context-truncation.js';
+
+test('estimateTokenCount: returns 0 for empty string', () => {
+  assert.strictEqual(estimateTokenCount(''), 0);
+});
+
+test('estimateTokenCount: estimates tokens conservatively using 2.5 divisor', () => {
+  assert.strictEqual(estimateTokenCount('hello'), 2);
+  assert.strictEqual(estimateTokenCount('a'.repeat(100)), 40);
+  assert.strictEqual(estimateTokenCount('a'.repeat(250)), 100);
+  assert.strictEqual(estimateTokenCount('a'.repeat(2500)), 1000);
+});
+
+test('estimateTokenCount: handles single character', () => {
+  assert.strictEqual(estimateTokenCount('x'), 1);
+});
+
+test('estimateTokenCount: rounds up for non-multiples of 2.5', () => {
+  assert.strictEqual(estimateTokenCount('ab'), 1);
+  assert.strictEqual(estimateTokenCount('abc'), 2);
+  assert.strictEqual(estimateTokenCount('abcd'), 2);
+});
+
+test('truncateMessages: returns all messages when within context window', () => {
+  const messages = [
+    { role: 'system', content: 'You are helpful.' },
+    { role: 'user', content: 'Hello' },
+    { role: 'assistant', content: 'Hi there!' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 3);
+  assert.strictEqual(result[0].content, 'You are helpful.');
+  assert.strictEqual(result[1].content, 'Hello');
+  assert.strictEqual(result[2].content, 'Hi there!');
+});
+
+test('truncateMessages: preserves chronological order', () => {
+  const messages = [
+    { role: 'user', content: 'first' },
+    { role: 'assistant', content: 'second' },
+    { role: 'user', content: 'third' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, 'first');
+  assert.strictEqual(result[1].role, 'assistant');
+  assert.strictEqual(result[2].role, 'user');
+  assert.strictEqual(result[2].content, 'third');
+});
+
+test('truncateMessages: drops oldest messages first when exceeding context', () => {
+  const largeContent = 'x'.repeat(5000);
+  const messages = [
+    { role: 'user', content: largeContent },
+    { role: 'assistant', content: largeContent },
+    { role: 'user', content: 'latest message' },
+  ];
+  const result = truncateMessages(messages, 2000);
+  const lastMsg = result[result.length - 1];
+  assert.ok(lastMsg.content.includes('latest message') || lastMsg.content.includes('[Truncated]'));
+});
+
+test('truncateMessages: returns system prompt as fallback when context is extremely small', () => {
+  const messages = [
+    { role: 'user', content: 'some content' },
+  ];
+  const systemPrompt = 'system instructions';
+  const result = truncateMessages(messages, 10, systemPrompt);
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].role, 'user');
+  assert.strictEqual(result[0].content, systemPrompt);
+});
+
+test('truncateMessages: handles array content in messages', () => {
+  const messages = [
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'hello' },
+        { type: 'image_url', image_url: { url: 'data:image/png;base64,...' } },
+      ],
+    },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('hello'));
+});
+
+test('truncateMessages: handles null content', () => {
+  const messages = [
+    { role: 'user', content: null },
+    { role: 'assistant', content: 'response' },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 2);
+  assert.strictEqual(result[0].content, '');
+  assert.strictEqual(result[1].content, 'response');
+});
+
+test('truncateMessages: handles object content', () => {
+  const messages = [
+    { role: 'user', content: { structured: 'data', value: 42 } },
+  ];
+  const result = truncateMessages(messages, 100000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(result[0].content.includes('structured'));
+});
+
+test('truncateMessages: truncates partially fitting message with marker', () => {
+  const messages = [
+    { role: 'user', content: 'a'.repeat(10000) },
+  ];
+  const result = truncateMessages(messages, 1000);
+  assert.strictEqual(result.length, 1);
+  assert.ok(
+    result[0].content.includes('[Truncated]') || result[0].content.length < 10000,
+    'Should truncate or mark as truncated'
+  );
+});
+
+test('truncateMessages: accounts for system prompt in available tokens', () => {
+  const systemPrompt = 'x'.repeat(2000);
+  const messages = [
+    { role: 'user', content: 'short' },
+  ];
+  const withSystem = truncateMessages(messages, 2000, systemPrompt);
+  const withoutSystem = truncateMessages(messages, 2000);
+  assert.ok(withSystem.length <= withoutSystem.length);
+});
+
+test('truncateMessages: handles empty messages array', () => {
+  const result = truncateMessages([], 100000);
+  assert.strictEqual(result.length, 0);
+});
+
+test('truncateMessages: handles empty messages with system prompt fallback', () => {
+  const result = truncateMessages([], 5, 'fallback');
+  assert.strictEqual(result.length, 1);
+  assert.strictEqual(result[0].content, 'fallback');
+});

package/src/tests/delta.test.ts

@@ -1,23 +1,20 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { getIncrementalDelta } from '../routes/chat.ts';
+import { getIncrementalDelta } from '../routes/chat.js';
 
 test('getIncrementalDelta: handles strictly cumulative stream correctly', () => {
   let accumulated = '';
   
-  // Step 1
   let chunk1 = 'const x = 1;';
   let res1 = getIncrementalDelta(accumulated, chunk1);
   assert.strictEqual(res1.delta, 'const x = 1;');
   accumulated = res1.matchedContent;
   
-  // Step 2
   let chunk2 = 'const x = 1;\nconst y = 2;';
   let res2 = getIncrementalDelta(accumulated, chunk2);
   assert.strictEqual(res2.delta, '\nconst y = 2;');
   accumulated = res2.matchedContent;
 
-  // Step 3
   let chunk3 = 'const x = 1;\nconst y = 2;\nconst z = 3;';
   let res3 = getIncrementalDelta(accumulated, chunk3);
   assert.strictEqual(res3.delta, '\nconst z = 3;');
@@ -29,19 +26,16 @@ test('getIncrementalDelta: handles strictly cumulative stream correctly', () =>
 test('getIncrementalDelta: handles strictly incremental stream correctly', () => {
   let accumulated = '';
   
-  // Step 1
   let chunk1 = 'const x = 1;';
   let res1 = getIncrementalDelta(accumulated, chunk1);
   assert.strictEqual(res1.delta, 'const x = 1;');
   accumulated = res1.matchedContent;
   
-  // Step 2
   let chunk2 = '\nconst y = 2;';
   let res2 = getIncrementalDelta(accumulated, chunk2);
   assert.strictEqual(res2.delta, '\nconst y = 2;');
   accumulated = res2.matchedContent;
 
-  // Step 3
   let chunk3 = '\nconst z = 3;';
   let res3 = getIncrementalDelta(accumulated, chunk3);
   assert.strictEqual(res3.delta, '\nconst z = 3;');
@@ -51,13 +45,89 @@ test('getIncrementalDelta: handles strictly incremental stream correctly', () =>
 });
 
 test('getIncrementalDelta: does not suffer from false-positive repetitive word overlap bugs', () => {
-  // Previously, if oldStr ended in a common keyword and newStr started/contained the same keyword,
-  // it would incorrectly match them and strip them. Let's verify this is fixed.
   let accumulated = 'import { useState } from \'react\';\nimport {';
   let nextChunk = ' Button } from \'@/components/ui/button\';';
   
   let res = getIncrementalDelta(accumulated, nextChunk);
-  // It should treat the next chunk as strictly incremental and return it unchanged.
   assert.strictEqual(res.delta, ' Button } from \'@/components/ui/button\';');
   assert.strictEqual(res.matchedContent, 'import { useState } from \'react\';\nimport { Button } from \'@/components/ui/button\';');
 });
+
+test('getIncrementalDelta: empty oldStr returns newStr as delta', () => {
+  const res = getIncrementalDelta('', 'hello world');
+  assert.strictEqual(res.delta, 'hello world');
+  assert.strictEqual(res.matchedContent, 'hello world');
+  assert.strictEqual(res.contentLength, 11);
+});
+
+test('getIncrementalDelta: identical strings return empty delta', () => {
+  const str = 'some content here';
+  const res = getIncrementalDelta(str, str, str.length, str.slice(-64));
+  assert.strictEqual(res.delta, '');
+  assert.strictEqual(res.matchedContent, str);
+});
+
+test('getIncrementalDelta: completely different strings concatenate', () => {
+  const res = getIncrementalDelta('abc', 'xyz');
+  assert.strictEqual(res.delta, 'xyz');
+  assert.strictEqual(res.matchedContent, 'abcxyz');
+});
+
+test('getIncrementalDelta: uses prevLength fast path when suffix matches', () => {
+  const oldStr = 'hello world';
+  const prevLength = oldStr.length;
+  const prevSuffix = oldStr.slice(-64);
+  const newStr = 'hello world extended';
+  
+  const res = getIncrementalDelta(oldStr, newStr, prevLength, prevSuffix);
+  assert.strictEqual(res.delta, ' extended');
+  assert.strictEqual(res.matchedContent, newStr);
+  assert.strictEqual(res.contentLength, newStr.length);
+});
+
+test('getIncrementalDelta: large string with tiny delta falls back to concatenation for safety', () => {
+  const oldStr = 'x'.repeat(3000);
+  const tinyDelta = 'a';
+  const newStr = oldStr + tinyDelta;
+  
+  const res = getIncrementalDelta(oldStr, newStr, oldStr.length, oldStr.slice(-64));
+  assert.strictEqual(res.matchedContent, newStr);
+});
+
+test('getIncrementalDelta: contentSuffix tracks last 64 characters', () => {
+  const longStr = 'a'.repeat(100);
+  const res = getIncrementalDelta('', longStr);
+  assert.strictEqual(res.contentSuffix.length, 64);
+  assert.strictEqual(res.contentSuffix, 'a'.repeat(64));
+});
+
+test('getIncrementalDelta: handles segment-based prefix matching', () => {
+  const prefix = 'a'.repeat(200);
+  const oldStr = prefix + 'OLD';
+  const newStr = prefix + 'NEW';
+  
+  const res = getIncrementalDelta(oldStr, newStr);
+  assert.ok(res.delta.length > 0);
+});
+
+test('getIncrementalDelta: works through a realistic multi-chunk stream', () => {
+  let accumulated = '';
+  const chunks = [
+    'The',
+    'The quick',
+    'The quick brown',
+    'The quick brown fox',
+    'The quick brown fox jumps',
+    'The quick brown fox jumps over the lazy dog.',
+  ];
+  
+  let finalDelta = '';
+  for (const chunk of chunks) {
+    const res = getIncrementalDelta(accumulated, chunk, accumulated.length, accumulated.slice(-64));
+    finalDelta += res.delta;
+    accumulated = res.matchedContent;
+  }
+  
+  assert.strictEqual(accumulated, 'The quick brown fox jumps over the lazy dog.');
+  assert.strictEqual(finalDelta, 'The quick brown fox jumps over the lazy dog.');
+});

package/src/tests/jsonFix.test.ts

@@ -1,98 +1,127 @@
-import { robustParseJSON } from '../utils/json.ts';
-
-const problematicString = '{"name": "suggest", "arguments": {"suggest": "Landing page para escritório de advocacia criada em src/pages/Index.tsx", "actions": [{"label": "Revisar alterações", "description": "Executar review local das mudanças não commitadas", "prompt": "/local-review-uncommitted"}]})';
-
-console.log('Testing problematic string...');
-try {
-    const result = robustParseJSON(problematicString);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.name === 'suggest' && result.arguments.actions.length === 1) {
-        console.log('✅ Problematic string test passed!');
-    } else {
-        console.error('❌ Result structure is incorrect');
-    }
-} catch (e) {
-    console.error('❌ Failed to parse problematic string:', e);
-}
-
-const missingBraces = '{"name": "test", "arguments": {"foo": "bar"';
-console.log('\nTesting missing braces...');
-try {
-    const result = robustParseJSON(missingBraces);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.arguments.foo === 'bar') {
-        console.log('✅ Missing braces test passed!');
-    } else {
-        console.error('❌ Result structure is incorrect');
-    }
-} catch (e) {
-    console.error('❌ Failed to parse missing braces:', e);
-}
-
-const controlChars = '{"name": "control", "msg": "line 1\\nline 2"}';
-console.log('\nTesting control characters in string...');
-try {
-    // Note: in a real string from the model, it would be a literal newline
-    const literalNewline = '{"name": "control", "msg": "line 1\\nline 2"}'.replace('\\n', '\n');
-    const result = robustParseJSON(literalNewline);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.msg.includes('line 1') && result.msg.includes('line 2')) {
-        console.log('✅ Control characters test passed!');
-    } else {
-        console.error('❌ Result content is incorrect');
-    }
-} catch (e) {
-    console.error('❌ Failed to parse control characters:', e);
-}
-
-const crazyCase = `{"name": "suggest", "arguments": {"suggest": "Landing page criada para escritório de advocacia com design corporativo", "actions": [{"label": "Revisar código local", "description": "Exec<tool_call>\n{"name": "bashutar revisão local das", "arguments": alterações {"command": não commitadas", "npm run lint "prompt", "description":": "/local-review "Run lint-uncommitted"}] to verify code quality})"}}`;
-console.log('\nTesting crazy nested hallucination case...');
-try {
-    const result = robustParseJSON(crazyCase);
-    console.log('Successfully parsed (at least some of it):', JSON.stringify(result, null, 2));
-    console.log('✅ Crazy case handled without crashing!');
-} catch (e: any) {
-    console.log('⚠️ Crazy case failed (too malformed), but error was:', e.message);
-}
-
-const invalidEscapes = '{"path": "C:\\\\Users\\\\name\\\\Documents"}';
-console.log('\nTesting invalid backslash escapes in string...');
-try {
-    const result = robustParseJSON(invalidEscapes);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.path === 'C:\\\\Users\\\\name\\\\Documents' || result.path === 'C:\\Users\\name\\Documents') {
-        console.log('✅ Invalid backslash escapes test passed!');
-    } else {
-        console.error('❌ Result path is incorrect:', result.path);
-    }
-} catch (e) {
-    console.error('❌ Failed to parse invalid backslash escapes:', e);
-}
-
-const doubleKey = '{"name": "name": "create_file", "arguments": {"path": "b.txt"}}';
-console.log('\nTesting double key hallucination...');
-try {
-    const result = robustParseJSON(doubleKey);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.name === 'create_file') {
-        console.log('✅ Double key test passed!');
-    } else {
-        console.error('❌ Result name is incorrect:', result.name);
-    }
-} catch (e) {
-    console.error('❌ Failed to parse double key:', e);
-}
-
-const unquotedArgs = '{"name":"Read",arguments:{"file_path":"test.ts","limit":100}}';
-console.log('\nTesting unquoted arguments key...');
-try {
-    const result = robustParseJSON(unquotedArgs);
-    console.log('Successfully parsed:', JSON.stringify(result, null, 2));
-    if (result.arguments && result.arguments.limit === 100) {
-        console.log('✅ Unquoted arguments test passed!');
-    } else {
-        console.error('❌ Result structure is incorrect');
-    }
-} catch (e) {
-    console.error('❌ Failed to parse unquoted arguments:', e);
-}
+import { test } from 'node:test';
+import assert from 'node:assert';
+import { robustParseJSON } from '../utils/json.js';
+
+test('robustParseJSON: valid JSON passes through directly', () => {
+  const result = robustParseJSON('{"name": "test", "arguments": {"a": 1}}');
+  assert.deepStrictEqual(result, { name: 'test', arguments: { a: 1 } });
+});
+
+test('robustParseJSON: returns null for empty string', () => {
+  assert.strictEqual(robustParseJSON(''), null);
+});
+
+test('robustParseJSON: returns null for non-object string', () => {
+  assert.strictEqual(robustParseJSON('just plain text'), null);
+});
+
+test('robustParseJSON: handles markdown code fence wrapping', () => {
+  const result = robustParseJSON('```json\n{"name": "test"}\n```');
+  assert.deepStrictEqual(result, { name: 'test' });
+});
+
+test('robustParseJSON: handles missing closing braces', () => {
+  const result = robustParseJSON('{"name": "test", "arguments": {"foo": "bar"');
+  assert.ok(result);
+  assert.strictEqual(result.arguments.foo, 'bar');
+});
+
+test('robustParseJSON: handles missing closing brackets', () => {
+  const result = robustParseJSON('{"items": [1, 2, 3');
+  assert.ok(result);
+  assert.deepStrictEqual(result.items, [1, 2, 3]);
+});
+
+test('robustParseJSON: handles double key hallucination', () => {
+  const result = robustParseJSON('{"name": "name": "create_file", "arguments": {"path": "b.txt"}}');
+  assert.ok(result);
+  assert.strictEqual(result.name, 'create_file');
+});
+
+test('robustParseJSON: handles unquoted keys', () => {
+  const result = robustParseJSON('{"name":"Read",arguments:{"file_path":"test.ts","limit":100}}');
+  assert.ok(result);
+  assert.strictEqual(result.arguments.limit, 100);
+});
+
+test('robustParseJSON: handles control characters in string values', () => {
+  const literalNewline = '{"name": "control", "msg": "line 1\nline 2"}';
+  const result = robustParseJSON(literalNewline);
+  assert.ok(result);
+  assert.ok(result.msg.includes('line 1'));
+  assert.ok(result.msg.includes('line 2'));
+});
+
+test('robustParseJSON: handles Windows path backslashes', () => {
+  const result = robustParseJSON('{"path": "C:\\\\Users\\\\name\\\\Documents"}');
+  assert.ok(result);
+  assert.ok(
+    result.path === 'C:\\Users\\name\\Documents' || result.path === 'C:\\\\Users\\\\name\\\\Documents',
+    `Unexpected path: ${result.path}`
+  );
+});
+
+test('robustParseJSON: handles trailing comma', () => {
+  const result = robustParseJSON('{"name": "test", "value": 42,}');
+  assert.ok(result);
+  assert.strictEqual(result.name, 'test');
+  assert.strictEqual(result.value, 42);
+});
+
+test('robustParseJSON: handles complex nested suggest payload', () => {
+  const payload = '{"name": "suggest", "arguments": {"suggest": "Landing page criada", "actions": [{"label": "Revisar", "description": "Review", "prompt": "/local-review-uncommitted"}]})';
+  const result = robustParseJSON(payload);
+  assert.ok(result);
+  assert.strictEqual(result.name, 'suggest');
+  assert.ok(result.arguments.actions.length >= 1);
+});
+
+test('robustParseJSON: handles deeply nested malformed JSON gracefully', () => {
+  const crazy = `{"name": "suggest", "arguments": {"suggest": "ok", "actions": [{"label": "test"<tool_call>\n{"name": "broken"}]}}`;
+  const result = robustParseJSON(crazy);
+  assert.ok(result === null || typeof result === 'object');
+});
+
+test('robustParseJSON: strips leading text before first brace', () => {
+  const result = robustParseJSON('some text before {"name": "found"}');
+  assert.ok(result);
+  assert.strictEqual(result.name, 'found');
+});
+
+test('robustParseJSON: handles array values correctly', () => {
+  const result = robustParseJSON('{"items": ["a", "b", "c"]}');
+  assert.ok(result);
+  assert.deepStrictEqual(result.items, ['a', 'b', 'c']);
+});
+
+test('robustParseJSON: handles numeric values', () => {
+  const result = robustParseJSON('{"count": 42, "ratio": 3.14}');
+  assert.ok(result);
+  assert.strictEqual(result.count, 42);
+  assert.strictEqual(result.ratio, 3.14);
+});
+
+test('robustParseJSON: handles boolean and null values', () => {
+  const result = robustParseJSON('{"active": true, "deleted": false, "data": null}');
+  assert.ok(result);
+  assert.strictEqual(result.active, true);
+  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/multimodal.test.ts

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import net from 'node:net';
 import { serve } from '@hono/node-server';
 import { app } from '../api/server.js';
-import { initPlaywright, closePlaywright } from '../services/playwright.ts';
+import { initPlaywright, closePlaywright } from '../services/playwright.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);