fix(tools): tolerate smart/curly-quote JSON in tool-call arguments (no retry loop)

Device 2026-07-15: a local model (Qwythos GGUF) emitted tool-call arguments with CURLY double quotes
— {“expression”:“7 * 7”} — which strict JSON.parse rejects. parseToolCall then fell back to args={},
so the calculator got an EMPTY call, schema validation failed, and the model retried the same call
in a loop until it happened to emit straight quotes ('worked eventually').

Fix: parseToolArguments tries strict JSON first (unchanged for the common case), then retries once
with curly double quotes normalized to straight — only the string DELIMITERS, never content. The real
expression now reaches the tool on the first try. Tested through the real generateWithToolsImpl path
(fake engine boundary emits the curly-quote tool_call), red-verified by reverting the normalization.

NOTE: the raw <tool_call>…</tool_call> / [Tool Result] text seen in the reply was the model QUOTING
its own calls inside its <think> reasoning (rendered as thinking text) — the display stripper already
handles real tool-call blocks (messageContent.ts). That's the model narrating, not a strip miss.

Author: alichherawalla

__tests__/unit/services/llmToolGeneration.test.ts

@@ -406,6 +406,29 @@ describe('generateWithToolsImpl', () => {
       expect(result.toolCalls[0].arguments).toEqual({ expression: '3*3' });
     });
 
+    it('parses arguments that use smart/curly quotes as delimiters (no empty-args retry loop)', async () => {
+      // Device 2026-07-15: a local model emitted `{“expression”:“7 * 7”}` with CURLY double quotes.
+      // Strict JSON.parse throws → args became {} → the calculator got an empty call → schema
+      // validation failed → the model retried the same call in a loop. The parser now normalizes the
+      // curly delimiters, so the real expression reaches the tool on the first try.
+      const completion = jest.fn(async (_params: any, cb: any) => {
+        cb({
+          tool_calls: [
+            { id: 'call_curly', function: { name: 'calculator', arguments: '{“expression”:“7 * 7”}' } },
+          ],
+        });
+        return {};
+      });
+      const deps = createMockDeps({ context: { completion } });
+
+      const result = await generateWithToolsImpl(deps, [createUserMessage('multiply 7 by 7')], {
+        tools: SAMPLE_TOOLS,
+      });
+
+      expect(result.toolCalls[0].name).toBe('calculator');
+      expect(result.toolCalls[0].arguments).toEqual({ expression: '7 * 7' }); // NOT {} — curly quotes normalized
+    });
+
     it('handles tool call with missing function fields gracefully', async () => {
       const completion = jest.fn(async (_params: any, cb: any) => {
         cb({

src/services/llmToolGeneration.ts

@@ -91,11 +91,32 @@ export class ToolCallTokenFilter {
   }
 }
 
+/**
+ * Parse a tool call's `arguments` JSON string into an object, tolerating the smart/curly quotes some
+ * local models emit as string delimiters. Plain JSON.parse rejects `{"expression":"7 * 7"}` (curly
+ * double quotes) → args became `{}` → the tool got an EMPTY call → schema validation failed → the
+ * model retried the same call in a loop until it happened to emit straight quotes (device 2026-07-15).
+ * We try strict JSON first (unchanged for the common case), then retry once with curly double quotes
+ * normalized to straight. Zero-IO; exercised through generateWithToolsImpl in tests.
+ */
+function parseToolArguments(raw: string): Record<string, unknown> {
+  const tryParse = (s: string): Record<string, unknown> | undefined => {
+    try {
+      const v = JSON.parse(s || '{}');
+      return v && typeof v === 'object' && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  // Normalize only the JSON string DELIMITERS (curly → straight double quotes); leave content alone.
+  return tryParse(raw) ?? tryParse(raw.replace(/[“”]/g, '"')) ?? {};
+}
+
 function parseToolCall(tc: any): ToolCall {
   const fn = tc.function || {};
   let args = fn.arguments || {};
   if (typeof args === 'string') {
-    try { args = JSON.parse(args || '{}'); } catch { args = {}; }
+    args = parseToolArguments(args);
   }
   return { id: tc.id, name: fn.name || '', arguments: args };
 }