@ai-sdk-tool/parser 4.0.1 → 4.1.0

package/dist/{chunk-DPGORNPB.js → chunk-O6NWVXQD.js}

@@ -1,16 +1,19 @@
 import {
   escapeRegExp,
+  escapeXmlMinimalAttr,
+  escapeXmlMinimalText,
   parse as parse2,
-  stringify
-} from "./chunk-76E6H46R.js";
+  stringify,
+  unescapeXml
+} from "./chunk-MHZC45AC.js";
 import {
   parse
-} from "./chunk-IX4FJELL.js";
+} from "./chunk-QBZNMO5C.js";
 import {
   coerceBySchema,
   getSchemaType,
   unwrapJsonSchema
-} from "./chunk-DJB4DAZO.js";
+} from "./chunk-GMTE7BY5.js";
 
 // src/core/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -257,7 +260,7 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
   };
 }
 
-// src/core/protocols/json-protocol.ts
+// src/core/protocols/hermes-protocol.ts
 function shouldEmitRawToolCallTextOnError(options) {
   return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
 }
@@ -800,7 +803,7 @@ function handlePartialTag(state, controller, toolCallStart, toolCallEnd) {
     state.buffer = "";
   }
 }
-var jsonProtocol = ({
+var hermesProtocol = ({
   toolCallStart = "<tool_call>",
   toolCallEnd = "</tool_call>"
 } = {}) => ({
@@ -902,14 +905,6 @@ var jsonProtocol = ({
   }
 });
 
-// src/core/protocols/protocol-interface.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-function isTCMProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
 // src/core/utils/regex-constants.ts
 var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX = /\s/;
@@ -1012,7 +1007,7 @@ ${body}
 </${rootTag}>`;
 }
 
-// src/core/protocols/xml-protocol.ts
+// src/core/protocols/morph-xml-protocol.ts
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
@@ -1988,7 +1983,7 @@ function findToolCallsWithFallbacks(text, toolNames) {
   }
   return { parseText, toolCalls };
 }
-var xmlProtocol = (protocolOptions) => {
+var morphXmlProtocol = (protocolOptions) => {
   var _a;
   const parseOptions = {
     repair: true,
@@ -2251,200 +2246,2070 @@ var xmlProtocol = (protocolOptions) => {
   };
 };
 
-// src/core/protocols/yaml-protocol.ts
-import YAML from "yaml";
-function shouldEmitRawToolCallTextOnError3(options) {
-  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+// src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
 }
-var selfClosingTagCache2 = /* @__PURE__ */ new Map();
-function getSelfClosingTagPattern2(toolName) {
-  let pattern = selfClosingTagCache2.get(toolName);
-  if (!pattern) {
-    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
-    selfClosingTagCache2.set(toolName, pattern);
-  }
-  return pattern;
+function isTCMProtocolFactory(protocol) {
+  return typeof protocol === "function";
 }
-var LEADING_WHITESPACE_RE = /^(\s*)/;
-var INCOMPLETE_MAPPING_TAIL_RE = /^[^:[\]{}-][^:]*:\s*$/;
-var INCOMPLETE_SEQUENCE_TAIL_RE = /^-\s*$/;
-var BLOCK_SCALAR_KEY_RE = /:\s*[|>][-+0-9]*\s*$/;
-var PLAIN_MAPPING_VALUE_RE = /^[^:[\]{}-][^:]*:\s*(.+)$/;
-var PLAIN_SEQUENCE_VALUE_RE = /^-\s+(.+)$/;
-function normalizeYamlContent(yamlContent) {
-  let normalized = yamlContent;
-  if (normalized.startsWith("\n")) {
-    normalized = normalized.slice(1);
+
+// src/core/utils/tool-call-coercion.ts
+function coerceToolCallInput(toolName, input, tools) {
+  var _a;
+  let args = {};
+  if (typeof input === "string") {
+    try {
+      args = JSON.parse(input);
+    } catch (e) {
+      return;
+    }
+  } else if (input && typeof input === "object") {
+    args = input;
+  } else {
+    return;
   }
-  const lines = normalized.split("\n");
-  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
-  if (nonEmptyLines.length === 0) {
-    return { normalized: "", nonEmptyLines };
+  const schema = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return JSON.stringify(coerced != null ? coerced : {});
+}
+function coerceToolCallPart(part, tools) {
+  const coercedInput = coerceToolCallInput(part.toolName, part.input, tools);
+  if (coercedInput === void 0) {
+    return part;
   }
-  const minIndent = Math.min(
-    ...nonEmptyLines.map((line) => {
-      const match = line.match(LEADING_WHITESPACE_RE);
-      return match ? match[1].length : 0;
-    })
-  );
-  if (minIndent > 0) {
-    normalized = lines.map((line) => line.slice(minIndent)).join("\n");
+  return {
+    ...part,
+    input: coercedInput
+  };
+}
+
+// src/core/protocols/qwen3coder-protocol.ts
+function shouldEmitRawToolCallTextOnError3(options) {
+  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+}
+var TOOL_CALL_OPEN_RE = /<tool_call\b[^>]*>/i;
+var TOOL_CALL_CLOSE_RE = /<\/tool_call\s*>/i;
+var TOOL_CALL_CLOSE_TRAILING_RE = /<\/tool_call\s*>\s*$/i;
+var TOOL_CALL_BLOCK_RE = /<tool_call\b[^>]*>[\s\S]*?<\/tool_call\s*>/gi;
+var LEADING_CALL_CLOSE_TAG_RE = /^\s*<\s*\/\s*(?:tool_call|function|call|tool|invoke)\s*>/i;
+var CALL_BLOCK_RE = /<(call|function|tool|invoke)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+var QWEN3CODER_TOOL_PARSER_PARAM_TAG_NAMES = /* @__PURE__ */ new Set([
+  "parameter",
+  "param",
+  "argument",
+  "arg"
+]);
+var QWEN3CODER_TOOL_PARSER_CALL_TAG_NAMES = /* @__PURE__ */ new Set([
+  "function",
+  "call",
+  "tool",
+  "invoke",
+  "tool_call"
+]);
+var CALL_SHORTHAND_VALUE_RE = /^<\s*(call|function|tool|invoke)\b\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+))/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE = /<\s*(?!\/)\s*(call|function|tool|invoke)\b[^>]*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_TOOL_CALL_CLOSE_TAG_RE = /<\s*\/\s*tool_call\s*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE = /<\s*(?!\/)\s*(name|tool_name|parameter|param|argument|arg)\b/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_NAME_TAG_RE = /<\s*(name|tool_name)\b[^>]*>([\s\S]*?)<\s*\/\s*\1\s*>/i;
+var QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE = /\/\s*>$/;
+function isAsciiWhitespace(ch) {
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "	" || ch === "\f";
+}
+function skipAsciiWhitespace(text, index) {
+  var _a;
+  let i = index;
+  while (i < text.length && isAsciiWhitespace((_a = text[i]) != null ? _a : "")) {
+    i += 1;
   }
-  return { normalized, nonEmptyLines };
+  return i;
 }
-function parseYamlDocumentAsMapping(normalized) {
-  try {
-    const doc = YAML.parseDocument(normalized);
-    const errors = doc.errors.map((e) => e.message);
-    const result = doc.toJSON();
-    if (result === null) {
-      return { value: {}, errors };
+function stripLeadingToolCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const start = skipAsciiWhitespace(out, 0);
+    const trimmed = out.slice(start);
+    const match = TOOL_CALL_CLOSE_RE.exec(trimmed);
+    if (!match || match.index !== 0 || !match[0]) {
+      return out;
     }
-    if (typeof result !== "object" || Array.isArray(result)) {
-      return { value: null, errors };
+    out = out.slice(start + match[0].length);
+  }
+}
+function stripTrailingToolCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const next = out.replace(TOOL_CALL_CLOSE_TRAILING_RE, "");
+    if (next === out) {
+      return out;
     }
-    return { value: result, errors };
-  } catch (error) {
-    return {
-      value: null,
-      errors: [
-        error instanceof Error ? error.message : "Unknown YAML parsing error"
-      ]
-    };
+    out = next;
   }
 }
-function getLastMeaningfulLineInfo(input) {
+function isTagBoundaryChar(ch) {
+  return ch === "" || isAsciiWhitespace(ch) || ch === ">" || ch === "/";
+}
+function findTagEndIndex(text, startIndex) {
   var _a;
-  const lines = input.split("\n");
-  let index = lines.length - 1;
-  while (index >= 0) {
-    const raw = (_a = lines[index]) != null ? _a : "";
-    const trimmed = raw.trim();
-    if (trimmed.length > 0 && !trimmed.startsWith("#")) {
-      return {
-        index,
-        raw,
-        trimmed,
-        indent: raw.length - raw.trimStart().length
-      };
+  let quote = null;
+  for (let i = startIndex; i < text.length; i += 1) {
+    const ch = (_a = text[i]) != null ? _a : "";
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === ">") {
+      return i;
     }
-    index -= 1;
   }
   return null;
 }
-function dropLastMeaningfulLine(input) {
-  const lineInfo = getLastMeaningfulLineInfo(input);
-  if (!lineInfo) {
+function parseShorthandValue(openTag, tagNameLower) {
+  var _a, _b;
+  let i = 1;
+  i = skipAsciiWhitespace(openTag, i);
+  if (!openTag.toLowerCase().startsWith(tagNameLower, i)) {
     return null;
   }
-  return input.split("\n").slice(0, lineInfo.index).join("\n").trimEnd();
+  i += tagNameLower.length;
+  i = skipAsciiWhitespace(openTag, i);
+  if (openTag[i] !== "=") {
+    return null;
+  }
+  i += 1;
+  i = skipAsciiWhitespace(openTag, i);
+  const quote = (_a = openTag[i]) != null ? _a : "";
+  if (quote === '"' || quote === "'") {
+    const end = openTag.indexOf(quote, i + 1);
+    if (end === -1) {
+      return null;
+    }
+    return openTag.slice(i + 1, end);
+  }
+  const start = i;
+  while (i < openTag.length) {
+    const ch = (_b = openTag[i]) != null ? _b : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/") {
+      break;
+    }
+    i += 1;
+  }
+  const value = openTag.slice(start, i);
+  return value.length > 0 ? value : null;
 }
-function hasIncompleteMappingTail(normalized) {
-  const lineInfo = getLastMeaningfulLineInfo(normalized);
-  if (!lineInfo) {
-    return false;
+function parseQwen3CoderToolParserParamName(openTag, tagNameLower) {
+  const shorthand = parseShorthandValue(openTag, tagNameLower);
+  if (shorthand != null) {
+    return unescapeXml(shorthand);
   }
-  return INCOMPLETE_MAPPING_TAIL_RE.test(lineInfo.trimmed);
+  return getAttributeValue(openTag, "name");
 }
-function hasIncompleteSequenceTail(normalized) {
-  const lineInfo = getLastMeaningfulLineInfo(normalized);
-  if (!lineInfo) {
-    return false;
+function getCdataSectionNextIndex(textLower, startIndex) {
+  if (!textLower.startsWith("<![cdata[", startIndex)) {
+    return startIndex;
   }
-  return INCOMPLETE_SEQUENCE_TAIL_RE.test(lineInfo.trimmed);
+  const cdataEnd = textLower.indexOf("]]>", startIndex + "<![cdata[".length);
+  if (cdataEnd === -1) {
+    return null;
+  }
+  return cdataEnd + 3;
 }
-function hasSplitNestedKeyTail(normalized) {
+function parseMatchingTagHeader(textLower, lt, tagNameLower) {
   var _a;
-  const lineInfo = getLastMeaningfulLineInfo(normalized);
-  if (!lineInfo) {
-    return false;
+  let i = skipAsciiWhitespace(textLower, lt + 1);
+  const isClosing = textLower[i] === "/";
+  if (isClosing) {
+    i += 1;
+    i = skipAsciiWhitespace(textLower, i);
   }
-  const { trimmed, indent, index } = lineInfo;
-  if (indent === 0) {
-    return false;
+  if (!textLower.startsWith(tagNameLower, i)) {
+    return null;
   }
-  if (trimmed.startsWith("#") || trimmed.startsWith("-") || trimmed.includes(":")) {
-    return false;
+  const afterName = i + tagNameLower.length;
+  const boundary = (_a = textLower[afterName]) != null ? _a : "";
+  const validBoundary = isClosing ? isTagBoundaryChar(boundary) : isTagBoundaryChar(boundary) || boundary === "=";
+  if (boundary && !validBoundary) {
+    return null;
   }
-  const lines = normalized.split("\n");
-  let parentIndex = index - 1;
-  while (parentIndex >= 0) {
-    const parentRaw = (_a = lines[parentIndex]) != null ? _a : "";
-    const parentTrimmed = parentRaw.trim();
-    if (parentTrimmed.length === 0 || parentTrimmed.startsWith("#")) {
-      parentIndex -= 1;
+  return { isClosing, afterName };
+}
+function isSelfClosingXmlTag(textLower, lt, gt) {
+  return textLower.slice(lt, gt + 1).trimEnd().endsWith("/>");
+}
+function findClosingTagEnd(textLower, startIndex, tagNameLower) {
+  let depth = 1;
+  let index = startIndex;
+  while (true) {
+    const lt = textLower.indexOf("<", index);
+    if (lt === -1) {
+      return null;
+    }
+    const cdataNextIndex = getCdataSectionNextIndex(textLower, lt);
+    if (cdataNextIndex == null) {
+      return null;
+    }
+    if (cdataNextIndex !== lt) {
+      index = cdataNextIndex;
       continue;
     }
-    const parentIndent = parentRaw.length - parentRaw.trimStart().length;
-    if (parentIndent >= indent) {
-      parentIndex -= 1;
+    const header = parseMatchingTagHeader(textLower, lt, tagNameLower);
+    if (!header) {
+      index = lt + 1;
       continue;
     }
-    if (!parentTrimmed.endsWith(":")) {
-      return false;
+    const gt = textLower.indexOf(">", header.afterName);
+    if (gt === -1) {
+      return null;
     }
-    if (BLOCK_SCALAR_KEY_RE.test(parentTrimmed)) {
-      return false;
+    if (header.isClosing) {
+      depth -= 1;
+      if (depth === 0) {
+        return { start: lt, end: gt + 1 };
+      }
+      index = gt + 1;
+      continue;
     }
-    return true;
+    const isSelfClosing = isSelfClosingXmlTag(textLower, lt, gt);
+    if (!isSelfClosing) {
+      depth += 1;
+    }
+    index = gt + 1;
   }
-  return false;
 }
-function extractTrailingPlainScalarValue(line) {
+function findClosingTagStartWithBoundary(lowerText, valueStart, tagNameLower, allowEndOfStringBoundary) {
   var _a;
-  if (BLOCK_SCALAR_KEY_RE.test(line)) {
-    return null;
+  const needle = `</${tagNameLower}`;
+  let searchIndex = valueStart;
+  while (searchIndex < lowerText.length) {
+    const found = lowerText.indexOf(needle, searchIndex);
+    if (found === -1) {
+      return -1;
+    }
+    const nextChar = (_a = lowerText[found + needle.length]) != null ? _a : "";
+    if (nextChar === "" && !allowEndOfStringBoundary) {
+      searchIndex = found + needle.length;
+      continue;
+    }
+    if (isTagBoundaryChar(nextChar)) {
+      return found;
+    }
+    searchIndex = found + needle.length;
   }
-  const mappingMatch = line.match(PLAIN_MAPPING_VALUE_RE);
-  const sequenceMatch = line.match(PLAIN_SEQUENCE_VALUE_RE);
-  const value = (_a = mappingMatch == null ? void 0 : mappingMatch[1]) != null ? _a : sequenceMatch == null ? void 0 : sequenceMatch[1];
-  if (!value) {
+  return -1;
+}
+function toSupportedCallEndTagName(tagNameLower) {
+  var _a;
+  const normalized = (_a = tagNameLower == null ? void 0 : tagNameLower.trim().toLowerCase()) != null ? _a : "";
+  if (!normalized) {
     return null;
   }
-  const trimmedValue = value.trim();
-  if (trimmedValue.length === 0) {
+  return QWEN3CODER_TOOL_PARSER_CALL_TAG_NAMES.has(normalized) ? normalized : null;
+}
+function findUnclosedParamBoundaryIndex(lowerText, valueStart, callEndTagNameLower, allowEndOfString) {
+  const normalizedCallEndTag = toSupportedCallEndTagName(callEndTagNameLower);
+  const callCloseIndex = normalizedCallEndTag ? findClosingTagStartWithBoundary(
+    lowerText,
+    valueStart,
+    normalizedCallEndTag,
+    allowEndOfString
+  ) : findClosingTagStartWithBoundary(
+    lowerText,
+    valueStart,
+    "function",
+    allowEndOfString
+  );
+  const indices = [
+    lowerText.indexOf("<parameter", valueStart),
+    lowerText.indexOf("<param", valueStart),
+    lowerText.indexOf("<argument", valueStart),
+    lowerText.indexOf("<arg", valueStart),
+    callCloseIndex,
+    findClosingTagStartWithBoundary(
+      lowerText,
+      valueStart,
+      "tool_call",
+      allowEndOfString
+    ),
+    lowerText.indexOf("<function", valueStart)
+  ].filter((index) => index !== -1);
+  if (indices.length === 0) {
     return null;
   }
-  if (trimmedValue.startsWith('"') || trimmedValue.startsWith("'")) {
-    return null;
+  return Math.min(...indices);
+}
+function parseQwen3CoderToolParserParamTagNameLower(lowerText, startIndex) {
+  var _a;
+  let i = skipAsciiWhitespace(lowerText, startIndex + 1);
+  if (i >= lowerText.length) {
+    return { kind: "partial" };
   }
-  if (trimmedValue.startsWith("{") || trimmedValue.startsWith("[") || trimmedValue.startsWith("|") || trimmedValue.startsWith(">")) {
+  if (lowerText[i] === "/") {
     return null;
   }
-  return trimmedValue;
-}
-function hasUnterminatedPlainScalarTail(normalized) {
-  if (normalized.endsWith("\n")) {
-    return false;
+  const nameStart = i;
+  while (i < lowerText.length) {
+    const ch = (_a = lowerText[i]) != null ? _a : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/" || ch === "=") {
+      break;
+    }
+    i += 1;
   }
-  const lineInfo = getLastMeaningfulLineInfo(normalized);
-  if (!lineInfo) {
-    return false;
+  const tagNameLower = lowerText.slice(nameStart, i);
+  if (!QWEN3CODER_TOOL_PARSER_PARAM_TAG_NAMES.has(tagNameLower)) {
+    return null;
   }
-  return extractTrailingPlainScalarValue(lineInfo.trimmed) != null;
-}
-function hasUnstableProgressTail(normalized) {
-  return hasIncompleteMappingTail(normalized) || hasIncompleteSequenceTail(normalized) || hasSplitNestedKeyTail(normalized) || hasUnterminatedPlainScalarTail(normalized);
+  return { kind: "match", tagNameLower };
 }
-function trimTrailingNewlineInUnknown(value) {
-  if (typeof value === "string") {
-    if (value.endsWith("\n")) {
-      return value.slice(0, -1);
+function parseQwen3CoderToolParserUnclosedParamValue(options) {
+  var _a;
+  const valueStart = options.openEnd + 1;
+  const boundaryIndex = findUnclosedParamBoundaryIndex(
+    options.lowerText,
+    valueStart,
+    (_a = options.callEndTagNameLower) != null ? _a : null,
+    options.allowEndOfString
+  );
+  if (boundaryIndex == null) {
+    if (!options.allowEndOfString) {
+      return {
+        kind: "partial",
+        start: options.startIndex,
+        openEnd: options.openEnd
+      };
     }
-    return value;
+    const rawValue2 = options.text.slice(valueStart);
+    return {
+      kind: "match",
+      start: options.startIndex,
+      end: options.text.length,
+      name: options.paramName,
+      value: rawValue2 ? normalizeXmlTextValue(rawValue2) : ""
+    };
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => trimTrailingNewlineInUnknown(item));
+  const rawValue = options.text.slice(valueStart, boundaryIndex);
+  return {
+    kind: "match",
+    start: options.startIndex,
+    end: boundaryIndex,
+    name: options.paramName,
+    value: rawValue ? normalizeXmlTextValue(rawValue) : ""
+  };
+}
+function parseQwen3CoderToolParserParamTagAt(text, lowerText, startIndex, options) {
+  var _a;
+  const tagNameParse = parseQwen3CoderToolParserParamTagNameLower(
+    lowerText,
+    startIndex
+  );
+  if (!tagNameParse) {
+    return null;
   }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, item]) => [
-        key,
-        trimTrailingNewlineInUnknown(item)
-      ])
-    );
+  if (tagNameParse.kind === "partial") {
+    return { kind: "partial", start: startIndex, openEnd: null };
   }
-  return value;
+  const tagNameLower = tagNameParse.tagNameLower;
+  const openEnd = findTagEndIndex(text, startIndex);
+  if (openEnd == null) {
+    return { kind: "partial", start: startIndex, openEnd: null };
+  }
+  const openTag = text.slice(startIndex, openEnd + 1);
+  const paramNameRaw = parseQwen3CoderToolParserParamName(
+    openTag,
+    tagNameLower
+  );
+  const paramName = (_a = paramNameRaw == null ? void 0 : paramNameRaw.trim()) != null ? _a : "";
+  if (paramName.length === 0) {
+    return null;
+  }
+  const selfClosing = openTag.trimEnd().endsWith("/>");
+  if (selfClosing) {
+    return {
+      kind: "match",
+      start: startIndex,
+      end: openEnd + 1,
+      name: paramName,
+      value: ""
+    };
+  }
+  const valueStart = openEnd + 1;
+  const close = findClosingTagEnd(lowerText, valueStart, tagNameLower);
+  if (!close) {
+    return parseQwen3CoderToolParserUnclosedParamValue({
+      text,
+      lowerText,
+      startIndex,
+      openEnd,
+      paramName,
+      allowEndOfString: (options == null ? void 0 : options.allowEndOfString) === true,
+      callEndTagNameLower: options == null ? void 0 : options.callEndTagNameLower
+    });
+  }
+  const rawValue = text.slice(openEnd + 1, close.start);
+  return {
+    kind: "match",
+    start: startIndex,
+    end: close.end,
+    name: paramName,
+    value: rawValue ? normalizeXmlTextValue(rawValue) : ""
+  };
+}
+function normalizeXmlTextValue(raw) {
+  let out = raw.trim();
+  if (out.startsWith("<![CDATA[") && out.endsWith("]]>")) {
+    out = out.slice("<![CDATA[".length, -"]]>".length).trim();
+  }
+  return unescapeXml(out);
+}
+function getOpeningTag(xml) {
+  const gt = xml.indexOf(">");
+  if (gt === -1) {
+    return null;
+  }
+  return xml.slice(0, gt + 1);
+}
+var attrValueRegExpCache = /* @__PURE__ */ new Map();
+function getAttributeValue(openTag, attrName) {
+  var _a;
+  let re = attrValueRegExpCache.get(attrName);
+  if (!re) {
+    re = new RegExp(
+      `\\b${escapeRegExp(attrName)}\\s*=\\s*(["'])([\\s\\S]*?)\\1`,
+      "i"
+    );
+    attrValueRegExpCache.set(attrName, re);
+  }
+  const match = re.exec(openTag);
+  if (!match) {
+    return null;
+  }
+  return unescapeXml((_a = match[2]) != null ? _a : "");
+}
+function getShorthandValue(openTag) {
+  var _a, _b;
+  const match = CALL_SHORTHAND_VALUE_RE.exec(openTag);
+  if (!match) {
+    return null;
+  }
+  const value = (_b = (_a = match[2]) != null ? _a : match[3]) != null ? _b : match[4];
+  if (!value) {
+    return null;
+  }
+  return unescapeXml(value);
+}
+function extractFirstTagText(xml, tagName) {
+  var _a;
+  const lower = xml.toLowerCase();
+  const tagLower = tagName.toLowerCase();
+  let index = 0;
+  while (true) {
+    const lt = lower.indexOf("<", index);
+    if (lt === -1) {
+      return null;
+    }
+    const i = skipAsciiWhitespace(lower, lt + 1);
+    if (i >= lower.length || lower[i] === "/") {
+      index = lt + 1;
+      continue;
+    }
+    if (!lower.startsWith(tagLower, i)) {
+      index = lt + 1;
+      continue;
+    }
+    const afterName = i + tagLower.length;
+    const boundary = (_a = lower[afterName]) != null ? _a : "";
+    if (boundary && !isTagBoundaryChar(boundary)) {
+      index = lt + 1;
+      continue;
+    }
+    const openEnd = findTagEndIndex(xml, lt);
+    if (openEnd == null) {
+      return null;
+    }
+    const contentStart = openEnd + 1;
+    const close = findClosingTagEnd(lower, contentStart, tagLower);
+    if (!close) {
+      return null;
+    }
+    return normalizeXmlTextValue(xml.slice(contentStart, close.start));
+  }
+}
+function extractToolCallInnerXml(segment) {
+  const openMatch = TOOL_CALL_OPEN_RE.exec(segment);
+  const closeMatch = TOOL_CALL_CLOSE_RE.exec(segment);
+  if (!(openMatch && closeMatch)) {
+    return null;
+  }
+  const openIndex = openMatch.index;
+  const openTag = openMatch[0];
+  const openEnd = openIndex + openTag.length;
+  const closeIndex = segment.toLowerCase().lastIndexOf("</tool_call");
+  if (closeIndex === -1) {
+    return null;
+  }
+  const closeGt = segment.indexOf(">", closeIndex);
+  if (closeGt === -1) {
+    return null;
+  }
+  return {
+    outerOpenTag: openTag,
+    inner: segment.slice(openEnd, closeIndex)
+  };
+}
+function mergeParamValue(args, key, value) {
+  const existing = args[key];
+  if (existing === void 0) {
+    args[key] = value;
+    return;
+  }
+  if (Array.isArray(existing)) {
+    existing.push(value);
+    return;
+  }
+  args[key] = [existing, value];
+}
+function extractParameters(xml, options) {
+  var _a;
+  const args = {};
+  const lower = xml.toLowerCase();
+  let index = 0;
+  while (true) {
+    const lt = lower.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const parsed = parseQwen3CoderToolParserParamTagAt(xml, lower, lt, {
+      allowEndOfString: true,
+      callEndTagNameLower: options == null ? void 0 : options.callEndTagNameLower
+    });
+    if (!parsed) {
+      index = lt + 1;
+      continue;
+    }
+    if (parsed.kind === "match") {
+      mergeParamValue(args, parsed.name, parsed.value);
+      index = parsed.end;
+      continue;
+    }
+    index = ((_a = parsed.openEnd) != null ? _a : lt) + 1;
+  }
+  return args;
+}
+function parseSingleFunctionCallXml(xml, fallbackToolName) {
+  var _a, _b, _c;
+  const openingTag = getOpeningTag(xml);
+  const toolNameAttr = openingTag ? getAttributeValue(openingTag, "name") : null;
+  const shorthandName = openingTag ? getShorthandValue(openingTag) : null;
+  const toolName = (_c = (_b = (_a = toolNameAttr != null ? toolNameAttr : shorthandName) != null ? _a : extractFirstTagText(xml, "name")) != null ? _b : extractFirstTagText(xml, "tool_name")) != null ? _c : fallbackToolName;
+  const callEndTagNameLower = toSupportedCallEndTagName(
+    openingTag ? getOpenTagNameLower(openingTag) : null
+  );
+  if (!toolName || toolName.trim().length === 0) {
+    return null;
+  }
+  return {
+    toolName,
+    args: extractParameters(xml, { callEndTagNameLower })
+  };
+}
+function findImplicitCallOpenIndices(lowerText) {
+  var _a;
+  const indices = [];
+  let index = 0;
+  while (true) {
+    const lt = lowerText.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const i = skipAsciiWhitespace(lowerText, lt + 1);
+    if (i >= lowerText.length) {
+      break;
+    }
+    if (lowerText[i] === "/") {
+      index = lt + 1;
+      continue;
+    }
+    const tagNames = ["call", "function", "tool", "invoke"];
+    for (const tagName of tagNames) {
+      if (!lowerText.startsWith(tagName, i)) {
+        continue;
+      }
+      const after = i + tagName.length;
+      const boundary = (_a = lowerText[after]) != null ? _a : "";
+      if (boundary && !isTagBoundaryChar(boundary) && boundary !== "=") {
+        continue;
+      }
+      indices.push(lt);
+      break;
+    }
+    index = lt + 1;
+  }
+  return indices;
+}
+function splitImplicitCallBlocks(xml) {
+  var _a, _b;
+  const lower = xml.toLowerCase();
+  const starts = findImplicitCallOpenIndices(lower);
+  if (starts.length === 0) {
+    return [];
+  }
+  const blocks = [];
+  for (let i = 0; i < starts.length; i += 1) {
+    const start = (_a = starts[i]) != null ? _a : 0;
+    const end = (_b = starts[i + 1]) != null ? _b : xml.length;
+    blocks.push(xml.slice(start, end));
+  }
+  return blocks;
+}
+function stripLeadingCallCloseTags(text) {
+  let out = text;
+  while (true) {
+    const match = LEADING_CALL_CLOSE_TAG_RE.exec(out);
+    if (!match) {
+      return out;
+    }
+    out = out.slice(match[0].length);
+  }
+}
+function getOpenTagNameLower(openTag) {
+  var _a;
+  const lowerOpenTag = openTag.toLowerCase();
+  const lt = lowerOpenTag.indexOf("<");
+  if (lt === -1) {
+    return null;
+  }
+  let i = skipAsciiWhitespace(lowerOpenTag, lt + 1);
+  if (i >= lowerOpenTag.length || lowerOpenTag[i] === "/") {
+    return null;
+  }
+  const start = i;
+  while (i < lowerOpenTag.length) {
+    const ch = (_a = lowerOpenTag[i]) != null ? _a : "";
+    if (isAsciiWhitespace(ch) || ch === ">" || ch === "/" || ch === "=") {
+      break;
+    }
+    i += 1;
+  }
+  const tagName = lowerOpenTag.slice(start, i);
+  return tagName.length > 0 ? tagName : null;
+}
+function splitImplicitCallAndTail(callBlock) {
+  var _a;
+  const openingTag = getOpeningTag(callBlock);
+  const openingTagName = toSupportedCallEndTagName(
+    openingTag ? getOpenTagNameLower(openingTag) : null
+  );
+  const lowerCallBlock = callBlock.toLowerCase();
+  let consumed = 0;
+  if (openingTag) {
+    consumed = openingTag.length;
+    if (openingTagName) {
+      const close = findClosingTagEnd(lowerCallBlock, consumed, openingTagName);
+      if (close) {
+        consumed = Math.max(consumed, close.end);
+      }
+    }
+  }
+  let index = 0;
+  while (true) {
+    const lt = lowerCallBlock.indexOf("<", index);
+    if (lt === -1) {
+      break;
+    }
+    const parsed = parseQwen3CoderToolParserParamTagAt(
+      callBlock,
+      lowerCallBlock,
+      lt,
+      {
+        allowEndOfString: true,
+        callEndTagNameLower: openingTagName
+      }
+    );
+    if (!parsed) {
+      index = lt + 1;
+      continue;
+    }
+    if (parsed.kind === "partial") {
+      index = ((_a = parsed.openEnd) != null ? _a : lt) + 1;
+      continue;
+    }
+    consumed = Math.max(consumed, parsed.end);
+    index = parsed.end;
+  }
+  const clamped = Math.max(0, Math.min(consumed, callBlock.length));
+  return {
+    callContent: callBlock.slice(0, clamped),
+    trailingText: callBlock.slice(clamped)
+  };
+}
+function parseQwen3CoderToolParserCallBlocks(blocks, outerNameAttr) {
+  const calls = [];
+  for (const block of blocks) {
+    const parsed = parseSingleFunctionCallXml(block, outerNameAttr);
+    if (!parsed) {
+      return null;
+    }
+    calls.push(parsed);
+  }
+  return calls;
+}
+function parseQwen3CoderToolParserClosedMatches(inner, outerNameAttr) {
+  var _a, _b;
+  const callBlockMatches = Array.from(inner.matchAll(CALL_BLOCK_RE));
+  if (callBlockMatches.length === 0) {
+    return void 0;
+  }
+  const closedBlocks = [];
+  let lastClosedEnd = 0;
+  for (const match of callBlockMatches) {
+    const callBlock = (_a = match[0]) != null ? _a : "";
+    const startIndex = (_b = match.index) != null ? _b : -1;
+    if (!callBlock || startIndex < 0) {
+      continue;
+    }
+    closedBlocks.push(callBlock);
+    lastClosedEnd = startIndex + callBlock.length;
+  }
+  const closedCalls = parseQwen3CoderToolParserCallBlocks(
+    closedBlocks,
+    outerNameAttr
+  );
+  if (!closedCalls) {
+    return null;
+  }
+  const trailingInner = inner.slice(lastClosedEnd);
+  if (trailingInner.trim().length === 0) {
+    return closedCalls;
+  }
+  const trailingBlocks = splitImplicitCallBlocks(trailingInner).filter(
+    (b) => b.trim().length > 0
+  );
+  if (trailingBlocks.length === 0) {
+    return closedCalls;
+  }
+  const trailingCalls = parseQwen3CoderToolParserCallBlocks(
+    trailingBlocks,
+    outerNameAttr
+  );
+  if (!trailingCalls) {
+    return closedCalls;
+  }
+  return closedCalls.concat(trailingCalls);
+}
+function parseQwen3CoderToolParserToolCallSegment(segment) {
+  var _a;
+  const extracted = extractToolCallInnerXml(segment);
+  if (!extracted) {
+    return null;
+  }
+  const { inner, outerOpenTag } = extracted;
+  const outerNameAttr = getAttributeValue(outerOpenTag, "name");
+  const closedCalls = parseQwen3CoderToolParserClosedMatches(
+    inner,
+    outerNameAttr
+  );
+  if (closedCalls) {
+    return closedCalls;
+  }
+  if (closedCalls === null) {
+    return null;
+  }
+  const implicitBlocks = splitImplicitCallBlocks(inner).filter(
+    (b) => b.trim().length > 0
+  );
+  if (implicitBlocks.length > 0) {
+    return parseQwen3CoderToolParserCallBlocks(implicitBlocks, outerNameAttr);
+  }
+  const single = (_a = parseSingleFunctionCallXml(inner, outerNameAttr)) != null ? _a : parseSingleFunctionCallXml(segment, outerNameAttr);
+  if (!single) {
+    return null;
+  }
+  return [single];
+}
+function parseToolCallInput(input) {
+  if (input == null) {
+    return {};
+  }
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return input;
+  }
+}
+function stringifyToolInputWithSchema(options) {
+  const coerced = coerceToolCallInput(
+    options.toolName,
+    options.args,
+    options.tools
+  );
+  return coerced != null ? coerced : JSON.stringify(options.args);
+}
+function toQwen3CoderToolParserParamText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function appendQwen3CoderToolParserParameter(lines, key, value) {
+  const nameAttr = escapeXmlMinimalAttr(key, '"');
+  const text = escapeXmlMinimalText(toQwen3CoderToolParserParamText(value));
+  lines.push(`    <parameter="${nameAttr}">${text}</parameter>`);
+}
+function appendQwen3CoderToolParserArgs(lines, args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    for (const [key, value] of Object.entries(args)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          appendQwen3CoderToolParserParameter(lines, key, item);
+        }
+      } else {
+        appendQwen3CoderToolParserParameter(lines, key, value);
+      }
+    }
+    return;
+  }
+  if (args !== void 0 && args !== null && args !== "") {
+    appendQwen3CoderToolParserParameter(lines, "input", args);
+  }
+}
+var qwen3CoderProtocol = () => ({
+  formatTools({ tools, toolSystemPromptTemplate }) {
+    return toolSystemPromptTemplate(tools || []);
+  },
+  formatToolCall(toolCall) {
+    const args = parseToolCallInput(toolCall.input);
+    const lines = ["<tool_call>"];
+    lines.push(
+      `  <function="${escapeXmlMinimalAttr(toolCall.toolName, '"')}">`
+    );
+    appendQwen3CoderToolParserArgs(lines, args);
+    lines.push("  </function>");
+    lines.push("</tool_call>");
+    return lines.join("\n");
+  },
+  parseGeneratedText({ text, tools, options }) {
+    const processedElements = [];
+    const emitToolCalls = (calls) => {
+      for (const call of calls) {
+        processedElements.push({
+          type: "tool-call",
+          toolCallId: generateToolCallId(),
+          toolName: call.toolName,
+          input: stringifyToolInputWithSchema({
+            tools,
+            toolName: call.toolName,
+            args: call.args
+          })
+        });
+      }
+    };
+    const pushText = (value) => {
+      if (value.length === 0) {
+        return;
+      }
+      processedElements.push({ type: "text", text: value });
+    };
+    const tryEmitToolCallSegment = (segment, fallbackText = segment) => {
+      var _a;
+      const parsedCalls = parseQwen3CoderToolParserToolCallSegment(segment);
+      if (!parsedCalls) {
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+          options,
+          "Could not process Qwen3CoderToolParser XML tool call; keeping original text.",
+          { toolCall: fallbackText }
+        );
+        processedElements.push({ type: "text", text: fallbackText });
+        return false;
+      }
+      emitToolCalls(parsedCalls);
+      return true;
+    };
+    const emitWrapperlessCallParseFailureAsText = (raw) => {
+      var _a;
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        "Could not process Qwen3CoderToolParser <function> call; keeping original text.",
+        { toolCall: raw }
+      );
+      processedElements.push({ type: "text", text: raw });
+    };
+    const tryParseCallBlocksWithoutWrapperByImplicitStarts = (sourceText, starts) => {
+      var _a, _b;
+      let index = 0;
+      for (let i = 0; i < starts.length; i += 1) {
+        const startIndex = (_a = starts[i]) != null ? _a : -1;
+        if (startIndex < 0) {
+          continue;
+        }
+        const endIndex = (_b = starts[i + 1]) != null ? _b : sourceText.length;
+        pushText(
+          stripTrailingToolCallCloseTags(
+            stripLeadingToolCallCloseTags(sourceText.slice(index, startIndex))
+          )
+        );
+        const full = sourceText.slice(startIndex, endIndex);
+        const { callContent, trailingText } = splitImplicitCallAndTail(full);
+        const parsed = parseSingleFunctionCallXml(callContent, null);
+        if (parsed) {
+          emitToolCalls([parsed]);
+          pushText(
+            stripTrailingToolCallCloseTags(
+              stripLeadingToolCallCloseTags(trailingText)
+            )
+          );
+        } else {
+          emitWrapperlessCallParseFailureAsText(full);
+        }
+        index = endIndex;
+      }
+      pushText(
+        stripTrailingToolCallCloseTags(
+          stripLeadingToolCallCloseTags(sourceText.slice(index))
+        )
+      );
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapperByMatches = (sourceText, matches) => {
+      var _a;
+      let index = 0;
+      for (const match of matches) {
+        const full = match[0];
+        const startIndex = (_a = match.index) != null ? _a : -1;
+        if (!full || startIndex < 0) {
+          continue;
+        }
+        pushText(
+          stripTrailingToolCallCloseTags(
+            stripLeadingToolCallCloseTags(sourceText.slice(index, startIndex))
+          )
+        );
+        const parsed = parseSingleFunctionCallXml(full, null);
+        if (parsed) {
+          emitToolCalls([parsed]);
+        } else {
+          emitWrapperlessCallParseFailureAsText(full);
+        }
+        index = startIndex + full.length;
+      }
+      const trailing = sourceText.slice(index);
+      const trailingStarts = findImplicitCallOpenIndices(
+        trailing.toLowerCase()
+      );
+      if (trailingStarts.length > 0) {
+        return tryParseCallBlocksWithoutWrapperByImplicitStarts(
+          trailing,
+          trailingStarts
+        );
+      }
+      pushText(
+        stripTrailingToolCallCloseTags(stripLeadingToolCallCloseTags(trailing))
+      );
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapperText = (sourceText) => {
+      const matches = Array.from(sourceText.matchAll(CALL_BLOCK_RE));
+      if (matches.length > 0) {
+        return tryParseCallBlocksWithoutWrapperByMatches(sourceText, matches);
+      }
+      const starts = findImplicitCallOpenIndices(sourceText.toLowerCase());
+      if (starts.length === 0) {
+        return false;
+      }
+      return tryParseCallBlocksWithoutWrapperByImplicitStarts(
+        sourceText,
+        starts
+      );
+    };
+    const pushTextOrParseWrapperlessCalls = (segment) => {
+      if (segment.length === 0) {
+        return;
+      }
+      if (!tryParseCallBlocksWithoutWrapperText(segment)) {
+        pushText(segment);
+      }
+    };
+    const handleCompleteToolCallRemainder = (remainder) => {
+      if (!remainder) {
+        return;
+      }
+      const lowerRemainder = remainder.toLowerCase();
+      const trailingIndex = lowerRemainder.indexOf("<tool_call");
+      if (trailingIndex === -1) {
+        pushTextOrParseWrapperlessCalls(remainder);
+        return;
+      }
+      pushTextOrParseWrapperlessCalls(remainder.slice(0, trailingIndex));
+      const trailing = remainder.slice(trailingIndex);
+      const synthetic = TOOL_CALL_CLOSE_RE.test(trailing) ? trailing : `${trailing}</tool_call>`;
+      tryEmitToolCallSegment(synthetic, trailing);
+    };
+    const tryParseCompleteToolCallBlocks = () => {
+      var _a;
+      const matches = Array.from(text.matchAll(TOOL_CALL_BLOCK_RE));
+      if (matches.length === 0) {
+        return false;
+      }
+      let index = 0;
+      for (const match of matches) {
+        const full = match[0];
+        const startIndex = (_a = match.index) != null ? _a : -1;
+        if (!full || startIndex < 0) {
+          continue;
+        }
+        pushTextOrParseWrapperlessCalls(text.slice(index, startIndex));
+        tryEmitToolCallSegment(full);
+        index = startIndex + full.length;
+      }
+      handleCompleteToolCallRemainder(text.slice(index));
+      return true;
+    };
+    const tryParseIncompleteToolCall = () => {
+      const lowerText = text.toLowerCase();
+      const startIndex = lowerText.indexOf("<tool_call");
+      if (startIndex === -1) {
+        return false;
+      }
+      pushTextOrParseWrapperlessCalls(text.slice(0, startIndex));
+      const trailing = text.slice(startIndex);
+      const synthetic = TOOL_CALL_CLOSE_RE.test(trailing) ? trailing : `${trailing}</tool_call>`;
+      tryEmitToolCallSegment(synthetic, trailing);
+      return true;
+    };
+    const tryParseCallBlocksWithoutWrapper = () => {
+      return tryParseCallBlocksWithoutWrapperText(text);
+    };
+    const tryParseSingleFunctionCall = () => {
+      const lowerText = text.toLowerCase();
+      const startIndex = lowerText.indexOf("<function");
+      if (startIndex === -1) {
+        return false;
+      }
+      pushText(stripTrailingToolCallCloseTags(text.slice(0, startIndex)));
+      const trailing = stripLeadingToolCallCloseTags(text.slice(startIndex));
+      const parsed = parseSingleFunctionCallXml(trailing, null);
+      if (!parsed) {
+        processedElements.push({ type: "text", text: trailing });
+        return true;
+      }
+      emitToolCalls([parsed]);
+      return true;
+    };
+    if (tryParseCompleteToolCallBlocks()) {
+      return processedElements;
+    }
+    if (tryParseIncompleteToolCall()) {
+      return processedElements;
+    }
+    if (tryParseCallBlocksWithoutWrapper()) {
+      return processedElements;
+    }
+    if (tryParseSingleFunctionCall()) {
+      return processedElements;
+    }
+    return [{ type: "text", text }];
+  },
+  extractToolCallSegments({ text }) {
+    return Array.from(text.matchAll(TOOL_CALL_BLOCK_RE)).map((m) => m[0]).filter((s) => Boolean(s));
+  },
+  createStreamParser({ tools, options }) {
+    const toolCallStartPrefixLower = "<tool_call";
+    const implicitCallPrefixesLower = [
+      "<function",
+      "<call",
+      "<tool",
+      "<invoke"
+    ];
+    let buffer = "";
+    let toolCall = null;
+    let implicitCall = null;
+    let implicitCallOpenTag = null;
+    let currentTextId = null;
+    let hasEmittedTextStart = false;
+    const flushText = createFlushTextHandler(
+      () => currentTextId,
+      (id) => {
+        currentTextId = id;
+      },
+      () => hasEmittedTextStart,
+      (value) => {
+        hasEmittedTextStart = value;
+      }
+    );
+    const removeSlice = (text, start, end) => text.slice(0, start) + text.slice(end);
+    const maybeEmitToolInputStart = (controller, callState) => {
+      if (callState.hasEmittedStart) {
+        return;
+      }
+      const toolName = callState.toolName;
+      if (!toolName || toolName.trim().length === 0) {
+        return;
+      }
+      flushText(controller);
+      controller.enqueue({
+        type: "tool-input-start",
+        id: callState.toolCallId,
+        toolName
+      });
+      callState.hasEmittedStart = true;
+    };
+    const maybeEmitToolInputProgress = (controller, callState) => {
+      if (!callState.hasEmittedStart) {
+        return;
+      }
+      const toolName = callState.toolName;
+      if (!toolName) {
+        return;
+      }
+      const fullInput = stringifyToolInputWithSchema({
+        tools,
+        toolName,
+        args: callState.args
+      });
+      if (fullInput === "{}") {
+        return;
+      }
+      const prefixCandidate = toIncompleteJsonPrefix(fullInput);
+      emitPrefixDelta({
+        controller,
+        id: callState.toolCallId,
+        state: callState,
+        candidate: prefixCandidate
+      });
+    };
+    const finalizeCall = (controller, callState, fallbackToolName, rawToolCallText = null) => {
+      var _a, _b;
+      const resolvedToolName = (_a = callState.toolName) != null ? _a : fallbackToolName;
+      if (!resolvedToolName || resolvedToolName.trim().length === 0) {
+        const shouldEmitRaw = shouldEmitRawToolCallTextOnError3(options);
+        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+          options,
+          shouldEmitRaw && rawToolCallText ? "Could not resolve Qwen3CoderToolParser tool name for tool call; emitting original text." : "Could not resolve Qwen3CoderToolParser tool name for tool call",
+          {
+            toolCallId: callState.toolCallId,
+            toolCall: rawToolCallText
+          }
+        );
+        if (callState.hasEmittedStart) {
+          controller.enqueue({
+            type: "tool-input-end",
+            id: callState.toolCallId
+          });
+        }
+        if (shouldEmitRaw && rawToolCallText) {
+          flushText(controller, rawToolCallText);
+        }
+        return false;
+      }
+      callState.toolName = resolvedToolName;
+      maybeEmitToolInputStart(controller, callState);
+      maybeEmitToolInputProgress(controller, callState);
+      const finalInput = stringifyToolInputWithSchema({
+        tools,
+        toolName: resolvedToolName,
+        args: callState.args
+      });
+      emitFinalRemainder({
+        controller,
+        id: callState.toolCallId,
+        state: callState,
+        finalFullJson: finalInput,
+        onMismatch: options == null ? void 0 : options.onError
+      });
+      controller.enqueue({
+        type: "tool-input-end",
+        id: callState.toolCallId
+      });
+      controller.enqueue({
+        type: "tool-call",
+        toolCallId: callState.toolCallId,
+        toolName: resolvedToolName,
+        input: finalInput
+      });
+      return true;
+    };
+    const consumeToolNameTag = (controller, callState, work) => {
+      var _a, _b, _c, _d;
+      if (callState.toolName) {
+        return work;
+      }
+      const match = QWEN3CODER_TOOL_PARSER_STREAM_NAME_TAG_RE.exec(work);
+      if (!match) {
+        return work;
+      }
+      const value = normalizeXmlTextValue((_a = match[2]) != null ? _a : "");
+      if (value.trim().length > 0) {
+        callState.toolName = value;
+      }
+      const start = (_b = match.index) != null ? _b : 0;
+      const nextWork = removeSlice(
+        work,
+        start,
+        start + ((_d = (_c = match[0]) == null ? void 0 : _c.length) != null ? _d : 0)
+      );
+      maybeEmitToolInputStart(controller, callState);
+      return nextWork;
+    };
+    const consumeParamTags = (controller, callState, work, allowEndOfString) => {
+      const lower = work.toLowerCase();
+      let index = 0;
+      let lastKept = 0;
+      let pieces = null;
+      while (true) {
+        const lt = lower.indexOf("<", index);
+        if (lt === -1) {
+          break;
+        }
+        const parsed = parseQwen3CoderToolParserParamTagAt(work, lower, lt, {
+          allowEndOfString,
+          callEndTagNameLower: callState.endTagName
+        });
+        if (!parsed) {
+          index = lt + 1;
+          continue;
+        }
+        if (parsed.kind === "partial") {
+          break;
+        }
+        mergeParamValue(callState.args, parsed.name, parsed.value);
+        pieces != null ? pieces : pieces = [];
+        pieces.push(work.slice(lastKept, parsed.start));
+        lastKept = parsed.end;
+        index = parsed.end;
+      }
+      maybeEmitToolInputStart(controller, callState);
+      if (!pieces) {
+        return work;
+      }
+      pieces.push(work.slice(lastKept));
+      return pieces.join("");
+    };
+    const parseCallContent = (controller, callState, content, allowEndOfString) => {
+      let work = content;
+      work = consumeToolNameTag(controller, callState, work);
+      work = consumeParamTags(controller, callState, work, allowEndOfString);
+      maybeEmitToolInputStart(controller, callState);
+      maybeEmitToolInputProgress(controller, callState);
+      return work;
+    };
+    const closeTagCache = /* @__PURE__ */ new Map();
+    const getCloseTagPattern = (endTagName) => {
+      const cached = closeTagCache.get(endTagName);
+      if (cached) {
+        return cached;
+      }
+      const created = new RegExp(
+        `<\\s*\\/\\s*${escapeRegExp(endTagName)}\\s*>`,
+        "i"
+      );
+      closeTagCache.set(endTagName, created);
+      return created;
+    };
+    const getNextCallStartInBuffer = (callState) => {
+      var _a;
+      if (callState.endTagName === "tool_call") {
+        return -1;
+      }
+      const match = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(
+        callState.buffer
+      );
+      return (_a = match == null ? void 0 : match.index) != null ? _a : -1;
+    };
+    const finalizeStreamingCall = (controller, callState, fallbackToolName, remainder) => {
+      const rawToolCallText = remainder.length > 0 && callState.raw.endsWith(remainder) ? callState.raw.slice(0, -remainder.length) : callState.raw;
+      const ok = finalizeCall(
+        controller,
+        callState,
+        fallbackToolName,
+        rawToolCallText
+      );
+      if (ok && toolCall) {
+        toolCall.emittedToolCallCount += 1;
+      }
+    };
+    const consumeCallAtNextBoundary = (controller, callState, fallbackToolName, nextCallStart) => {
+      const beforeNextCall = callState.buffer.slice(0, nextCallStart);
+      const afterNextCall = callState.buffer.slice(nextCallStart);
+      callState.buffer = parseCallContent(
+        controller,
+        callState,
+        beforeNextCall,
+        true
+      );
+      finalizeStreamingCall(
+        controller,
+        callState,
+        fallbackToolName,
+        afterNextCall
+      );
+      return { done: true, remainder: afterNextCall };
+    };
+    const consumeCall = (controller, callState, incoming, fallbackToolName) => {
+      var _a, _b, _c;
+      callState.buffer += incoming;
+      callState.raw += incoming;
+      const closeMatch = getCloseTagPattern(callState.endTagName).exec(
+        callState.buffer
+      );
+      const closeStart = (_a = closeMatch == null ? void 0 : closeMatch.index) != null ? _a : -1;
+      const nextCallStart = getNextCallStartInBuffer(callState);
+      const shouldCloseAtNextBoundary = nextCallStart !== -1 && (closeStart === -1 || nextCallStart < closeStart);
+      if (shouldCloseAtNextBoundary) {
+        return consumeCallAtNextBoundary(
+          controller,
+          callState,
+          fallbackToolName,
+          nextCallStart
+        );
+      }
+      if (!closeMatch) {
+        callState.buffer = parseCallContent(
+          controller,
+          callState,
+          callState.buffer,
+          false
+        );
+        return { done: false, remainder: "" };
+      }
+      const closeEnd = closeStart + ((_c = (_b = closeMatch[0]) == null ? void 0 : _b.length) != null ? _c : 0);
+      const beforeClose = callState.buffer.slice(0, closeStart);
+      const afterClose = callState.buffer.slice(closeEnd);
+      parseCallContent(controller, callState, beforeClose, true);
+      callState.buffer = "";
+      finalizeStreamingCall(
+        controller,
+        callState,
+        fallbackToolName,
+        afterClose
+      );
+      return { done: true, remainder: afterClose };
+    };
+    const finalizeCallAtFinish = (controller, callState, fallbackToolName) => {
+      callState.buffer = parseCallContent(
+        controller,
+        callState,
+        callState.buffer,
+        true
+      );
+      const trailingText = stripLeadingCallCloseTags(callState.buffer);
+      callState.buffer = "";
+      const ok = finalizeCall(controller, callState, fallbackToolName, null);
+      return {
+        ok,
+        trailingText
+      };
+    };
+    const flushSafeTextPrefix = (controller) => {
+      const lower = buffer.toLowerCase();
+      const potentialIndices = [
+        getPotentialStartIndex(lower, toolCallStartPrefixLower),
+        ...implicitCallPrefixesLower.map(
+          (prefix) => getPotentialStartIndex(lower, prefix)
+        )
+      ].filter((value) => value != null);
+      const potentialIndex = potentialIndices.length > 0 ? Math.min(...potentialIndices) : null;
+      if (potentialIndex == null) {
+        if (buffer.length > 0) {
+          flushText(controller, buffer);
+          buffer = "";
+        }
+        return;
+      }
+      if (potentialIndex > 0) {
+        flushText(controller, buffer.slice(0, potentialIndex));
+        buffer = buffer.slice(potentialIndex);
+      }
+    };
+    const stripLeadingToolCallCloseTagsFromBuffer = () => {
+      if (!buffer) {
+        return;
+      }
+      const stripped = stripLeadingToolCallCloseTags(buffer);
+      if (stripped !== buffer) {
+        buffer = stripped;
+      }
+    };
+    const startToolCallIfPresent = (_controller) => {
+      if (toolCall) {
+        return;
+      }
+      if (implicitCall) {
+        return;
+      }
+      const lower = buffer.toLowerCase();
+      const startIndex = getPotentialStartIndex(
+        lower,
+        toolCallStartPrefixLower
+      );
+      if (startIndex == null || startIndex !== 0) {
+        return;
+      }
+      const gtIndex = buffer.indexOf(">");
+      if (gtIndex === -1) {
+        return;
+      }
+      const openTag = buffer.slice(0, gtIndex + 1);
+      if (!TOOL_CALL_OPEN_RE.test(openTag)) {
+        return;
+      }
+      toolCall = {
+        outerOpenTag: openTag,
+        outerNameAttr: getAttributeValue(openTag, "name"),
+        raw: openTag,
+        mode: "unknown",
+        innerBuffer: "",
+        activeCall: null,
+        emittedToolCallCount: 0
+      };
+      const remainder = buffer.slice(gtIndex + 1);
+      buffer = "";
+      if (remainder.length > 0) {
+        toolCall.raw += remainder;
+        toolCall.innerBuffer += remainder;
+      }
+    };
+    const startImplicitCallIfPresent = (controller) => {
+      var _a, _b, _c, _d;
+      if (toolCall || implicitCall) {
+        return;
+      }
+      const match = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(buffer);
+      const startIndex = (_a = match == null ? void 0 : match.index) != null ? _a : -1;
+      const openTag = (_b = match == null ? void 0 : match[0]) != null ? _b : "";
+      const callTagName = ((_c = match == null ? void 0 : match[1]) != null ? _c : "").toLowerCase();
+      if (!match || startIndex !== 0 || !openTag || !callTagName) {
+        return;
+      }
+      const inlineToolName = (_d = getAttributeValue(openTag, "name")) != null ? _d : getShorthandValue(openTag);
+      if (!inlineToolName || inlineToolName.trim().length === 0) {
+        return;
+      }
+      const selfClosing = QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE.test(openTag);
+      buffer = buffer.slice(openTag.length);
+      const newCall = {
+        endTagName: callTagName,
+        toolCallId: generateToolCallId(),
+        toolName: inlineToolName,
+        hasEmittedStart: false,
+        emittedInput: "",
+        raw: openTag,
+        args: {},
+        buffer: ""
+      };
+      maybeEmitToolInputStart(controller, newCall);
+      if (selfClosing) {
+        finalizeCall(controller, newCall, inlineToolName, newCall.raw);
+        return;
+      }
+      implicitCall = newCall;
+      implicitCallOpenTag = openTag;
+    };
+    const processImplicitCall = (controller) => {
+      while (implicitCall) {
+        const callState = implicitCall;
+        const { done, remainder } = consumeCall(
+          controller,
+          callState,
+          buffer,
+          null
+        );
+        buffer = "";
+        if (!done) {
+          return;
+        }
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        if (remainder.length > 0) {
+          buffer = remainder;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        startToolCallIfPresent(controller);
+        if (toolCall) {
+          processToolCall2(controller);
+          return;
+        }
+        startImplicitCallIfPresent(controller);
+      }
+    };
+    const drainStarts = (controller) => {
+      while (true) {
+        if (toolCall || implicitCall) {
+          return;
+        }
+        const before = buffer;
+        startToolCallIfPresent(controller);
+        if (toolCall) {
+          processToolCall2(controller);
+          return;
+        }
+        startImplicitCallIfPresent(controller);
+        if (implicitCall) {
+          processImplicitCall(controller);
+          return;
+        }
+        if (buffer === before) {
+          return;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+      }
+    };
+    const processToolCall2 = (controller) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      while (toolCall) {
+        if (toolCall.mode === "unknown") {
+          const callMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE.exec(
+            toolCall.innerBuffer
+          );
+          const signalMatch = QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE.exec(
+            toolCall.innerBuffer
+          );
+          if (callMatch && (!signalMatch || ((_a = callMatch.index) != null ? _a : 0) < ((_b = signalMatch.index) != null ? _b : 0))) {
+            toolCall.mode = "multi";
+          } else if (signalMatch) {
+            toolCall.mode = "single";
+            const activeCall = {
+              endTagName: "tool_call",
+              toolCallId: generateToolCallId(),
+              toolName: toolCall.outerNameAttr,
+              hasEmittedStart: false,
+              emittedInput: "",
+              raw: toolCall.outerOpenTag,
+              args: {},
+              buffer: ""
+            };
+            toolCall.activeCall = activeCall;
+            if (toolCall.outerNameAttr) {
+              maybeEmitToolInputStart(controller, activeCall);
+            }
+          } else {
+            return;
+          }
+        }
+        if (toolCall.mode === "single") {
+          const callState = toolCall.activeCall;
+          if (!callState) {
+            return;
+          }
+          const { done, remainder } = consumeCall(
+            controller,
+            callState,
+            toolCall.innerBuffer,
+            toolCall.outerNameAttr
+          );
+          toolCall.innerBuffer = "";
+          if (!done) {
+            return;
+          }
+          toolCall = null;
+          if (remainder.length > 0) {
+            buffer = remainder + buffer;
+          }
+          flushSafeTextPrefix(controller);
+          startToolCallIfPresent(controller);
+          continue;
+        }
+        if (toolCall.mode === "multi") {
+          if (toolCall.activeCall) {
+            const callState = toolCall.activeCall;
+            const { done, remainder } = consumeCall(
+              controller,
+              callState,
+              toolCall.innerBuffer,
+              toolCall.outerNameAttr
+            );
+            toolCall.innerBuffer = "";
+            if (!done) {
+              return;
+            }
+            toolCall.activeCall = null;
+            toolCall.innerBuffer = remainder;
+            continue;
+          }
+          const closeMatch = QWEN3CODER_TOOL_PARSER_STREAM_TOOL_CALL_CLOSE_TAG_RE.exec(
+            toolCall.innerBuffer
+          );
+          const callOpenMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_TAG_RE.exec(
+            toolCall.innerBuffer
+          );
+          if (!(closeMatch || callOpenMatch)) {
+            return;
+          }
+          const closeIndex = (_c = closeMatch == null ? void 0 : closeMatch.index) != null ? _c : -1;
+          const callIndex = (_d = callOpenMatch == null ? void 0 : callOpenMatch.index) != null ? _d : -1;
+          const hasClose = closeIndex !== -1;
+          const hasCall = callIndex !== -1;
+          const chooseClose = hasClose && (!hasCall || closeIndex < callIndex);
+          const nextIndex = chooseClose ? closeIndex : callIndex;
+          if (nextIndex > 0) {
+            toolCall.innerBuffer = toolCall.innerBuffer.slice(nextIndex);
+          }
+          if (chooseClose) {
+            const matchLen = (_f = (_e = closeMatch == null ? void 0 : closeMatch[0]) == null ? void 0 : _e.length) != null ? _f : 0;
+            const remainder = toolCall.innerBuffer.slice(matchLen);
+            toolCall = null;
+            if (remainder.length > 0) {
+              buffer = remainder + buffer;
+            }
+            flushSafeTextPrefix(controller);
+            startToolCallIfPresent(controller);
+            continue;
+          }
+          if (!callOpenMatch) {
+            return;
+          }
+          const openTag = (_g = callOpenMatch[0]) != null ? _g : "";
+          const callTagName = ((_h = callOpenMatch[1]) != null ? _h : "").toLowerCase();
+          const rest = toolCall.innerBuffer.slice(openTag.length);
+          const selfClosing = QWEN3CODER_TOOL_PARSER_STREAM_SELF_CLOSING_TAG_RE.test(openTag);
+          if (selfClosing) {
+            const toolNameAttr2 = (_j = (_i = getAttributeValue(openTag, "name")) != null ? _i : getShorthandValue(openTag)) != null ? _j : toolCall.outerNameAttr;
+            const immediateCall = {
+              endTagName: callTagName,
+              toolCallId: generateToolCallId(),
+              toolName: toolNameAttr2,
+              hasEmittedStart: false,
+              emittedInput: "",
+              raw: openTag,
+              args: {},
+              buffer: ""
+            };
+            const ok = finalizeCall(
+              controller,
+              immediateCall,
+              toolNameAttr2,
+              immediateCall.raw
+            );
+            if (ok) {
+              toolCall.emittedToolCallCount += 1;
+            }
+            toolCall.innerBuffer = rest;
+            continue;
+          }
+          const toolNameAttr = (_k = getAttributeValue(openTag, "name")) != null ? _k : getShorthandValue(openTag);
+          const newCall = {
+            endTagName: callTagName,
+            toolCallId: generateToolCallId(),
+            toolName: toolNameAttr,
+            hasEmittedStart: false,
+            emittedInput: "",
+            raw: openTag,
+            args: {},
+            buffer: ""
+          };
+          if (toolNameAttr) {
+            maybeEmitToolInputStart(controller, newCall);
+          }
+          toolCall.activeCall = newCall;
+          toolCall.innerBuffer = rest;
+        }
+      }
+    };
+    const reportUnfinishedToolCallAtFinish = (controller, rawToolCall) => {
+      var _a;
+      const shouldEmitRaw = shouldEmitRawToolCallTextOnError3(options);
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser XML tool call at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser XML tool call at finish.",
+        { toolCall: rawToolCall }
+      );
+      if (shouldEmitRaw) {
+        flushText(controller, rawToolCall);
+      }
+    };
+    const reportUnfinishedImplicitCallAtFinish = (controller, rawCallText) => {
+      var _a;
+      const shouldEmitRaw = shouldEmitRawToolCallTextOnError3(options);
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        shouldEmitRaw ? "Could not complete streaming Qwen3CoderToolParser call block at finish; emitting original text." : "Could not complete streaming Qwen3CoderToolParser call block at finish.",
+        { toolCall: rawCallText }
+      );
+      if (shouldEmitRaw) {
+        flushText(controller, rawCallText);
+      }
+    };
+    const handleFinish = (controller) => {
+      var _a, _b;
+      if (toolCall) {
+        processToolCall2(controller);
+        if (toolCall) {
+          if (toolCall.mode === "unknown") {
+            const callMatch = QWEN3CODER_TOOL_PARSER_STREAM_CALL_OPEN_START_RE.exec(
+              toolCall.innerBuffer
+            );
+            const signalMatch = QWEN3CODER_TOOL_PARSER_STREAM_NAME_OR_PARAM_SIGNAL_RE.exec(
+              toolCall.innerBuffer
+            );
+            if (callMatch && (!signalMatch || ((_a = callMatch.index) != null ? _a : 0) < ((_b = signalMatch.index) != null ? _b : 0))) {
+              toolCall.mode = "multi";
+            } else if (signalMatch) {
+              toolCall.mode = "single";
+              toolCall.activeCall = {
+                endTagName: "tool_call",
+                toolCallId: generateToolCallId(),
+                toolName: toolCall.outerNameAttr,
+                hasEmittedStart: false,
+                emittedInput: "",
+                raw: toolCall.outerOpenTag,
+                args: {},
+                buffer: ""
+              };
+            }
+          }
+          if (toolCall.mode === "single" && toolCall.activeCall) {
+            toolCall.activeCall.buffer += toolCall.innerBuffer;
+            toolCall.innerBuffer = "";
+            const result = finalizeCallAtFinish(
+              controller,
+              toolCall.activeCall,
+              toolCall.outerNameAttr
+            );
+            if (result.ok) {
+              toolCall.emittedToolCallCount += 1;
+            }
+            const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+            if (shouldFlushTrailingText && result.trailingText.length > 0) {
+              flushText(controller, result.trailingText);
+            }
+            if (!result.ok && toolCall.emittedToolCallCount === 0) {
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+            }
+          } else if (toolCall.mode === "multi") {
+            if (toolCall.activeCall) {
+              const result = finalizeCallAtFinish(
+                controller,
+                toolCall.activeCall,
+                toolCall.outerNameAttr
+              );
+              if (result.ok) {
+                toolCall.emittedToolCallCount += 1;
+              }
+              const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+              if (shouldFlushTrailingText && result.trailingText.length > 0) {
+                flushText(controller, result.trailingText);
+              }
+              if (!result.ok && toolCall.emittedToolCallCount === 0) {
+                reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+              }
+              toolCall.activeCall = null;
+            } else if (toolCall.emittedToolCallCount === 0) {
+              reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+            }
+          } else {
+            reportUnfinishedToolCallAtFinish(controller, toolCall.raw);
+          }
+          toolCall = null;
+        }
+      }
+      if (implicitCall) {
+        const callState = implicitCall;
+        const openTag = implicitCallOpenTag;
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        const result = finalizeCallAtFinish(controller, callState, null);
+        const shouldFlushTrailingText = result.ok || !shouldEmitRawToolCallTextOnError3(options);
+        if (shouldFlushTrailingText && result.trailingText.length > 0) {
+          flushText(controller, result.trailingText);
+        }
+        if (!result.ok && openTag) {
+          reportUnfinishedImplicitCallAtFinish(
+            controller,
+            callState.raw || openTag + callState.buffer
+          );
+        }
+      } else {
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        drainStarts(controller);
+      }
+      if (buffer.length > 0) {
+        flushText(controller, buffer);
+        buffer = "";
+      }
+      flushText(controller);
+    };
+    const handlePassthroughChunk = (controller, chunk) => {
+      if (!toolCall && buffer) {
+        flushText(controller, buffer);
+        buffer = "";
+      }
+      controller.enqueue(chunk);
+    };
+    const handleTextDeltaChunk = (controller, delta) => {
+      if (toolCall) {
+        toolCall.raw += delta;
+        toolCall.innerBuffer += delta;
+        processToolCall2(controller);
+        return;
+      }
+      if (implicitCall) {
+        const callState = implicitCall;
+        const { done, remainder } = consumeCall(
+          controller,
+          callState,
+          delta,
+          null
+        );
+        if (!done) {
+          return;
+        }
+        implicitCall = null;
+        implicitCallOpenTag = null;
+        if (remainder.length > 0) {
+          buffer = remainder + buffer;
+        }
+        stripLeadingToolCallCloseTagsFromBuffer();
+        flushSafeTextPrefix(controller);
+        drainStarts(controller);
+        return;
+      }
+      buffer += delta;
+      stripLeadingToolCallCloseTagsFromBuffer();
+      flushSafeTextPrefix(controller);
+      drainStarts(controller);
+    };
+    const handleTransformChunk = (controller, chunk) => {
+      if (chunk.type === "finish") {
+        handleFinish(controller);
+        controller.enqueue(chunk);
+        return;
+      }
+      if (chunk.type !== "text-delta") {
+        handlePassthroughChunk(controller, chunk);
+        return;
+      }
+      const delta = chunk.delta;
+      if (!delta) {
+        return;
+      }
+      handleTextDeltaChunk(controller, delta);
+    };
+    return new TransformStream({
+      transform(chunk, controller) {
+        handleTransformChunk(controller, chunk);
+      },
+      flush(controller) {
+        handleFinish(controller);
+      }
+    });
+  }
+});
+var uiTarsXmlProtocol = qwen3CoderProtocol;
+var Qwen3CoderToolParser = qwen3CoderProtocol;
+
+// src/core/protocols/yaml-xml-protocol.ts
+import YAML from "yaml";
+function shouldEmitRawToolCallTextOnError4(options) {
+  return (options == null ? void 0 : options.emitRawToolCallTextOnError) === true;
+}
+var selfClosingTagCache2 = /* @__PURE__ */ new Map();
+function getSelfClosingTagPattern2(toolName) {
+  let pattern = selfClosingTagCache2.get(toolName);
+  if (!pattern) {
+    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
+    selfClosingTagCache2.set(toolName, pattern);
+  }
+  return pattern;
+}
+var LEADING_WHITESPACE_RE = /^(\s*)/;
+var INCOMPLETE_MAPPING_TAIL_RE = /^[^:[\]{}-][^:]*:\s*$/;
+var INCOMPLETE_SEQUENCE_TAIL_RE = /^-\s*$/;
+var BLOCK_SCALAR_KEY_RE = /:\s*[|>][-+0-9]*\s*$/;
+var PLAIN_MAPPING_VALUE_RE = /^[^:[\]{}-][^:]*:\s*(.+)$/;
+var PLAIN_SEQUENCE_VALUE_RE = /^-\s+(.+)$/;
+function normalizeYamlContent(yamlContent) {
+  let normalized = yamlContent;
+  if (normalized.startsWith("\n")) {
+    normalized = normalized.slice(1);
+  }
+  const lines = normalized.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return { normalized: "", nonEmptyLines };
+  }
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = line.match(LEADING_WHITESPACE_RE);
+      return match ? match[1].length : 0;
+    })
+  );
+  if (minIndent > 0) {
+    normalized = lines.map((line) => line.slice(minIndent)).join("\n");
+  }
+  return { normalized, nonEmptyLines };
+}
+function parseYamlDocumentAsMapping(normalized) {
+  try {
+    const doc = YAML.parseDocument(normalized);
+    const errors = doc.errors.map((e) => e.message);
+    const result = doc.toJSON();
+    if (result === null) {
+      return { value: {}, errors };
+    }
+    if (typeof result !== "object" || Array.isArray(result)) {
+      return { value: null, errors };
+    }
+    return { value: result, errors };
+  } catch (error) {
+    return {
+      value: null,
+      errors: [
+        error instanceof Error ? error.message : "Unknown YAML parsing error"
+      ]
+    };
+  }
+}
+function getLastMeaningfulLineInfo(input) {
+  var _a;
+  const lines = input.split("\n");
+  let index = lines.length - 1;
+  while (index >= 0) {
+    const raw = (_a = lines[index]) != null ? _a : "";
+    const trimmed = raw.trim();
+    if (trimmed.length > 0 && !trimmed.startsWith("#")) {
+      return {
+        index,
+        raw,
+        trimmed,
+        indent: raw.length - raw.trimStart().length
+      };
+    }
+    index -= 1;
+  }
+  return null;
+}
+function dropLastMeaningfulLine(input) {
+  const lineInfo = getLastMeaningfulLineInfo(input);
+  if (!lineInfo) {
+    return null;
+  }
+  return input.split("\n").slice(0, lineInfo.index).join("\n").trimEnd();
+}
+function hasIncompleteMappingTail(normalized) {
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return INCOMPLETE_MAPPING_TAIL_RE.test(lineInfo.trimmed);
+}
+function hasIncompleteSequenceTail(normalized) {
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return INCOMPLETE_SEQUENCE_TAIL_RE.test(lineInfo.trimmed);
+}
+function hasSplitNestedKeyTail(normalized) {
+  var _a;
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  const { trimmed, indent, index } = lineInfo;
+  if (indent === 0) {
+    return false;
+  }
+  if (trimmed.startsWith("#") || trimmed.startsWith("-") || trimmed.includes(":")) {
+    return false;
+  }
+  const lines = normalized.split("\n");
+  let parentIndex = index - 1;
+  while (parentIndex >= 0) {
+    const parentRaw = (_a = lines[parentIndex]) != null ? _a : "";
+    const parentTrimmed = parentRaw.trim();
+    if (parentTrimmed.length === 0 || parentTrimmed.startsWith("#")) {
+      parentIndex -= 1;
+      continue;
+    }
+    const parentIndent = parentRaw.length - parentRaw.trimStart().length;
+    if (parentIndent >= indent) {
+      parentIndex -= 1;
+      continue;
+    }
+    if (!parentTrimmed.endsWith(":")) {
+      return false;
+    }
+    if (BLOCK_SCALAR_KEY_RE.test(parentTrimmed)) {
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+function extractTrailingPlainScalarValue(line) {
+  var _a;
+  if (BLOCK_SCALAR_KEY_RE.test(line)) {
+    return null;
+  }
+  const mappingMatch = line.match(PLAIN_MAPPING_VALUE_RE);
+  const sequenceMatch = line.match(PLAIN_SEQUENCE_VALUE_RE);
+  const value = (_a = mappingMatch == null ? void 0 : mappingMatch[1]) != null ? _a : sequenceMatch == null ? void 0 : sequenceMatch[1];
+  if (!value) {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  if (trimmedValue.length === 0) {
+    return null;
+  }
+  if (trimmedValue.startsWith('"') || trimmedValue.startsWith("'")) {
+    return null;
+  }
+  if (trimmedValue.startsWith("{") || trimmedValue.startsWith("[") || trimmedValue.startsWith("|") || trimmedValue.startsWith(">")) {
+    return null;
+  }
+  return trimmedValue;
+}
+function hasUnterminatedPlainScalarTail(normalized) {
+  if (normalized.endsWith("\n")) {
+    return false;
+  }
+  const lineInfo = getLastMeaningfulLineInfo(normalized);
+  if (!lineInfo) {
+    return false;
+  }
+  return extractTrailingPlainScalarValue(lineInfo.trimmed) != null;
+}
+function hasUnstableProgressTail(normalized) {
+  return hasIncompleteMappingTail(normalized) || hasIncompleteSequenceTail(normalized) || hasSplitNestedKeyTail(normalized) || hasUnterminatedPlainScalarTail(normalized);
+}
+function trimTrailingNewlineInUnknown(value) {
+  if (typeof value === "string") {
+    if (value.endsWith("\n")) {
+      return value.slice(0, -1);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => trimTrailingNewlineInUnknown(item));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        trimTrailingNewlineInUnknown(item)
+      ])
+    );
+  }
+  return value;
 }
 function stabilizeParsedValueForStreamProgress(value, source) {
   if (source.endsWith("\n")) {
@@ -2452,7 +4317,7 @@ function stabilizeParsedValueForStreamProgress(value, source) {
   }
   return trimTrailingNewlineInUnknown(value);
 }
-function findClosingTagEnd(text, contentStart, toolName) {
+function findClosingTagEnd2(text, contentStart, toolName) {
   let pos = contentStart;
   let depth = 1;
   while (pos < text.length) {
@@ -2550,7 +4415,7 @@ function collectToolCallsForName(text, toolName) {
       continue;
     }
     const contentStart = tagStart + startTag.length;
-    const fullTagEnd = findClosingTagEnd(text, contentStart, toolName);
+    const fullTagEnd = findClosingTagEnd2(text, contentStart, toolName);
     if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
       const endTag = `</${toolName}>`;
       const endTagStart = fullTagEnd - endTag.length;
@@ -2700,7 +4565,7 @@ function stripTrailingPartialCloseTag(content, toolName) {
   )}${preservedLeadingWhitespace}`;
   return contentWithoutPartial.trimEnd();
 }
-var yamlProtocol = (_protocolOptions) => {
+var yamlXmlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
       return toolSystemPromptTemplate(tools || []);
@@ -2824,7 +4689,7 @@ ${yamlContent}</${toolCall.toolName}>`;
           (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
             toolCall: original
           });
-          if (shouldEmitRawToolCallTextOnError3(options)) {
+          if (shouldEmitRawToolCallTextOnError4(options)) {
             flushText(controller, original);
           }
         }
@@ -2869,7 +4734,7 @@ ${yamlContent}</${toolCall.toolName}>`;
             "Could not complete streaming YAML tool call at finish.",
             { toolCall: unfinishedContent }
           );
-          if (shouldEmitRawToolCallTextOnError3(options)) {
+          if (shouldEmitRawToolCallTextOnError4(options)) {
             flushText(controller, unfinishedContent);
           }
         }
@@ -3410,36 +5275,6 @@ function recoverToolCallFromJsonCandidates(text, tools) {
   return null;
 }
 
-// src/core/utils/tool-call-coercion.ts
-function coerceToolCallInput(toolName, input, tools) {
-  var _a;
-  let args = {};
-  if (typeof input === "string") {
-    try {
-      args = JSON.parse(input);
-    } catch (e) {
-      return;
-    }
-  } else if (input && typeof input === "object") {
-    args = input;
-  } else {
-    return;
-  }
-  const schema = (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
-  return JSON.stringify(coerced != null ? coerced : {});
-}
-function coerceToolCallPart(part, tools) {
-  const coercedInput = coerceToolCallInput(part.toolName, part.input, tools);
-  if (coercedInput === void 0) {
-    return part;
-  }
-  return {
-    ...part,
-    input: coercedInput
-  };
-}
-
 // src/core/utils/tool-choice.ts
 function ensureNonEmptyToolName(name) {
   if (typeof name !== "string") {
@@ -3647,23 +5482,127 @@ async function wrapGenerate({
   };
 }
 
-// src/core/prompts/hermes-system-prompt.ts
-function hermesSystemPromptTemplate(tools) {
-  const toolsJson = JSON.stringify(tools);
-  return `You are a function calling AI model.
-You are provided with function signatures within <tools></tools> XML tags.
-You may call one or more functions to assist with the user query.
-Don't make assumptions about what values to plug into functions.
-Here are the available tools: <tools>${toolsJson}</tools>
-Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
-For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
-<tool_call>
-{"name": "<function-name>", "arguments": <args-dict>}
-</tool_call>`;
+// src/core/prompts/shared/tool-result-normalizer.ts
+function isMapping(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getMediaKindFromMediaType(mediaType) {
+  if (mediaType.startsWith("image/")) {
+    return "image";
+  }
+  if (mediaType.startsWith("audio/")) {
+    return "audio";
+  }
+  if (mediaType.startsWith("video/")) {
+    return "video";
+  }
+  return "file";
+}
+function getContentPartMediaKind(part) {
+  const contentPart = isMapping(part) ? part : void 0;
+  const type = contentPart == null ? void 0 : contentPart.type;
+  switch (type) {
+    case "image-data":
+    case "image-url":
+    case "image-file-id":
+      return "image";
+    case "file-data":
+    case "file-url":
+    case "file-id": {
+      const mediaType = contentPart == null ? void 0 : contentPart.mediaType;
+      if (typeof mediaType === "string") {
+        return getMediaKindFromMediaType(mediaType);
+      }
+      return "file";
+    }
+    case "media": {
+      const mediaType = contentPart == null ? void 0 : contentPart.mediaType;
+      if (typeof mediaType === "string") {
+        return getMediaKindFromMediaType(mediaType);
+      }
+      return "file";
+    }
+    default:
+      return null;
+  }
+}
+function shouldPassRawByStrategy(mediaKind, strategy) {
+  var _a, _b;
+  const mode = (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+  if (mode === "raw") {
+    return true;
+  }
+  if (mode === "placeholder") {
+    return false;
+  }
+  if (mode === "model") {
+    return false;
+  }
+  return ((_b = strategy == null ? void 0 : strategy.capabilities) == null ? void 0 : _b[mediaKind]) === true;
+}
+function shouldPassRawContent(contentParts, strategy) {
+  var _a;
+  const mode = (_a = strategy == null ? void 0 : strategy.mode) != null ? _a : "placeholder";
+  if (mode === "raw") {
+    return true;
+  }
+  if (mode === "placeholder") {
+    return false;
+  }
+  if (mode === "model") {
+    return false;
+  }
+  let hasSupportedMediaContent = false;
+  for (const part of contentParts) {
+    const mediaKind = getContentPartMediaKind(part);
+    if (!mediaKind) {
+      continue;
+    }
+    hasSupportedMediaContent = true;
+    if (!shouldPassRawByStrategy(mediaKind, strategy)) {
+      return false;
+    }
+  }
+  return hasSupportedMediaContent;
+}
+function formatContentPartPlaceholder(part) {
+  var _a;
+  const contentPart = part;
+  switch (contentPart.type) {
+    case "text":
+      return (_a = contentPart.text) != null ? _a : "";
+    case "image-data":
+      return `[Image: ${contentPart.mediaType}]`;
+    case "image-url":
+      return `[Image URL: ${contentPart.url}]`;
+    case "image-file-id": {
+      const fileId = contentPart.fileId;
+      const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+      return `[Image ID: ${displayId}]`;
+    }
+    case "file-data": {
+      const filePart = contentPart;
+      if (filePart.filename) {
+        return `[File: ${filePart.filename} (${filePart.mediaType})]`;
+      }
+      return `[File: ${filePart.mediaType}]`;
+    }
+    case "file-url":
+      return `[File URL: ${contentPart.url}]`;
+    case "file-id": {
+      const fileId = contentPart.fileId;
+      const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+      return `[File ID: ${displayId}]`;
+    }
+    case "media":
+      return `[Media: ${contentPart.mediaType}]`;
+    case "custom":
+      return "[Custom content]";
+    default:
+      return "[Unknown content]";
+  }
 }
-
-// src/core/prompts/tool-response.ts
-function unwrapToolResult(result) {
+function unwrapToolResult(result, mediaStrategy) {
   var _a, _b;
   switch (result.type) {
     case "text":
@@ -3679,43 +5618,11 @@ function unwrapToolResult(result) {
     case "error-json":
       return `[Error: ${JSON.stringify(result.value)}]`;
     case "content": {
-      return result.value.map((part) => {
-        var _a2;
-        const contentPart = part;
-        switch (contentPart.type) {
-          case "text":
-            return (_a2 = contentPart.text) != null ? _a2 : "";
-          case "image-data":
-            return `[Image: ${contentPart.mediaType}]`;
-          case "image-url":
-            return `[Image URL: ${contentPart.url}]`;
-          case "image-file-id": {
-            const fileId = contentPart.fileId;
-            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
-            return `[Image ID: ${displayId}]`;
-          }
-          case "file-data": {
-            const filePart = contentPart;
-            if (filePart.filename) {
-              return `[File: ${filePart.filename} (${filePart.mediaType})]`;
-            }
-            return `[File: ${filePart.mediaType}]`;
-          }
-          case "file-url":
-            return `[File URL: ${contentPart.url}]`;
-          case "file-id": {
-            const fileId = contentPart.fileId;
-            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
-            return `[File ID: ${displayId}]`;
-          }
-          case "media":
-            return `[Media: ${contentPart.mediaType}]`;
-          case "custom":
-            return "[Custom content]";
-          default:
-            return "[Unknown content]";
-        }
-      }).join("\n");
+      const parts = result.value;
+      if (shouldPassRawContent(parts, mediaStrategy)) {
+        return parts;
+      }
+      return parts.map(formatContentPartPlaceholder).join("\n");
     }
     default: {
       const _exhaustive = result;
@@ -3723,58 +5630,89 @@ function unwrapToolResult(result) {
     }
   }
 }
-function formatToolResponseAsJsonInXml(toolResult) {
-  const unwrappedResult = unwrapToolResult(toolResult.output);
+
+// src/core/prompts/hermes-prompt.ts
+function formatToolResponseAsHermesWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
   return `<tool_response>${JSON.stringify({
-    toolName: toolResult.toolName,
-    result: unwrappedResult
+    name: toolResult.toolName,
+    content: unwrappedResult
   })}</tool_response>`;
 }
-function formatToolResponseAsXml(toolResult) {
-  const unwrappedResult = unwrapToolResult(toolResult.output);
-  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
-  const resultLines = formatXmlNode("result", unwrappedResult, 1);
-  return [
-    "<tool_response>",
-    `  ${toolNameXml}`,
-    ...resultLines,
-    "</tool_response>"
-  ].join("\n");
+function formatToolResponseAsHermes(toolResult) {
+  return formatToolResponseAsHermesWithOptions(toolResult);
 }
-function formatXmlNode(tagName, value, depth) {
-  const indent = "  ".repeat(depth);
-  if (value === null || value === void 0) {
-    return [`${indent}<${tagName}></${tagName}>`];
+function jsonSchemaToPythonType(schema) {
+  const type = schema.type;
+  if (type === "string") {
+    return "str";
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  if (type === "number") {
+    return "float";
   }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return [`${indent}<${tagName}></${tagName}>`];
+  if (type === "integer") {
+    return "int";
+  }
+  if (type === "boolean") {
+    return "bool";
+  }
+  if (type === "array") {
+    const items = schema.items;
+    if (items) {
+      return `list[${jsonSchemaToPythonType(items)}]`;
     }
-    const lines2 = [`${indent}<${tagName}>`];
-    for (const item of value) {
-      lines2.push(...formatXmlNode("item", item, depth + 1));
+    return "list[Any]";
+  }
+  if (type === "object") {
+    const additionalProperties = schema.additionalProperties;
+    if (additionalProperties) {
+      return `dict[str, ${jsonSchemaToPythonType(additionalProperties)}]`;
     }
-    lines2.push(`${indent}</${tagName}>`);
-    return lines2;
+    return "dict";
   }
-  const entries = Object.entries(value);
-  if (entries.length === 0) {
-    return [`${indent}<${tagName}></${tagName}>`];
+  if (Array.isArray(type)) {
+    return `Union[${type.map((t) => jsonSchemaToPythonType({ type: t })).join(",")}]`;
   }
-  const lines = [`${indent}<${tagName}>`];
-  for (const [key, entryValue] of entries) {
-    lines.push(...formatXmlNode(key, entryValue, depth + 1));
+  return "Any";
+}
+function renderToolDefinition(tool) {
+  var _a, _b;
+  const schema = tool.inputSchema;
+  const properties = schema.properties;
+  const paramSignature = properties ? Object.entries(properties).map(([name, field]) => `${name}: ${jsonSchemaToPythonType(field)}`).join(", ") : "";
+  const desc = (_a = tool.description) != null ? _a : "";
+  let description = `${tool.name}(${paramSignature}) - ${desc}
+
+`;
+  if (properties && Object.keys(properties).length > 0) {
+    description += "    Args:\n";
+    for (const [paramName, paramFields] of Object.entries(properties)) {
+      const paramDesc = (_b = paramFields.description) != null ? _b : "";
+      description += `        ${paramName}(${jsonSchemaToPythonType(paramFields)}): ${paramDesc.trim()}
+`;
+    }
   }
-  lines.push(`${indent}</${tagName}>`);
-  return lines;
+  const parametersJson = JSON.stringify(schema);
+  const descJson = JSON.stringify(description);
+  const nameJson = JSON.stringify(tool.name);
+  return `{"type": "function", "function": {"name": ${nameJson}, "description": ${descJson}, "parameters": ${parametersJson}}}`;
+}
+function hermesSystemPromptTemplate(tools) {
+  const toolsRendered = tools.map(renderToolDefinition).join("\n");
+  return `You are a function calling AI model. You are provided with function signatures within <tools></tools> XML tags. You may call one or more functions to assist with the user query. Don't make assumptions about what values to plug into functions. Here are the available tools: <tools> ${toolsRendered} </tools>
+Use the following pydantic model json schema for each tool call you will make: {"properties": {"name": {"title": "Name", "type": "string"}, "arguments": {"title": "Arguments", "type": "object"}}, "required": ["name", "arguments"], "title": "FunctionCall", "type": "object"}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
 }
 
-// src/core/prompts/xml-system-prompt.ts
+// src/core/prompts/morph-xml-prompt.ts
 import dedent from "dedent";
-function xmlSystemPromptTemplate(tools) {
+function morphXmlSystemPromptTemplate(tools) {
   const toolsText = renderToolsForXmlPrompt(tools);
   const header = dedent`
     # Tools
@@ -3998,9 +5936,241 @@ function stripSchemaKeys(value) {
   }
   return value;
 }
+function formatXmlNode(tagName, value, depth) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${indent}<${tagName}></${tagName}>`];
+    }
+    const lines2 = [`${indent}<${tagName}>`];
+    for (const item of value) {
+      lines2.push(...formatXmlNode("item", item, depth + 1));
+    }
+    lines2.push(`${indent}</${tagName}>`);
+    return lines2;
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  const lines = [`${indent}<${tagName}>`];
+  for (const [key, entryValue] of entries) {
+    lines.push(...formatXmlNode(key, entryValue, depth + 1));
+  }
+  lines.push(`${indent}</${tagName}>`);
+  return lines;
+}
+function morphFormatToolResponseAsXmlWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
+  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
+  const resultLines = formatXmlNode("result", unwrappedResult, 1);
+  return [
+    "<tool_response>",
+    `  ${toolNameXml}`,
+    ...resultLines,
+    "</tool_response>"
+  ].join("\n");
+}
+function morphFormatToolResponseAsXml(toolResult) {
+  return morphFormatToolResponseAsXmlWithOptions(toolResult);
+}
+
+// src/core/prompts/shared/assistant-tool-calls-to-text.ts
+function assistantToolCallsToTextContent(options) {
+  var _a, _b;
+  const newContent = [];
+  for (const item of options.content) {
+    switch (item.type) {
+      case "tool-call":
+        newContent.push({
+          type: "text",
+          text: options.protocol.formatToolCall(item)
+        });
+        break;
+      case "text":
+      case "reasoning":
+        newContent.push(item);
+        break;
+      default:
+        (_b = (_a = options.conversionOptions) == null ? void 0 : _a.onError) == null ? void 0 : _b.call(
+          _a,
+          "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+          { content: item }
+        );
+        newContent.push({
+          type: "text",
+          text: JSON.stringify(item)
+        });
+    }
+  }
+  if (!newContent.every((entry) => entry.type === "text")) {
+    return newContent;
+  }
+  return [
+    {
+      type: "text",
+      text: newContent.map((entry) => entry.text).join("\n")
+    }
+  ];
+}
+
+// src/core/prompts/qwen3coder-prompt.ts
+var QWEN3CODER_TOOL_HEADER = "# Tools\n\nYou have access to the following functions:\n\n";
+var QWEN3CODER_TOOL_CALL_INSTRUCTIONS = "\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>";
+var XML_PROMPT_TAG_NAME_RE = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+function isMapping2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSequence(value) {
+  return Array.isArray(value);
+}
+function toJinjaString(value) {
+  if (value === void 0) {
+    return "";
+  }
+  if (value === null) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  return String(value);
+}
+function toJinjaTrimmedString(value) {
+  return toJinjaString(value).trim();
+}
+function toEscapedXmlText(value) {
+  return escapeXmlMinimalText(toJinjaString(value));
+}
+function toEscapedTrimmedXmlText(value) {
+  return escapeXmlMinimalText(toJinjaTrimmedString(value));
+}
+function renderXmlPromptField(key, escapedValue) {
+  if (XML_PROMPT_TAG_NAME_RE.test(key)) {
+    return `
+<${key}>${escapedValue}</${key}>`;
+  }
+  return `
+<property name="${escapeXmlMinimalAttr(
+    key,
+    '"'
+  )}">${escapedValue}</property>`;
+}
+function renderExtraKeys(jsonDict, handledKeys) {
+  if (!isMapping2(jsonDict)) {
+    return "";
+  }
+  const handled = new Set(handledKeys);
+  let out = "";
+  for (const [jsonKey, jsonValue] of Object.entries(jsonDict)) {
+    if (handled.has(jsonKey)) {
+      continue;
+    }
+    const renderedValue = isMapping2(jsonValue) || isSequence(jsonValue) ? JSON.stringify(jsonValue) : toJinjaString(jsonValue);
+    out += renderXmlPromptField(jsonKey, escapeXmlMinimalText(renderedValue));
+  }
+  return out;
+}
+function normalizeInputSchema(inputSchema) {
+  if (typeof inputSchema !== "string") {
+    return inputSchema;
+  }
+  try {
+    return JSON.parse(inputSchema);
+  } catch (e) {
+    return inputSchema;
+  }
+}
+function normalizeTool(rawTool) {
+  return {
+    name: rawTool.name,
+    description: rawTool.description,
+    parameters: normalizeInputSchema(rawTool.inputSchema)
+  };
+}
+function renderParameter(paramName, paramFieldsRaw) {
+  const paramFields = isMapping2(paramFieldsRaw) ? paramFieldsRaw : void 0;
+  let out = "\n<parameter>";
+  out += `
+<name>${toEscapedXmlText(paramName)}</name>`;
+  if ((paramFields == null ? void 0 : paramFields.type) !== void 0) {
+    out += `
+<type>${toEscapedXmlText(paramFields.type)}</type>`;
+  }
+  if ((paramFields == null ? void 0 : paramFields.description) !== void 0) {
+    out += `
+<description>${toEscapedTrimmedXmlText(paramFields.description)}</description>`;
+  }
+  out += renderExtraKeys(paramFieldsRaw, ["name", "type", "description"]);
+  out += "\n</parameter>";
+  return out;
+}
+function renderTool(tool) {
+  let out = `
+<function>
+<name>${toEscapedXmlText(tool.name)}</name>`;
+  if (tool.description !== void 0) {
+    out += `
+<description>${toEscapedTrimmedXmlText(tool.description)}</description>`;
+  }
+  out += "\n<parameters>";
+  const parameters = tool.parameters;
+  if (isMapping2(parameters) && isMapping2(parameters.properties)) {
+    for (const [paramName, paramFieldsRaw] of Object.entries(
+      parameters.properties
+    )) {
+      out += renderParameter(paramName, paramFieldsRaw);
+    }
+  }
+  out += renderExtraKeys(parameters, ["type", "properties"]);
+  out += "\n</parameters>";
+  out += renderExtraKeys(tool, ["type", "name", "description", "parameters"]);
+  out += "\n</function>";
+  return out;
+}
+function qwen3coderSystemPromptTemplate(tools) {
+  if (!tools.length) {
+    return "";
+  }
+  let out = `${QWEN3CODER_TOOL_HEADER}<tools>`;
+  for (const tool of tools) {
+    out += renderTool(normalizeTool(tool));
+  }
+  out += "\n</tools>";
+  out += QWEN3CODER_TOOL_CALL_INSTRUCTIONS;
+  return out;
+}
+function stringifyToolResponseContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function formatToolResponseAsQwen3CoderXmlWithOptions(toolResult, options) {
+  const unwrappedResult = unwrapToolResult(
+    toolResult.output,
+    options == null ? void 0 : options.mediaStrategy
+  );
+  const content = stringifyToolResponseContent(unwrappedResult);
+  return `<tool_response>
+${content}
+</tool_response>`;
+}
+function formatToolResponseAsQwen3CoderXml(toolResult) {
+  return formatToolResponseAsQwen3CoderXmlWithOptions(toolResult);
+}
 
