@pedrofariasx/qwenproxy 1.2.1 → 1.2.3

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

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);

package/src/tests/parser.test.ts

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { StreamingToolParser } from '../tools/parser.ts';
+import { StreamingToolParser } from '../tools/parser.js';
 
 test('StreamingToolParser: basic tool call', () => {
   const parser = new StreamingToolParser();
@@ -54,7 +54,7 @@ test('StreamingToolParser: flush partial content', () => {
 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('<tool_call>{"name": "broken", "arguments": {"a": 1}</tool_call>');
   assert.strictEqual(res.toolCalls.length, 1);
   assert.strictEqual(res.toolCalls[0].name, 'broken');
   assert.deepStrictEqual(res.toolCalls[0].arguments, { a: 1 });
@@ -87,3 +87,41 @@ test('StreamingToolParser: handles multiple tool calls in array format', () => {
   assert.strictEqual(result.toolCalls[1].name, 'read');
   assert.strictEqual(result.toolCalls[0].arguments.command, 'ls');
 });
+
+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 res = parser.feed(input);
+  assert.strictEqual(res.toolCalls.length, 1);
+  assert.strictEqual(res.toolCalls[0].name, 'edit');
+  assert.strictEqual(res.toolCalls[0].arguments.filePath, '/tmp/test.txt');
+});
+
+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 res = parser.feed(input);
+  assert.strictEqual(res.toolCalls.length, 1);
+  assert.strictEqual(res.toolCalls[0].name, 'write');
+  assert.strictEqual(res.toolCalls[0].arguments.content, '<div>hello & world</div>');
+});
+
+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>');
+  assert.strictEqual(res.toolCalls.length, 1);
+  assert.strictEqual(res.toolCalls[0].name, 'bash');
+  assert.strictEqual(typeof res.toolCalls[0].arguments.command, 'string');
+});
+
+test('StreamingToolParser: flush double-escaped tool call', () => {
+  const parser = new StreamingToolParser();
+  
+  parser.feed('<tool_call>{\\"name\\": \\"recover\\",\\"arguments\\": {\\"a\\": \\"val');
+  const flushed = parser.flush();
+  assert.strictEqual(flushed.toolCalls.length, 1);
+  assert.strictEqual(flushed.toolCalls[0].name, 'recover');
+});

package/src/tools/parser.ts

@@ -5,7 +5,7 @@
  * Supports both JSON and Hermes-style XML <parameter> formats.
  */
 
-import { v4 as uuidv4 } from 'uuid';
+import crypto from 'crypto';
 import { robustParseJSON } from '../utils/json.js';
 import { logger } from '../core/logger.js';
 import type { ParsedToolCall } from './types';
@@ -30,6 +30,29 @@ function decodeXmlEntities(value: string): string {
     .replace(/&amp;/g, '&');
 }
 
