@pedrofariasx/qwenproxy 1.2.2 → 1.3.0

package/src/tests/parser.test.ts

@@ -1,11 +1,13 @@
 import { test } from 'node:test';
 import assert from 'node:assert';
-import { StreamingToolParser } from '../tools/parser.ts';
+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,28 +59,111 @@ 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');
   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 = `${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');
+  assert.strictEqual(res.toolCalls[0].arguments.filePath, '/tmp/test.txt');
+});
+
+test('StreamingToolParser: double-escaped quotes in XML parameters', () => {
+  const parser = new StreamingToolParser();
+  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');
+  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(`${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');
+});
+
+test('StreamingToolParser: flush double-escaped tool call', () => {
+  const parser = new StreamingToolParser();
+  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

@@ -30,6 +30,29 @@ function decodeXmlEntities(value: string): string {
     .replace(/&/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,69 @@ 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;
 }
@@ -211,11 +284,10 @@ export class StreamingToolParser {
           }
           break;
         }
-      } else {
-        // Inside tool: look for </tool_call>
-        const lowerBuffer = this.buffer.toLowerCase();
-        const endIdx = lowerBuffer.indexOf(TOOL_END);
-        if (endIdx !== -1) {
+       } else {
+        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);
@@ -223,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];
@@ -236,7 +308,7 @@ export class StreamingToolParser {
             }
           }
         } else {
-          break; // Wait for more data
+          break;
         }
       }
     }
@@ -284,9 +356,8 @@ export class StreamingToolParser {
   // ─── 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;
@@ -295,7 +366,8 @@ 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({
@@ -358,8 +430,9 @@ 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_${crypto.randomUUID()}`,
@@ -368,8 +441,7 @@ export class StreamingToolParser {
       };
     }
 
-    // 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_${crypto.randomUUID()}`,
@@ -378,11 +450,10 @@ export class StreamingToolParser {
       };
     }
 
-    // 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;
     }

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 {
@@ -31,11 +31,13 @@ function truncateSemantically(content: string, maxChars: number): string {
 }
 
 export function truncateMessages(
-  messages: Array<{ role: string; content: string | null | any[] }>,
+  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

@@ -4,7 +4,7 @@
  * Robust JSON parsing utilities
  */
 
-function sanitizeAndBalance(input: string): { result: string; openBraces: number; openBrackets: number } {
+function sanitizeAndBalance(input: string): { result: string; openBraces: number; openBrackets: number; inString: boolean } {
   let out = '';
   let openBraces = 0;
   let openBrackets = 0;
@@ -48,16 +48,135 @@ function sanitizeAndBalance(input: string): { result: string; openBraces: number
       if (char === ']') openBrackets--;
     }
   }
-  return { result: out, openBraces, openBrackets };
+  return { result: out, openBraces, openBrackets, inString };
 }
 
-function closeBraces(input: string, openBraces: number, openBrackets: number): string {
+function closeBraces(input: string, openBraces: number, openBrackets: number, inString: boolean = false): string {
   let out = input;
+  if (inString) out += '"';
   if (openBrackets > 0) out += ']'.repeat(openBrackets);
   if (openBraces > 0) out += '}'.repeat(openBraces);
   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();
@@ -68,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:');
 
@@ -79,7 +199,7 @@ export function robustParseJSON(str: string): any {
     cleaned = cleaned.slice(0, -1).trim();
   }
 
-  const { result: fixedJson, openBraces, openBrackets } = sanitizeAndBalance(cleaned);
+  const { result: fixedJson, openBraces, openBrackets, inString } = sanitizeAndBalance(cleaned);
   let lastBalancedIndex = -1;
 
   { let ob = 0, bk = 0, ins = false, esc = false;
@@ -99,15 +219,15 @@ export function robustParseJSON(str: string): any {
   let tempJson = fixedJson;
   if (lastBalancedIndex !== -1 && (openBraces !== 0 || openBrackets !== 0 || fixedJson.length > lastBalancedIndex + 1)) {
     tempJson = fixedJson.substring(0, lastBalancedIndex + 1);
-  } else if (openBraces > 0 || openBrackets > 0) {
-    tempJson = closeBraces(fixedJson, openBraces, openBrackets);
+  } else if (openBraces > 0 || openBrackets > 0 || inString) {
+    tempJson = closeBraces(fixedJson, openBraces, openBrackets, inString);
   }
 
   try { return JSON.parse(tempJson); } catch (e) {
     let aggressive = fixedJson.trim();
-    if (aggressive.endsWith(',')) aggressive = aggressive.slice(0, -1);
-    const { result: aggFixed, openBraces: ob, openBrackets: bk } = sanitizeAndBalance(aggressive);
-  try { return JSON.parse(closeBraces(aggFixed, ob, bk)); } catch {
+    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;
   }
 }

package/src/utils/types.ts

@@ -8,7 +8,7 @@
  * Modified By: Pedro Farias
  */
 
-import type { JsonSchema, FunctionToolDefinition } from '../tools/types.ts';
+import type { JsonSchema, FunctionToolDefinition } from '../tools/types.js';
 export type { JsonSchema, FunctionToolDefinition };
 
 /** Tool choice options */