-// src/core/prompts/yaml-system-prompt.ts
-function yamlSystemPromptTemplate(tools, includeMultilineExample = true) {
+// src/core/prompts/yaml-xml-prompt.ts
+function yamlXmlSystemPromptTemplate(tools, includeMultilineExample = true) {
   const toolsJson = JSON.stringify(tools);
   const multilineExample = includeMultilineExample ? `
 
@@ -4039,6 +6209,9 @@ unit: celsius
 - Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
 - If a task requires multiple function calls, make ALL of them at once.`;
 }
+function formatToolResponseAsYaml(toolResult) {
+  return morphFormatToolResponseAsXml(toolResult);
+}
 
 // src/stream-handler.ts
 async function wrapStream({
@@ -4203,8 +6376,75 @@ function normalizeUsage(usage) {
   return ZERO_USAGE;
 }
 
+// src/core/prompts/shared/tool-role-to-user-message.ts
+function formatApprovalResponse(part) {
+  const status = part.approved ? "Approved" : "Denied";
+  const reason = part.reason ? `: ${part.reason}` : "";
+  return `[Tool Approval ${status}${reason}]`;
+}
+function toTextPart(text) {
+  return {
+    type: "text",
+    text
+  };
+}
+function normalizeTemplateResult(result) {
+  if (typeof result === "string") {
+    return [toTextPart(result)];
+  }
+  return result;
+}
+function appendSection(target, section) {
+  if (section.length === 0) {
+    return;
+  }
+  if (target.length > 0) {
+    target.push(toTextPart("\n"));
+  }
+  target.push(...section);
+}
+function mergeAdjacentTextParts(parts) {
+  const merged = [];
+  for (const part of parts) {
+    const last = merged.at(-1);
+    const canMergeTextParts = part.type === "text" && (last == null ? void 0 : last.type) === "text" && part.providerOptions === void 0 && last.providerOptions === void 0;
+    if (canMergeTextParts) {
+      last.text += part.text;
+      continue;
+    }
+    merged.push(part);
+  }
+  return merged;
+}
+function toolRoleContentToUserTextMessage(options) {
+  const toolResultParts = options.toolContent.filter(
+    (part) => part.type === "tool-result"
+  );
+  const approvalResponseParts = options.toolContent.filter(
+    (part) => part.type === "tool-approval-response"
+  );
+  const sections = [];
+  for (const toolResult of toolResultParts) {
+    const result = options.toolResponsePromptTemplate(toolResult);
+    appendSection(sections, normalizeTemplateResult(result));
+  }
+  for (const approvalResponse of approvalResponseParts) {
+    appendSection(sections, [
+      toTextPart(formatApprovalResponse(approvalResponse))
+    ]);
+  }
+  const normalizedSections = sections.length > 0 ? sections : [toTextPart("")];
+  return {
+    role: "user",
+    content: mergeAdjacentTextParts(normalizedSections)
+  };
+}
+
 // src/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
+  if (systemPrompt.trim().length === 0) {
+    return processedPrompt;
+  }
   const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
   if (systemIndex !== -1) {
     const existing = processedPrompt[systemIndex].content;
@@ -4400,94 +6640,30 @@ function transformParams({
   }
   return baseReturnParams;
 }
-function processAssistantContent(content, resolvedProtocol, providerOptions) {
-  var _a;
-  const newContent = [];
-  for (const item of content) {
-    switch (item.type) {
-      case "tool-call":
-        newContent.push({
-          type: "text",
-          text: resolvedProtocol.formatToolCall(item)
-        });
-        break;
-      case "text":
-      case "reasoning":
-        newContent.push(item);
-        break;
-      default: {
-        const options = extractOnErrorOption(providerOptions);
-        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
-          options,
-          "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
-          { content: item }
-        );
-        newContent.push({
-          type: "text",
-          text: JSON.stringify(item)
-        });
-      }
-    }
-  }
-  const onlyText = newContent.every((c) => c.type === "text");
-  return onlyText ? [
-    {
-      type: "text",
-      text: newContent.map((c) => c.text).join("\n")
-    }
-  ] : newContent;
-}
-function formatApprovalResponse(part) {
-  const status = part.approved ? "Approved" : "Denied";
-  const reason = part.reason ? `: ${part.reason}` : "";
-  return `[Tool Approval ${status}${reason}]`;
-}
-function processToolMessage(toolResults, approvalResponses, toolResponsePromptTemplate) {
-  const resultTexts = toolResults.map((toolResult) => {
-    return toolResponsePromptTemplate(toolResult);
-  });
-  const approvalTexts = approvalResponses.map(formatApprovalResponse);
-  const allTexts = [...resultTexts, ...approvalTexts];
-  return {
-    role: "user",
-    content: [
-      {
-        type: "text",
-        text: allTexts.join("\n")
-      }
-    ]
-  };
-}
 function processMessage(message, resolvedProtocol, providerOptions, toolResponsePromptTemplate) {
   if (message.role === "assistant") {
-    const condensedContent = processAssistantContent(
-      message.content,
-      resolvedProtocol,
-      providerOptions
-    );
+    const condensedContent = assistantToolCallsToTextContent({
+      content: message.content,
+      protocol: resolvedProtocol,
+      conversionOptions: {
+        onError: providerOptions == null ? void 0 : providerOptions.onError
+      }
+    });
     return {
       role: "assistant",
       content: condensedContent
     };
   }
   if (message.role === "tool") {
-    const toolContent = message.content;
-    const toolResultParts = toolContent.filter(
-      (part) => part.type === "tool-result"
-    );
-    const approvalResponseParts = toolContent.filter(
-      (part) => part.type === "tool-approval-response"
-    );
     if (!toolResponsePromptTemplate) {
       throw new Error(
         'toolResponsePromptTemplate is required when processing messages with role "tool". This parameter is optional for other roles but is required here so tool-result content can be converted into a prompt. Ensure your middleware or transform configuration passes a toolResponsePromptTemplate when tool message processing is enabled.'
       );
     }
-    return processToolMessage(
-      toolResultParts,
-      approvalResponseParts,
+    return toolRoleContentToUserTextMessage({
+      toolContent: message.content,
       toolResponsePromptTemplate
-    );
+    });
   }
   return message;
 }
@@ -4538,6 +6714,9 @@ function mergeConsecutiveUserMessages(processedPrompt) {
     const current = processedPrompt[i];
     const prev = processedPrompt[i - 1];
     if (current.role === "user" && prev.role === "user") {
+      if (!(isAllTextContent(prev.content) && isAllTextContent(current.content))) {
+        continue;
+      }
       const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
       const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
       processedPrompt[i - 1] = {
@@ -4597,19 +6776,24 @@ function createToolMiddleware({
 
 // src/preconfigured-middleware.ts
 var hermesToolMiddleware = createToolMiddleware({
-  protocol: jsonProtocol({}),
+  protocol: hermesProtocol(),
   toolSystemPromptTemplate: hermesSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsJsonInXml
+  toolResponsePromptTemplate: formatToolResponseAsHermes
+});
+var qwen3CoderToolMiddleware = createToolMiddleware({
+  protocol: qwen3CoderProtocol,
+  toolSystemPromptTemplate: qwen3coderSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsQwen3CoderXml
 });
-var xmlToolMiddleware = createToolMiddleware({
-  protocol: xmlProtocol({}),
-  toolSystemPromptTemplate: xmlSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsXml
+var morphXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol({}),
+  toolSystemPromptTemplate: morphXmlSystemPromptTemplate,
+  toolResponsePromptTemplate: morphFormatToolResponseAsXml
 });
-var yamlToolMiddleware = createToolMiddleware({
-  protocol: yamlProtocol({}),
-  toolSystemPromptTemplate: yamlSystemPromptTemplate,
-  toolResponsePromptTemplate: formatToolResponseAsXml
+var yamlXmlToolMiddleware = createToolMiddleware({
+  protocol: yamlXmlProtocol({}),
+  toolSystemPromptTemplate: yamlXmlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsYaml
 });
 
 export {
@@ -4619,11 +6803,14 @@ export {
   logParsedChunk,
   logParsedSummary,
   getPotentialStartIndex,
-  jsonProtocol,
+  hermesProtocol,
+  morphXmlProtocol,
   isProtocolFactory,
   isTCMProtocolFactory,
-  xmlProtocol,
-  yamlProtocol,
+  qwen3CoderProtocol,
+  uiTarsXmlProtocol,
+  Qwen3CoderToolParser,
+  yamlXmlProtocol,
   createDynamicIfThenElseSchema,
   extractOnErrorOption,
   originalToolsSchema,
@@ -4634,12 +6821,14 @@ export {
   isToolResultPart,
   hasInputProperty,
   wrapGenerate,
+  morphFormatToolResponseAsXml,
   wrapStream,
   toolChoiceStream,
   transformParams,
   createToolMiddleware,
   hermesToolMiddleware,
-  xmlToolMiddleware,
-  yamlToolMiddleware
+  qwen3CoderToolMiddleware,
+  morphXmlToolMiddleware,
+  yamlXmlToolMiddleware
 };
-//# sourceMappingURL=chunk-DPGORNPB.js.map
+//# sourceMappingURL=chunk-O6NWVXQD.js.map