+function unescapeDoubleEscaped(content: string): string {
+  const trimmed = content.trim();
+  if (!trimmed) return content;
+  
+  const isJsonLike = trimmed.startsWith('{') || trimmed.startsWith('[');
+  const isXmlLike = trimmed.startsWith('<');
+  
+  if (!isJsonLike && !isXmlLike) return content;
+  
+  const firstQuoteIdx = trimmed.indexOf('"');
+  if (firstQuoteIdx === -1) return content;
+  
+  const firstEscapedQuoteIdx = trimmed.indexOf('\\"');
+  
+  if (firstEscapedQuoteIdx !== -1 && (firstQuoteIdx === -1 || firstEscapedQuoteIdx < firstQuoteIdx)) {
+    return content
+      .replace(/\\"/g, '"')
+      .replace(/\\\\/g, '\\');
+  }
+  
+  return content;
+}
+
 function coerceParameterValue(rawValue: string): unknown {
   const value = decodeXmlEntities(rawValue.trim());
   if (value === 'true') return true;
@@ -136,19 +159,67 @@ function parseRecoverableXmlToolCall(
   return { name: toolName, arguments: args };
 }
 
+// ─── String-Aware Tag Detection ─────────────────────────────────────────────────
+
+function findToolEndIndex(buffer: string): number {
+  const tagLen = TOOL_END.length;
+  const limit = buffer.length - tagLen;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i <= limit; i++) {
+    const ch = buffer[i];
+    if (escaped) { escaped = false; continue; }
+    if (ch === '\\') { escaped = true; continue; }
+    if (ch === '"') { inString = !inString; continue; }
+    if (inString || ch !== '<') continue;
+    let match = true;
+    for (let j = 1; j < tagLen; j++) {
+      const c = buffer.charCodeAt(i + j);
+      const t = TOOL_END.charCodeAt(j);
+      if (c !== t && (c | 0x20) !== (t | 0x20)) { match = false; break; }
+    }
+    if (match) return i;
+  }
+  return -1;
+}
+
 // ─── Partial Tag Detection ─────────────────────────────────────────────────────
 
 const TOOL_START_LITERAL = '<tool_call>';
 
 function findPartialToolOpenIndex(buffer: string): number {
-  const lower = buffer.toLowerCase();
-  // Check if there's a partial opening tag like `<tool_call` without closing `>`
-  const idx = lower.lastIndexOf('<tool_call');
-  if (idx !== -1 && lower.indexOf('>', idx) === -1) return idx;
+  const prefix = '<tool_call';
+  const prefixLen = prefix.length;
+  const bufLen = buffer.length;
+
+  let lastPartialIdx = -1;
+  for (let i = bufLen - 1; i >= Math.max(0, bufLen - prefixLen - 1); i--) {
+    if (buffer[i] !== '<') continue;
+    let match = true;
+    for (let j = 1; j < prefixLen && i + j < bufLen; j++) {
+      const c = buffer.charCodeAt(i + j);
+      const t = prefix.charCodeAt(j);
+      if (c !== t && ((c | 0x20) !== (t | 0x20))) { match = false; break; }
+    }
+    if (match) {
+      lastPartialIdx = i;
+      break;
+    }
+  }
+  if (lastPartialIdx !== -1 && buffer.indexOf('>', lastPartialIdx) === -1) return lastPartialIdx;
 
-  // Check for partial prefix at end (e.g. `<tool`, `<tool_`, `<tool_c`)
   for (let i = 1; i < TOOL_START_LITERAL.length; i++) {
-    if (lower.endsWith(TOOL_START_LITERAL.substring(0, i))) return buffer.length - i;
+    const sub = TOOL_START_LITERAL.substring(0, i);
+    const subLen = sub.length;
+    if (bufLen < subLen) continue;
+    let match = true;
+    for (let j = 0; j < subLen; j++) {
+      const c = buffer.charCodeAt(bufLen - subLen + j);
+      const t = sub.charCodeAt(j);
+      if (c !== t && (c | 0x20) !== (t | 0x20)) { match = false; break; }
+    }
+    if (match) return bufLen - i;
   }
   return -1;
 }
@@ -183,6 +254,11 @@ export class StreamingToolParser {
 
     while (this.buffer.length > 0) {
       if (!this.insideTool) {
+        if (this.buffer.indexOf('<') === -1) {
+          if (this.emittedToolCallCount === 0) result.text += this.buffer;
+          this.buffer = '';
+          break;
+        }
         const match = this.buffer.match(TOOL_OPEN_RE);
         if (match && match.index !== undefined) {
           // Text before the tool call tag
@@ -206,10 +282,8 @@ export class StreamingToolParser {
           }
           break;
         }
-      } else {
-        // Inside tool: look for </tool_call>
-        const lowerBuffer = this.buffer.toLowerCase();
-        const endIdx = lowerBuffer.indexOf(TOOL_END);
+       } else {
+         const 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);
@@ -276,20 +350,11 @@ export class StreamingToolParser {
     return this.insideTool;
   }
 
-  /**
-   * Get any lead-in text that was captured before tool calls.
-   * Useful for fallback content when tool calls fail to parse.
-   */
-  getPendingLeadIn(): string {
-    return this.pendingLeadIn;
-  }
-
   // ─── Internal Methods ──────────────────────────────────────────────────────
 
   private processToolContent(content: string, result: ParserResult): void {
-    const t = content.trim();
+    let t = content.trim();
     if (!t) {
-      // Empty tool call - malformed. Restore lead-in if possible.
       logger.warn('[parser] Dropping empty tool call block');
       if (this.emittedToolCallCount === 0 && this.pendingLeadIn.trim().length > 0) {
         result.text += this.pendingLeadIn;
@@ -298,11 +363,12 @@ export class StreamingToolParser {
       return;
     }
 
-    // 1) Try Hermes-style XML <parameter> format first
+    t = unescapeDoubleEscaped(t);
+
     const xmlParsed = parseXmlParameterToolCall(t, this.currentOpenTag, this.tools);
     if (xmlParsed) {
       result.toolCalls.push({
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: xmlParsed.name,
         arguments: xmlParsed.arguments,
       });
@@ -361,31 +427,30 @@ export class StreamingToolParser {
   }
 
   private tryRecoverToolCall(block: string): ParsedToolCall | null {
-    // Try full parse first
-    const xmlParsed = parseXmlParameterToolCall(block, this.currentOpenTag, this.tools);
+    const unescaped = unescapeDoubleEscaped(block);
+    
+    const xmlParsed = parseXmlParameterToolCall(unescaped, this.currentOpenTag, this.tools);
     if (xmlParsed) {
       return {
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: xmlParsed.name,
         arguments: xmlParsed.arguments,
       };
     }
 
-    // Try recoverable (unclosed parameters)
-    const recovered = parseRecoverableXmlToolCall(block, this.currentOpenTag, this.tools);
+    const recovered = parseRecoverableXmlToolCall(unescaped, this.currentOpenTag, this.tools);
     if (recovered) {
       return {
-        id: `call_${uuidv4()}`,
+        id: `call_${crypto.randomUUID()}`,
         name: recovered.name,
         arguments: recovered.arguments,
       };
     }
 
-    // Try JSON (single or multiple)
-    const jsonParsed = this.parseToolContent(block);
+    const jsonParsed = this.parseToolContent(unescaped);
     if (jsonParsed.length > 0) {
       const first = jsonParsed[0];
-      const attrName = extractToolName(this.currentOpenTag, block);
+      const attrName = extractToolName(this.currentOpenTag, unescaped);
       if (attrName && !first.name) first.name = attrName;
       if (first.name) return first;
     }
@@ -438,7 +503,7 @@ export class StreamingToolParser {
     if (typeof args !== 'object' || args === null) args = {};
 
     return {
-      id: parsed.id || parsed.tool_call_id || `call_${uuidv4()}`,
+      id: parsed.id || parsed.tool_call_id || `call_${crypto.randomUUID()}`,
       name,
       arguments: args,
     };