QVAC-19908 fix: recover Qwen hybrid tool-call frames (tetherto#2677)

* fix: recover Qwen hybrid tool-call frames (QVAC-19908)

* QVAC-19908 doc: explain Qwen hybrid tool-call frame origin

Document why repairFunctionEqualsJson exists: Qwen3.5/3.6 can fuse its
XML and JSON tool templates into a single `{"function=NAME","arguments":{...}}`
frame, and the repair is intentionally scoped to that exact shape so
well-formed JSON frames are never rewritten.

(cherry picked from commit 4b3ac99)

Author: simon-iribarren

packages/sdk/server/utils/tools/parsers/hermes.ts

@@ -6,6 +6,30 @@ import {
   type ParserResult,
 } from "@/server/utils/tools/shared";
 
+// Qwen3.5/3.6 can fuse its two tool templates into one frame, embedding the
+// XML `<function=NAME>` token as a bare string key inside the JSON envelope:
+//   {"function=NAME","arguments":{...}}  (invalid JSON, not parseable as-is)
+// Rewrite only that exact shape to a canonical `{"name":NAME,"arguments":...}`
+// frame. Kept deliberately narrow so well-formed JSON frames are never touched.
+function repairFunctionEqualsJson(candidate: string): string | undefined {
+  const match =
+    /^\{\s*"function=([^"]+)"\s*,\s*"arguments"\s*:\s*([\s\S]+)\}\s*$/.exec(
+      candidate,
+    );
+  if (!match) return undefined;
+  return `{"name":${JSON.stringify(match[1])},"arguments":${match[2]}}`;
+}
+
+function parseHermesJson(candidate: string): unknown {
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    const repaired = repairFunctionEqualsJson(candidate);
+    if (repaired === undefined) throw err;
+    return JSON.parse(repaired);
+  }
+}
+
 // Hermes-style: JSON payload wrapped in `<tool_call>...</tool_call>` tags
 export function parseHermesFormat(text: string, tools: Tool[]): ParserResult {
   const toolCalls: ToolCall[] = [];
@@ -32,7 +56,7 @@ export function parseHermesFormat(text: string, tools: Tool[]): ParserResult {
 
     let callItem: unknown;
     try {
-      callItem = JSON.parse(trimmedJson);
+      callItem = parseHermesJson(trimmedJson);
     } catch (error) {
       errors.push({
         code: "PARSE_ERROR",
@@ -96,7 +120,7 @@ function recoverIncompleteHermesFrame(
 
   let parsed: unknown;
   try {
-    parsed = JSON.parse(candidate);
+    parsed = parseHermesJson(candidate);
   } catch {
     return { matched: false, toolCalls: [], errors: [] };
   }

packages/sdk/test/unit/tool-parser.test.ts

@@ -972,6 +972,33 @@ test("parseToolCalls(dialect=qwen35): JSON inside tool_call falls through to her
   t.alike(toolCalls[0]?.arguments, { city: "Seoul" });
 });
 
+test("parseToolCalls(dialect=qwen35): recovers function-equals JSON hybrid", (t) => {
+  const webfetchTool: Tool = {
+    type: "function",
+    name: "webfetch",
+    description: "Fetch a URL",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        format: { type: "string" },
+      },
+      required: ["url"],
+    },
+  };
+  const text = `<tool_call>
+{"function=webfetch","arguments":{"url":"https://docs.opencode.ai","format":"markdown"}}
+</tool_call>`;
+  const { toolCalls, errors } = parseToolCalls(text, [webfetchTool], "qwen35");
+  t.is(errors.length, 0);
+  t.is(toolCalls.length, 1);
+  t.is(toolCalls[0]?.name, "webfetch");
+  t.alike(toolCalls[0]?.arguments, {
+    url: "https://docs.opencode.ai",
+    format: "markdown",
+  });
+});
+
 // --- gemma4 structural and error-surface tests ---
 
 test("parseGemma4NativeFormat: bare numeric arg is parsed as number", (t) => {