@ai-sdk-tool/parser 3.0.0-canary.2 → 3.0.0

package/dist/{chunk-LB5ALTRD.js → v6.cjs}

@@ -1,7 +1,44 @@
-// src/protocols/json-mix-protocol.ts
-import { generateId } from "@ai-sdk/provider-utils";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/v6/index.ts
+var v6_exports = {};
+__export(v6_exports, {
+  createToolMiddleware: () => createToolMiddleware,
+  gemmaToolMiddleware: () => gemmaToolMiddleware,
+  hermesToolMiddleware: () => hermesToolMiddleware,
+  morphXmlToolMiddleware: () => morphXmlToolMiddleware,
+  orchestratorToolMiddleware: () => orchestratorToolMiddleware
+});
+module.exports = __toCommonJS(v6_exports);
 
-// src/utils/debug.ts
+// src/core/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
 function normalizeBooleanString(value) {
   const normalized = value.trim().toLowerCase();
@@ -156,7 +193,7 @@ ${rendered}`);
   }
 }
 
-// src/utils/get-potential-start-index.ts
+// src/core/utils/get-potential-start-index.ts
 function getPotentialStartIndex(text, searchedText) {
   if (searchedText.length === 0) {
     return null;
@@ -174,12 +211,17 @@ function getPotentialStartIndex(text, searchedText) {
   return null;
 }
 
-// src/utils/regex.ts
+// src/core/utils/id.ts
+function generateId() {
+  return Math.random().toString(36).substring(2, 15);
+}
+
+// src/core/utils/regex.ts
 function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/utils/robust-json.ts
+// src/core/utils/robust-json.ts
 var WHITESPACE_TEST_REGEX = /\s/;
 var WHITESPACE_REGEX = /^\s+/;
 var OBJECT_START_REGEX = /^\{/;
@@ -420,11 +462,6 @@ function stripTrailingComma(tokens) {
   });
   return res;
 }
-function transform(text) {
-  let tokens = lexer(text);
-  tokens = stripTrailingComma(tokens);
-  return tokens.reduce((str, token) => str + token.match, "");
-}
 function popToken(tokens, state) {
   var _a, _b;
   const token = tokens[state.pos];
@@ -820,33 +857,10 @@ function parse(text, optsOrReviver) {
   }
   return parseWithTransform(text, options);
 }
-function stringifyPair(obj, key) {
-  return `${JSON.stringify(key)}:${stringify(obj[key])}`;
-}
-function stringify(obj) {
-  const type = typeof obj;
-  if (type === "string" || type === "number" || type === "boolean" || obj === null) {
-    return JSON.stringify(obj);
-  }
-  if (type === "undefined") {
-    return "null";
-  }
-  if (Array.isArray(obj)) {
-    const elements = obj.map(stringify).join(",");
-    return `[${elements}]`;
-  }
-  if (type === "object") {
-    const keys = Object.keys(obj);
-    keys.sort();
-    const pairs = keys.map((key) => stringifyPair(obj, key)).join(",");
-    return `{${pairs}}`;
-  }
-  return "null";
-}
 
-// src/protocols/json-mix-protocol.ts
+// src/core/protocols/json-mix-protocol.ts
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
-  var _a;
+  var _a, _b;
   try {
     const parsedToolCall = parse(toolCallJson);
     processedElements.push({
@@ -862,12 +876,11 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
       snippet: fullMatch,
       error
     });
-    if (options == null ? void 0 : options.onError) {
-      options.onError(
-        "Could not process JSON tool call, keeping original text.",
-        { toolCall: fullMatch, error }
-      );
-    }
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+      options,
+      "Could not process JSON tool call, keeping original text.",
+      { toolCall: fullMatch, error }
+    );
     processedElements.push({ type: "text", text: fullMatch });
   }
 }
@@ -895,20 +908,27 @@ function flushBuffer(state, controller, toolCallStart) {
   }
   if (!state.currentTextId) {
     state.currentTextId = generateId();
-    controller.enqueue({ type: "text-start", id: state.currentTextId });
+    controller.enqueue({
+      type: "text-start",
+      id: state.currentTextId
+    });
     state.hasEmittedTextStart = true;
   }
-  const delta = state.isInsideToolCall ? `${toolCallStart}${state.buffer}` : state.buffer;
+  const deltaContent = state.isInsideToolCall ? `${toolCallStart}${state.buffer}` : state.buffer;
   controller.enqueue({
     type: "text-delta",
     id: state.currentTextId,
-    delta
+    textDelta: deltaContent,
+    delta: deltaContent
   });
   state.buffer = "";
 }
 function closeTextBlock(state, controller) {
   if (state.currentTextId && state.hasEmittedTextStart) {
-    controller.enqueue({ type: "text-end", id: state.currentTextId });
+    controller.enqueue({
+      type: "text-end",
+      id: state.currentTextId
+    });
     state.currentTextId = null;
     state.hasEmittedTextStart = false;
   }
@@ -923,13 +943,21 @@ function emitIncompleteToolCall(state, controller, toolCallStart) {
     snippet: `${toolCallStart}${state.currentToolCallJson}`
   });
   const errorId = generateId();
-  controller.enqueue({ type: "text-start", id: errorId });
+  const errorContent = `${toolCallStart}${state.currentToolCallJson}`;
+  controller.enqueue({
+    type: "text-start",
+    id: errorId
+  });
   controller.enqueue({
     type: "text-delta",
     id: errorId,
-    delta: `${toolCallStart}${state.currentToolCallJson}`
+    textDelta: errorContent,
+    delta: errorContent
+  });
+  controller.enqueue({
+    type: "text-end",
+    id: errorId
   });
-  controller.enqueue({ type: "text-end", id: errorId });
   state.currentToolCallJson = "";
 }
 function handleFinishChunk(state, controller, toolCallStart, chunk) {
@@ -947,18 +975,22 @@ function publishText(text, state, controller) {
   } else if (text.length > 0) {
     if (!state.currentTextId) {
       state.currentTextId = generateId();
-      controller.enqueue({ type: "text-start", id: state.currentTextId });
+      controller.enqueue({
+        type: "text-start",
+        id: state.currentTextId
+      });
       state.hasEmittedTextStart = true;
     }
     controller.enqueue({
       type: "text-delta",
       id: state.currentTextId,
+      textDelta: text,
       delta: text
     });
   }
 }
 function emitToolCall(context) {
-  var _a;
+  var _a, _b;
   const { state, controller, toolCallStart, toolCallEnd, options } = context;
   try {
     const parsedToolCall = parse(state.currentToolCallJson);
@@ -977,21 +1009,28 @@ function emitToolCall(context) {
       error
     });
     const errorId = generateId();
-    controller.enqueue({ type: "text-start", id: errorId });
+    const errorContent = `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`;
+    controller.enqueue({
+      type: "text-start",
+      id: errorId
+    });
     controller.enqueue({
       type: "text-delta",
       id: errorId,
-      delta: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`
+      textDelta: errorContent,
+      delta: errorContent
     });
-    controller.enqueue({ type: "text-end", id: errorId });
-    if (options == null ? void 0 : options.onError) {
-      options.onError(
-        "Could not process streaming JSON tool call; emitting original text.",
-        {
-          toolCall: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`
-        }
-      );
-    }
+    controller.enqueue({
+      type: "text-end",
+      id: errorId
+    });
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+      options,
+      "Could not process streaming JSON tool call; emitting original text.",
+      {
+        toolCall: errorContent
+      }
+    );
   }
 }
 function processTagMatch(context) {
@@ -1067,7 +1106,7 @@ var jsonMixProtocol = ({
   formatToolResponse(toolResult) {
     return `${toolResponseStart}${JSON.stringify({
       toolName: toolResult.toolName,
-      result: toolResult.output
+      result: toolResult.result
     })}${toolResponseEnd}`;
   },
   parseGeneratedText({ text, options }) {
@@ -1096,7 +1135,7 @@ var jsonMixProtocol = ({
     }
     return processedElements;
   },
-  createStreamParser({ tools: _tools, options } = { tools: [] }) {
+  createStreamParser({ options }) {
     const state = {
       isInsideToolCall: false,
       buffer: "",
@@ -1106,6 +1145,7 @@ var jsonMixProtocol = ({
     };
     return new TransformStream({
       transform(chunk, controller) {
+        var _a, _b;
         if (chunk.type === "finish") {
           handleFinishChunk(state, controller, toolCallStart, chunk);
           return;
@@ -1114,7 +1154,8 @@ var jsonMixProtocol = ({
           controller.enqueue(chunk);
           return;
         }
-        state.buffer += chunk.delta;
+        const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+        state.buffer += textContent;
         processBufferTags({
           state,
           controller,
@@ -1140,19 +1181,10 @@ var jsonMixProtocol = ({
   }
 });
 
-// src/protocols/morph-xml-protocol.ts
-import { generateId as generateId2 } from "@ai-sdk/provider-utils";
-import {
-  extractRawInner,
-  parse as parse3,
-  RXMLCoercionError,
-  RXMLDuplicateStringTagError,
-  RXMLParseError,
-  stringify as stringify2,
-  unwrapJsonSchema as unwrapJsonSchema2
-} from "@ai-sdk-tool/rxml";
+// src/core/protocols/morph-xml-protocol.ts
+var import_rxml2 = require("@ai-sdk-tool/rxml");
 
-// src/heuristics/engine.ts
+// src/core/heuristics/engine.ts
 function applyRawSegmentUpdate(current, result) {
   if (result.rawSegment !== void 0) {
     return { ...current, rawSegment: result.rawSegment };
@@ -1253,32 +1285,9 @@ function createIntermediateCall(toolName, rawSegment, schema) {
     meta: { originalContent: rawSegment }
   };
 }
-function mergePipelineConfigs(...configs) {
-  var _a, _b, _c;
-  const result = {
-    preParse: [],
-    fallbackReparse: [],
-    postParse: []
-  };
-  for (const config of configs) {
-    if (config.preParse) {
-      result.preParse = [...(_a = result.preParse) != null ? _a : [], ...config.preParse];
-    }
-    if (config.fallbackReparse) {
-      result.fallbackReparse = [
-        ...(_b = result.fallbackReparse) != null ? _b : [],
-        ...config.fallbackReparse
-      ];
-    }
-    if (config.postParse) {
-      result.postParse = [...(_c = result.postParse) != null ? _c : [], ...config.postParse];
-    }
-  }
-  return result;
-}
 
-// src/heuristics/xml-defaults.ts
-import { parse as parse2, unwrapJsonSchema } from "@ai-sdk-tool/rxml";
+// src/core/heuristics/xml-defaults.ts
+var import_rxml = require("@ai-sdk-tool/rxml");
 var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
 var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
@@ -1487,7 +1496,7 @@ function handleOpeningTagSegment(src, lt, out, stack) {
   return q + 1;
 }
 function shouldDeduplicateStringTags(schema) {
-  const unwrapped = unwrapJsonSchema(schema);
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
     return false;
   }
@@ -1499,11 +1508,11 @@ function shouldDeduplicateStringTags(schema) {
   if (!commandRaw) {
     return false;
   }
-  const command = unwrapJsonSchema(commandRaw);
+  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
   return (command == null ? void 0 : command.type) === "array";
 }
 function getStringPropertyNames(schema) {
-  const unwrapped = unwrapJsonSchema(schema);
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
     return [];
   }
@@ -1513,7 +1522,7 @@ function getStringPropertyNames(schema) {
   }
   const names = [];
   for (const key of Object.keys(props)) {
-    const prop = unwrapJsonSchema(
+    const prop = (0, import_rxml.unwrapJsonSchema)(
       props[key]
     );
     const type = prop.type;
@@ -1552,7 +1561,7 @@ function repairParsedAgainstSchema(input, schema) {
   if (!input || typeof input !== "object") {
     return input;
   }
-  const unwrapped = unwrapJsonSchema(schema);
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
     return input;
   }
@@ -1569,11 +1578,11 @@ function applySchemaProps(obj, properties) {
     if (!propSchema) {
       continue;
     }
-    const prop = unwrapJsonSchema(propSchema);
+    const prop = (0, import_rxml.unwrapJsonSchema)(propSchema);
     const propType = prop.type;
     if (propType === "array" && prop.items) {
       const itemSchemaRaw = prop.items;
-      const itemSchema = unwrapJsonSchema(itemSchemaRaw);
+      const itemSchema = (0, import_rxml.unwrapJsonSchema)(itemSchemaRaw);
       obj[key] = coerceArrayItems(obj[key], itemSchema);
       continue;
     }
@@ -1614,7 +1623,7 @@ function coerceArrayItem(v, itemSchema) {
 function tryParseStringToSchemaObject(xml, itemSchema) {
   try {
     const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
-    const fixed = parse2(normalized, itemSchema, { noChildNodes: [] });
+    const fixed = (0, import_rxml.parse)(normalized, itemSchema, { noChildNodes: [] });
     return typeof fixed === "string" ? null : fixed;
   } catch (e) {
     return null;
@@ -1629,40 +1638,21 @@ function extractStepStatusFromString(normXml) {
   return null;
 }
 
-// src/utils/type-guards.ts
-function isToolCallContent(content) {
-  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
-  (typeof content.input === "string" || typeof content.input === "object");
-}
-function isToolResultPart(content) {
-  const c = content;
-  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
-}
-function hasInputProperty(obj) {
-  return typeof obj === "object" && obj !== null && "input" in obj;
-}
-
-// src/protocols/morph-xml-protocol.ts
+// src/core/protocols/morph-xml-protocol.ts
 var defaultPipelineConfig2 = defaultPipelineConfig;
-var applyHeuristicPipeline2 = applyHeuristicPipeline;
-var createIntermediateCall2 = createIntermediateCall;
-var mergePipelineConfigs2 = mergePipelineConfigs;
-var WHITESPACE_REGEX3 = /\s/;
-var MALFORMED_CLOSE_RE2 = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
-var MALFORMED_CLOSE_RE_G2 = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
 var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX3 = /\s/;
+function getToolSchema(tools, toolName) {
+  var _a;
+  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
+}
 function normalizeCloseTags(xml) {
-  return xml.replace(MALFORMED_CLOSE_RE_G2, "</$1>");
+  return xml.replace(/<\/\s+([A-Za-z0-9_:-]+)\s*>/g, "</$1>");
 }
 function tryParseSecondaryXml(content, toolSchema, options) {
-  const normalized = normalizeCloseTags(content);
   const balanced = balanceTags(content);
-  const hasMalformedClose = MALFORMED_CLOSE_RE2.test(content);
-  if (!hasMalformedClose && balanced.length > normalized.length) {
-    return null;
-  }
   try {
-    let parsed = parse3(balanced, toolSchema, {
+    let parsed = (0, import_rxml2.parse)(balanced, toolSchema, {
       onError: options == null ? void 0 : options.onError,
       noChildNodes: []
     });
@@ -1670,10 +1660,14 @@ function tryParseSecondaryXml(content, toolSchema, options) {
     return parsed;
   } catch (e) {
     if (shouldDeduplicateStringTags(toolSchema)) {
-      const deduped = dedupeStringTagsAgainstSchema(balanced, toolSchema);
+      const names = getStringPropertyNames(toolSchema);
+      let deduped = balanced;
+      for (const key of names) {
+        deduped = dedupeSingleTag(deduped, key);
+      }
       if (deduped !== balanced) {
         try {
-          let reparsed = parse3(deduped, toolSchema, {
+          let reparsed = (0, import_rxml2.parse)(deduped, toolSchema, {
             onError: options == null ? void 0 : options.onError,
             noChildNodes: []
           });
@@ -1687,23 +1681,6 @@ function tryParseSecondaryXml(content, toolSchema, options) {
     return null;
   }
 }
-function dedupeStringTagsAgainstSchema(xml, schema) {
-  const names = getStringPropertyNames(schema);
-  let out = xml;
-  for (const key of names) {
-    out = dedupeSingleTag(out, key);
-  }
-  return out;
-}
-function processTextBeforeToolCall(text, currentIndex, toolCallStartIndex, processedElements) {
-  if (toolCallStartIndex > currentIndex) {
-    const textSegment = text.substring(currentIndex, toolCallStartIndex);
-    if (textSegment.trim()) {
-      processedElements.push({ type: "text", text: textSegment });
-    }
-  }
-  return currentIndex;
-}
 function processToolCallWithPipeline(params) {
   var _a;
   const {
@@ -1716,20 +1693,20 @@ function processToolCallWithPipeline(params) {
     maxReparses
   } = params;
   const toolSchema = getToolSchema(tools, toolCall.toolName);
-  const ctx = createIntermediateCall2(
+  const ctx = createIntermediateCall(
     toolCall.toolName,
     toolCall.content,
     toolSchema
   );
-  const result = applyHeuristicPipeline2(ctx, pipelineConfig, {
-    parse: (xml, schema) => parse3(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+  const result = applyHeuristicPipeline(ctx, pipelineConfig, {
+    parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
     onError: options == null ? void 0 : options.onError,
     maxReparses
   });
   if (result.parsed !== null) {
     processedElements.push({
       type: "tool-call",
-      toolCallId: generateId2(),
+      toolCallId: generateId(),
       toolName: toolCall.toolName,
       input: JSON.stringify(result.parsed)
     });
@@ -1738,69 +1715,15 @@ function processToolCallWithPipeline(params) {
       toolCall.startIndex,
       toolCall.endIndex
     );
-    const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-      toolCall: originalCallText,
-      toolName: toolCall.toolName,
-      error: result.errors[0]
-    });
-    processedElements.push({ type: "text", text: originalCallText });
-  }
-}
-function processToolCall(params) {
-  var _a;
-  const { toolCall, tools, options, text, processedElements } = params;
-  const toolSchema = getToolSchema(tools, toolCall.toolName);
-  try {
-    const primary = escapeInvalidLt(normalizeCloseTags(toolCall.content));
-    let parsed = parse3(primary, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      noChildNodes: []
-    });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema);
-    processedElements.push({
-      type: "tool-call",
-      toolCallId: generateId2(),
-      toolName: toolCall.toolName,
-      input: JSON.stringify(parsed)
-    });
-  } catch (error) {
-    const reparsed = tryParseSecondaryXml(
-      toolCall.content,
-      toolSchema,
-      options
-    );
-    if (reparsed !== null) {
-      processedElements.push({
-        type: "tool-call",
-        toolCallId: generateId2(),
-        toolName: toolCall.toolName,
-        input: JSON.stringify(reparsed)
-      });
-      return;
-    }
-    const originalCallText = text.substring(
-      toolCall.startIndex,
-      toolCall.endIndex
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+      options,
+      `Could not process XML tool call: ${toolCall.toolName}`,
+      { toolCall: originalCallText, error: result.errors[0] }
     );
-    const message = `Could not process XML tool call, keeping original text: ${originalCallText}`;
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-      toolCall: originalCallText,
-      toolName: toolCall.toolName,
-      error
-    });
     processedElements.push({ type: "text", text: originalCallText });
   }
 }
-function addRemainingText(text, currentIndex, processedElements) {
-  if (currentIndex < text.length) {
-    const remainingText = text.substring(currentIndex);
-    if (remainingText.trim()) {
-      processedElements.push({ type: "text", text: remainingText });
-    }
-  }
-}
-function handleStreamingToolCallEndWithPipeline(params) {
+function handleStreamingToolCallEnd(params) {
   var _a;
   const {
     toolContent,
@@ -1809,557 +1732,581 @@ function handleStreamingToolCallEndWithPipeline(params) {
     options,
     ctrl,
     flushText,
-    pipelineConfig = defaultPipelineConfig2,
+    pipelineConfig,
     maxReparses
   } = params;
   const toolSchema = getToolSchema(tools, currentToolCall.name);
-  const ctx = createIntermediateCall2(
-    currentToolCall.name,
-    toolContent,
-    toolSchema
-  );
-  const result = applyHeuristicPipeline2(ctx, pipelineConfig, {
-    parse: (xml, schema) => parse3(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
-    onError: options == null ? void 0 : options.onError,
-    maxReparses
-  });
+  let parsedResult = null;
+  if (pipelineConfig) {
+    const ctx = createIntermediateCall(
+      currentToolCall.name,
+      toolContent,
+      toolSchema
+    );
+    const result = applyHeuristicPipeline(ctx, pipelineConfig, {
+      parse: (xml, schema) => (0, import_rxml2.parse)(xml, schema, { onError: options == null ? void 0 : options.onError, noChildNodes: [] }),
+      onError: options == null ? void 0 : options.onError,
+      maxReparses
+    });
+    parsedResult = result.parsed;
+  } else {
+    try {
+      const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
+      const parsed = (0, import_rxml2.parse)(primary, toolSchema, {
+        onError: options == null ? void 0 : options.onError,
+        noChildNodes: []
+      });
+      parsedResult = repairParsedAgainstSchema(parsed, toolSchema);
+    } catch (e) {
+      parsedResult = tryParseSecondaryXml(
+        toolContent,
+        toolSchema,
+        options != null ? options : {}
+      );
+    }
+  }
   flushText(ctrl);
-  if (result.parsed !== null) {
+  if (parsedResult !== null) {
     ctrl.enqueue({
       type: "tool-call",
-      toolCallId: generateId2(),
+      toolCallId: generateId(),
       toolName: currentToolCall.name,
-      input: JSON.stringify(result.parsed)
+      input: JSON.stringify(parsedResult)
     });
   } else {
-    const endTag = `</${currentToolCall.name}>`;
-    const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
-    const error = result.errors[0];
-    let message = "Could not process streaming XML tool call; emitting original text.";
-    if (error instanceof RXMLDuplicateStringTagError) {
-      message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-    } else if (error instanceof RXMLCoercionError) {
-      message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-    } else if (error instanceof RXMLParseError) {
-      message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-    }
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-      toolCall: originalCallText,
-      toolName: currentToolCall.name,
-      error
+    const original = `<${currentToolCall.name}>${toolContent}</${currentToolCall.name}>`;
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not process streaming XML tool call", {
+      toolCall: original
     });
-    flushText(ctrl, originalCallText);
+    flushText(ctrl, original);
   }
 }
-function handleStreamingToolCallEnd(params) {
-  const { toolContent, currentToolCall, tools, options, ctrl, flushText } = params;
-  const toolSchema = getToolSchema(tools, currentToolCall.name);
-  try {
-    const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
-    let parsed = parse3(primary, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      noChildNodes: []
-    });
-    parsed = repairParsedAgainstSchema(parsed, toolSchema);
-    flushText(ctrl);
-    ctrl.enqueue({
-      type: "tool-call",
-      toolCallId: generateId2(),
-      toolName: currentToolCall.name,
-      input: JSON.stringify(parsed)
-    });
-  } catch (error) {
-    const parsed = tryParseSecondaryXml(toolContent, toolSchema, options);
-    if (parsed !== null) {
-      flushText(ctrl);
-      ctrl.enqueue({
-        type: "tool-call",
-        toolCallId: generateId2(),
-        toolName: currentToolCall.name,
-        input: JSON.stringify(parsed)
-      });
-      return;
+function findClosingTagEndFlexible(text, contentStart, toolName) {
+  let pos = contentStart;
+  let depth = 1;
+  while (pos < text.length) {
+    const tok = nextTagToken(text, pos);
+    if (tok.kind === "eof") {
+      break;
     }
-    handleStreamingToolCallError({
-      error,
-      currentToolCall,
-      toolContent,
-      options,
-      ctrl,
-      flushText
-    });
+    const result = updateDepthWithToken(tok, toolName, depth);
+    depth = result.depth;
+    if (result.closedAt !== void 0) {
+      return result.closedAt;
+    }
+    pos = tok.nextPos;
   }
+  return -1;
 }
-function handleStreamingToolCallError(params) {
-  var _a;
-  const { error, currentToolCall, toolContent, options, ctrl, flushText } = params;
-  const endTag = `</${currentToolCall.name}>`;
-  const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
-  let message = "Could not process streaming XML tool call; emitting original text.";
-  if (error instanceof RXMLDuplicateStringTagError) {
-    message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof RXMLCoercionError) {
-    message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof RXMLParseError) {
-    message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  }
-  (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-    toolCall: originalCallText,
-    toolName: currentToolCall.name,
-    error
-  });
-  flushText(ctrl, originalCallText);
-}
-function findEarliestToolTag(buffer, toolNames) {
-  let bestIndex = -1;
-  let bestName = "";
-  let bestSelfClosing = false;
-  if (toolNames.length > 0) {
-    for (const name of toolNames) {
-      const openTag = `<${name}>`;
-      const selfTag = `<${name}/>`;
-      const idxOpen = buffer.indexOf(openTag);
-      const idxSelf = buffer.indexOf(selfTag);
-      if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
-        bestIndex = idxOpen;
-        bestName = name;
-        bestSelfClosing = false;
-      }
-      if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
-        bestIndex = idxSelf;
-        bestName = name;
-        bestSelfClosing = true;
-      }
+function skipSpecialSegment(text, lt) {
+  const next = text[lt + 1];
+  if (next === "!" || next === "?") {
+    const gt = text.indexOf(">", lt + 1);
+    if (gt !== -1) {
+      return gt + 1;
     }
   }
-  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+  return null;
+}
+function consumeClosingTag(text, lt) {
+  const gt = text.indexOf(">", lt + 1);
+  const endPos = gt === -1 ? text.length : gt + 1;
+  return { matched: false, endPos };
 }
-function handleNoToolTagInBuffer(buffer, maxStartTagLen, controller, flushText) {
-  const tail = Math.max(0, maxStartTagLen - 1);
-  const safeLen = Math.max(0, buffer.length - tail);
-  if (safeLen > 0) {
-    const textToFlush = buffer.slice(0, safeLen);
-    flushText(controller, textToFlush);
-    return { buffer: buffer.slice(safeLen), shouldContinue: true };
+function consumeOpenTag(text, lt) {
+  let p = lt + 1;
+  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
+    p += 1;
+  }
+  const nameStart = p;
+  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+    p += 1;
+  }
+  const name = text.slice(nameStart, p);
+  const q = text.indexOf(">", p);
+  if (q === -1) {
+    return null;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
+    r -= 1;
   }
-  return { buffer, shouldContinue: false };
+  const selfClosing = text[r] === "/";
+  return { name, selfClosing, nextPos: q + 1 };
 }
-function processToolCallInBuffer(params) {
-  const {
-    buffer,
-    currentToolCall,
-    tools,
-    options,
-    controller,
-    flushText,
-    setBuffer,
-    pipelineConfig,
-    maxReparses
-  } = params;
-  const endTag = `</${currentToolCall.name}>`;
-  const normalized = normalizeCloseTags(buffer);
-  const effectiveBuffer = normalized;
-  const endTagIndex = effectiveBuffer.indexOf(endTag);
-  if (endTagIndex !== -1) {
-    const toolContent = effectiveBuffer.substring(0, endTagIndex);
-    const newBuffer = effectiveBuffer.substring(endTagIndex + endTag.length);
-    setBuffer("");
-    if (pipelineConfig) {
-      handleStreamingToolCallEndWithPipeline({
-        toolContent,
-        currentToolCall,
-        tools,
-        options,
-        ctrl: controller,
-        flushText,
-        pipelineConfig,
-        maxReparses
-      });
-    } else {
-      handleStreamingToolCallEnd({
-        toolContent,
-        currentToolCall,
-        tools,
-        options,
-        ctrl: controller,
-        flushText
-      });
-    }
-    setBuffer(newBuffer);
-    return { buffer: newBuffer, currentToolCall: null, shouldBreak: false };
+function updateDepthWithToken(tok, toolName, depth) {
+  if (tok.kind === "close" && tok.name === toolName) {
+    const newDepth = depth - 1;
+    return newDepth === 0 ? { depth: newDepth, closedAt: tok.nextPos } : { depth: newDepth };
   }
-  return { buffer: effectiveBuffer, currentToolCall, shouldBreak: true };
+  if (tok.kind === "open" && tok.name === toolName && !tok.selfClosing) {
+    return { depth: depth + 1 };
+  }
+  return { depth };
 }
-function processNoToolCallInBuffer(params) {
-  const {
-    buffer,
-    toolNames,
-    maxStartTagLen,
-    controller,
-    flushText,
-    tools,
-    options,
-    pipelineConfig,
-    maxReparses
-  } = params;
-  const {
-    index: earliestStartTagIndex,
-    name: earliestToolName,
-    selfClosing
-  } = findEarliestToolTag(buffer, toolNames);
-  if (earliestStartTagIndex !== -1) {
-    const textBeforeTag = buffer.substring(0, earliestStartTagIndex);
-    flushText(controller, textBeforeTag);
-    if (selfClosing) {
-      const selfTag = `<${earliestToolName}/>`;
-      const newBuffer2 = buffer.substring(
-        earliestStartTagIndex + selfTag.length
-      );
-      if (pipelineConfig) {
-        handleStreamingToolCallEndWithPipeline({
-          toolContent: "",
-          currentToolCall: { name: earliestToolName, content: "" },
-          tools,
-          options,
-          ctrl: controller,
-          flushText,
-          pipelineConfig,
-          maxReparses
-        });
-      } else {
-        handleStreamingToolCallEnd({
-          toolContent: "",
-          currentToolCall: { name: earliestToolName, content: "" },
-          tools,
-          options,
-          ctrl: controller,
-          flushText
-        });
-      }
-      return {
-        buffer: newBuffer2,
-        currentToolCall: null,
-        shouldBreak: false,
-        shouldContinue: false
-      };
+function nextTagToken(text, fromPos) {
+  const lt = text.indexOf("<", fromPos);
+  if (lt === -1 || lt + 1 >= text.length) {
+    return { kind: "eof", nextPos: text.length };
+  }
+  const next = text[lt + 1];
+  const specialEnd = skipSpecialSegment(text, lt);
+  if (specialEnd !== null) {
+    return { kind: "special", nextPos: specialEnd };
+  }
+  if (next === "/") {
+    const closing = consumeClosingTag(text, lt);
+    let p = lt + 2;
+    while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
+      p += 1;
     }
-    const startTag = `<${earliestToolName}>`;
-    const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
-    return {
-      buffer: newBuffer,
-      currentToolCall: { name: earliestToolName, content: "" },
-      shouldBreak: false,
-      shouldContinue: false
-    };
+    const nameStart = p;
+    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+      p += 1;
+    }
+    const name = text.slice(nameStart, p);
+    return { kind: "close", name, nextPos: closing.endPos };
+  }
+  const open = consumeOpenTag(text, lt);
+  if (open === null) {
+    return { kind: "eof", nextPos: text.length };
   }
-  const result = handleNoToolTagInBuffer(
-    buffer,
-    maxStartTagLen,
-    controller,
-    flushText
-  );
   return {
-    buffer: result.buffer,
-    currentToolCall: null,
-    shouldBreak: !result.shouldContinue,
-    shouldContinue: result.shouldContinue
+    kind: "open",
+    name: open.name,
+    selfClosing: open.selfClosing,
+    nextPos: open.nextPos
   };
 }
-function createFlushTextHandler(getBuffer, setBuffer, getCurrentTextId, setCurrentTextId) {
+function findToolCallsForName(text, toolName) {
+  var _a;
+  const toolCalls = [];
+  let searchIndex = 0;
+  while (searchIndex < text.length) {
+    const startTag = `<${toolName}>`;
+    const selfTag = `<${toolName}/>`;
+    const openIdx = text.indexOf(startTag, searchIndex);
+    const selfIdx = text.indexOf(selfTag, searchIndex);
+    if (openIdx === -1 && selfIdx === -1) {
+      break;
+    }
+    const tagStart = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx) ? selfIdx : openIdx;
+    const isSelfClosing = tagStart === selfIdx;
+    if (isSelfClosing) {
+      const endIndex = tagStart + selfTag.length;
+      const segment = text.substring(tagStart, endIndex);
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex,
+        content: "",
+        segment
+      });
+      searchIndex = endIndex;
+      continue;
+    }
+    const contentStart = tagStart + startTag.length;
+    const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
+    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
+      const segment = text.substring(tagStart, fullTagEnd);
+      const inner = (_a = (0, import_rxml2.extractRawInner)(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex: fullTagEnd,
+        content: inner,
+        segment
+      });
+      searchIndex = fullTagEnd;
+    } else {
+      searchIndex = contentStart;
+    }
+  }
+  return toolCalls;
+}
+function findToolCalls(text, toolNames) {
+  const toolCalls = [];
+  for (const toolName of toolNames) {
+    const calls = findToolCallsForName(text, toolName);
+    toolCalls.push(...calls);
+  }
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+}
+function findEarliestToolTag(buffer, toolNames) {
+  let bestIndex = -1;
+  let bestName = "";
+  let bestSelfClosing = false;
+  if (toolNames.length > 0) {
+    for (const name of toolNames) {
+      const openTag = `<${name}>`;
+      const selfTag = `<${name}/>`;
+      const idxOpen = buffer.indexOf(openTag);
+      const idxSelf = buffer.indexOf(selfTag);
+      if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
+        bestIndex = idxOpen;
+        bestName = name;
+        bestSelfClosing = false;
+      }
+      if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
+        bestIndex = idxSelf;
+        bestName = name;
+        bestSelfClosing = true;
+      }
+    }
+  }
+  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+}
+function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
   return (controller, text) => {
-    const content = text != null ? text : getBuffer();
+    const content = text;
     if (content) {
-      const currentTextId2 = getCurrentTextId();
-      if (!currentTextId2) {
-        const newId = generateId2();
+      if (!getCurrentTextId()) {
+        const newId = generateId();
         setCurrentTextId(newId);
-        controller.enqueue({ type: "text-start", id: newId });
+        controller.enqueue({
+          type: "text-start",
+          id: newId
+        });
+        setHasEmittedTextStart(true);
       }
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
+        textDelta: content,
         delta: content
       });
-      if (text === void 0) {
-        setBuffer("");
-      }
     }
     const currentTextId = getCurrentTextId();
     if (currentTextId && !text) {
-      controller.enqueue({ type: "text-end", id: currentTextId });
+      if (getHasEmittedTextStart()) {
+        controller.enqueue({
+          type: "text-end",
+          id: currentTextId
+        });
+        setHasEmittedTextStart(false);
+      }
       setCurrentTextId(null);
     }
   };
 }
-function processBufferWithToolCall(params, controller) {
+function processToolCallInBuffer(params) {
   const {
-    getBuffer,
-    setBuffer,
-    getCurrentToolCall,
-    setCurrentToolCall,
+    buffer,
+    currentToolCall,
     tools,
     options,
+    controller,
     flushText,
+    setBuffer,
     pipelineConfig,
     maxReparses
   } = params;
-  const currentToolCall = getCurrentToolCall();
-  if (!currentToolCall) {
-    return true;
-  }
-  const result = processToolCallInBuffer({
-    buffer: getBuffer(),
+  const endTag = `</${currentToolCall.name}>`;
+  const endIdx = buffer.indexOf(endTag);
+  if (endIdx === -1) {
+    return { buffer, currentToolCall, shouldBreak: true };
+  }
+  const content = buffer.substring(0, endIdx);
+  setBuffer(buffer.substring(endIdx + endTag.length));
+  handleStreamingToolCallEnd({
+    toolContent: content,
     currentToolCall,
     tools,
     options,
-    controller,
+    ctrl: controller,
     flushText,
-    setBuffer,
     pipelineConfig,
     maxReparses
   });
-  setBuffer(result.buffer);
-  setCurrentToolCall(result.currentToolCall);
-  return result.shouldBreak;
+  return {
+    buffer: buffer.substring(endIdx + endTag.length),
+    currentToolCall: null,
+    shouldBreak: false
+  };
 }
-function processBufferWithoutToolCall(params, controller) {
+function processNoToolCallInBuffer(params) {
   const {
-    getBuffer,
-    setBuffer,
-    setCurrentToolCall,
-    tools,
-    options,
-    toolNames,
-    maxStartTagLen,
-    flushText,
-    pipelineConfig,
-    maxReparses
-  } = params;
-  const result = processNoToolCallInBuffer({
-    buffer: getBuffer(),
+    buffer,
     toolNames,
-    maxStartTagLen,
     controller,
     flushText,
     tools,
     options,
     pipelineConfig,
-    maxReparses
-  });
-  setBuffer(result.buffer);
-  setCurrentToolCall(result.currentToolCall);
+    maxReparses,
+    setBuffer
+  } = params;
+  const {
+    index: earliestStartTagIndex,
+    name: earliestToolName,
+    selfClosing
+  } = findEarliestToolTag(buffer, toolNames);
+  if (earliestStartTagIndex === -1) {
+    const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
+    const tail = Math.max(0, maxTagLen - 1);
+    const safeLen = Math.max(0, buffer.length - tail);
+    if (safeLen > 0) {
+      flushText(controller, buffer.slice(0, safeLen));
+      setBuffer(buffer.slice(safeLen));
+    }
+    return {
+      buffer: buffer.slice(safeLen),
+      currentToolCall: null,
+      shouldBreak: true,
+      shouldContinue: false
+    };
+  }
+  flushText(controller, buffer.substring(0, earliestStartTagIndex));
+  if (selfClosing) {
+    const selfTag = `<${earliestToolName}/>`;
+    const newBuffer2 = buffer.substring(earliestStartTagIndex + selfTag.length);
+    setBuffer(newBuffer2);
+    handleStreamingToolCallEnd({
+      toolContent: "",
+      currentToolCall: { name: earliestToolName, content: "" },
+      tools,
+      options,
+      ctrl: controller,
+      flushText,
+      pipelineConfig,
+      maxReparses
+    });
+    return {
+      buffer: newBuffer2,
+      currentToolCall: null,
+      shouldBreak: false,
+      shouldContinue: false
+    };
+  }
+  const startTag = `<${earliestToolName}>`;
+  const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
+  setBuffer(newBuffer);
   return {
-    shouldBreak: result.shouldBreak,
-    shouldContinue: result.shouldContinue
+    buffer: newBuffer,
+    currentToolCall: { name: earliestToolName, content: "" },
+    shouldBreak: false,
+    shouldContinue: true
   };
 }
-function processBufferLoop(params, controller) {
-  while (true) {
-    const currentToolCall = params.getCurrentToolCall();
-    if (currentToolCall) {
-      const shouldBreak = processBufferWithToolCall(params, controller);
-      if (shouldBreak) {
-        break;
-      }
-    } else {
-      const { shouldBreak, shouldContinue } = processBufferWithoutToolCall(
-        params,
-        controller
-      );
-      if (shouldContinue) {
-        continue;
-      }
-      if (shouldBreak) {
+function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, pipelineConfig, maxReparses) {
+  return (controller) => {
+    while (true) {
+      const currentToolCall = getCurrentToolCall();
+      if (currentToolCall) {
+        const result = processToolCallInBuffer({
+          buffer: getBuffer(),
+          currentToolCall,
+          tools,
+          options,
+          controller,
+          flushText,
+          setBuffer,
+          pipelineConfig,
+          maxReparses
+        });
+        setBuffer(result.buffer);
+        setCurrentToolCall(result.currentToolCall);
+        if (result.shouldBreak) {
+          break;
+        }
+      } else {
+        const result = processNoToolCallInBuffer({
+          buffer: getBuffer(),
+          toolNames,
+          controller,
+          flushText,
+          tools,
+          options,
+          pipelineConfig,
+          maxReparses,
+          setBuffer
+        });
+        setBuffer(result.buffer);
+        setCurrentToolCall(result.currentToolCall);
+        if (result.shouldBreak) {
+          break;
+        }
+        if (result.shouldContinue) {
+          continue;
+        }
         break;
       }
     }
-  }
-}
-function createProcessBufferHandler(params) {
-  return (controller) => {
-    processBufferLoop(params, controller);
   };
 }
-function buildPipelineOptions(protocolOptions) {
-  var _a, _b, _c;
+var morphXmlProtocol = (protocolOptions) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  let pipelineConfig = protocolOptions == null ? void 0 : protocolOptions.pipeline;
   const maxReparses = protocolOptions == null ? void 0 : protocolOptions.maxReparses;
-  if (protocolOptions == null ? void 0 : protocolOptions.pipeline) {
-    return {
-      pipelineConfig: mergePipelineConfigs2(
-        defaultPipelineConfig2,
-        protocolOptions.pipeline
-      ),
-      maxReparses
+  if ((protocolOptions == null ? void 0 : protocolOptions.heuristics) && protocolOptions.heuristics.length > 0) {
+    const heuristicsConfig = {
+      preParse: [],
+      fallbackReparse: [],
+      postParse: []
     };
-  }
-  if (protocolOptions == null ? void 0 : protocolOptions.heuristics) {
-    return {
-      pipelineConfig: {
-        ...defaultPipelineConfig2,
+    for (const h of protocolOptions.heuristics) {
+      if (h.phase === "pre-parse") {
+        (_a = heuristicsConfig.preParse) == null ? void 0 : _a.push(h);
+      } else if (h.phase === "fallback-reparse") {
+        (_b = heuristicsConfig.fallbackReparse) == null ? void 0 : _b.push(h);
+      } else if (h.phase === "post-parse") {
+        (_c = heuristicsConfig.postParse) == null ? void 0 : _c.push(h);
+      }
+    }
+    if (pipelineConfig) {
+      pipelineConfig = {
         preParse: [
-          ...(_a = defaultPipelineConfig2.preParse) != null ? _a : [],
-          ...protocolOptions.heuristics.filter((h) => h.phase === "pre-parse")
+          ...(_d = pipelineConfig.preParse) != null ? _d : [],
+          ...(_e = heuristicsConfig.preParse) != null ? _e : []
         ],
         fallbackReparse: [
-          ...(_b = defaultPipelineConfig2.fallbackReparse) != null ? _b : [],
-          ...protocolOptions.heuristics.filter(
-            (h) => h.phase === "fallback-reparse"
-          )
+          ...(_f = pipelineConfig.fallbackReparse) != null ? _f : [],
+          ...(_g = heuristicsConfig.fallbackReparse) != null ? _g : []
         ],
         postParse: [
-          ...(_c = defaultPipelineConfig2.postParse) != null ? _c : [],
-          ...protocolOptions.heuristics.filter((h) => h.phase === "post-parse")
+          ...(_h = pipelineConfig.postParse) != null ? _h : [],
+          ...(_i = heuristicsConfig.postParse) != null ? _i : []
         ]
-      },
-      maxReparses
-    };
+      };
+    } else {
+      pipelineConfig = heuristicsConfig;
+    }
   }
-  return { pipelineConfig: void 0, maxReparses };
-}
-var morphXmlProtocol = (protocolOptions) => {
-  const { pipelineConfig, maxReparses } = buildPipelineOptions(protocolOptions);
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
       const toolsForPrompt = (tools || []).map((tool) => ({
         name: tool.name,
         description: tool.description,
-        parameters: unwrapJsonSchema2(tool.inputSchema)
+        parameters: (0, import_rxml2.unwrapJsonSchema)(tool.inputSchema)
       }));
       return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
     },
     formatToolCall(toolCall) {
       let args = {};
-      const inputValue = hasInputProperty(toolCall) ? toolCall.input : void 0;
-      if (typeof inputValue === "string") {
-        try {
-          args = JSON.parse(inputValue);
-        } catch (e) {
-          args = inputValue;
-        }
-      } else {
-        args = inputValue;
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = toolCall.input;
       }
-      return stringify2(toolCall.toolName, args, {
+      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: false
       });
     },
     formatToolResponse(toolResult) {
-      return stringify2("tool_response", {
-        tool_name: toolResult.toolName,
-        result: toolResult.output
-      });
+      let result = toolResult.result;
+      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
+        result = result.value;
+      }
+      const xml = (0, import_rxml2.stringify)(
+        "tool_response",
+        {
+          tool_name: toolResult.toolName,
+          result
+        },
+        { declaration: false }
+      );
+      return xml;
     },
     parseGeneratedText({ text, tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
       if (toolNames.length === 0) {
         return [{ type: "text", text }];
       }
       const processedElements = [];
       let currentIndex = 0;
-      const toolCallsRaw = findToolCalls(text, toolNames);
-      const toolCallsNorm = collectToolCallsFromNormalizedText(text, toolNames);
-      const seen = /* @__PURE__ */ new Set();
-      const toolCalls = [...toolCallsRaw, ...toolCallsNorm].filter((tc) => {
-        const key = `${tc.toolName}:${tc.startIndex}:${tc.endIndex}`;
-        if (seen.has(key)) {
-          return false;
-        }
-        seen.add(key);
-        return true;
-      }).sort((a, b) => a.startIndex - b.startIndex);
-      for (const toolCall of toolCalls) {
-        currentIndex = processTextBeforeToolCall(
-          text,
-          currentIndex,
-          toolCall.startIndex,
-          processedElements
-        );
-        if (pipelineConfig) {
-          processToolCallWithPipeline({
-            toolCall,
-            tools,
-            options,
-            text,
-            processedElements,
-            pipelineConfig,
-            maxReparses
-          });
-        } else {
-          processToolCall({
-            toolCall,
-            tools,
-            options,
-            text,
-            processedElements
+      const toolCalls = findToolCalls(text, toolNames);
+      for (const tc of toolCalls) {
+        if (tc.startIndex > currentIndex) {
+          processedElements.push({
+            type: "text",
+            text: text.substring(currentIndex, tc.startIndex)
           });
         }
-        currentIndex = toolCall.endIndex;
+        processToolCallWithPipeline({
+          toolCall: tc,
+          tools,
+          options,
+          text,
+          processedElements,
+          pipelineConfig,
+          maxReparses
+        });
+        currentIndex = tc.endIndex;
+      }
+      if (currentIndex < text.length) {
+        processedElements.push({
+          type: "text",
+          text: text.substring(currentIndex)
+        });
       }
-      addRemainingText(text, currentIndex, processedElements);
       return processedElements;
     },
     createStreamParser({ tools, options }) {
-      const toolNames = tools.map((t) => t.name).filter((name) => name != null);
-      const maxStartTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n}>`.length)) : 0;
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
       let buffer = "";
       let currentToolCall = null;
       let currentTextId = null;
+      let hasEmittedTextStart = false;
       const flushText = createFlushTextHandler(
-        () => buffer,
-        (newBuffer) => {
-          buffer = newBuffer;
-        },
         () => currentTextId,
         (newId) => {
           currentTextId = newId;
+        },
+        () => hasEmittedTextStart,
+        (value) => {
+          hasEmittedTextStart = value;
         }
       );
-      const processChunk = (chunk, controller) => {
-        if (chunk.type !== "text-delta") {
-          if (buffer) {
-            flushText(controller);
-          }
-          controller.enqueue(chunk);
-          return;
-        }
-        buffer += chunk.delta;
-        processBuffer(controller);
-      };
-      const processBuffer = createProcessBufferHandler({
-        getBuffer: () => buffer,
-        setBuffer: (newBuffer) => {
+      const processBuffer = createProcessBufferHandler(
+        () => buffer,
+        (newBuffer) => {
           buffer = newBuffer;
         },
-        getCurrentToolCall: () => currentToolCall,
-        setCurrentToolCall: (newToolCall) => {
+        () => currentToolCall,
+        (newToolCall) => {
           currentToolCall = newToolCall;
         },
         tools,
         options,
         toolNames,
-        maxStartTagLen,
         flushText,
         pipelineConfig,
         maxReparses
-      });
-      const flushBuffer2 = (controller) => {
-        if (currentToolCall) {
-          const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
-          flushText(controller, unfinishedCall);
-        } else if (buffer) {
-          flushText(controller);
-        }
-        if (currentTextId) {
-          controller.enqueue({ type: "text-end", id: currentTextId });
-        }
-      };
+      );
       return new TransformStream({
         transform(chunk, controller) {
-          processChunk(chunk, controller);
+          var _a2, _b2;
+          if (chunk.type !== "text-delta") {
+            if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            controller.enqueue(chunk);
+            return;
+          }
+          const textContent = (_b2 = (_a2 = chunk.textDelta) != null ? _a2 : chunk.delta) != null ? _b2 : "";
+          buffer += textContent;
+          processBuffer(controller);
         },
         flush(controller) {
-          flushBuffer2(controller);
+          if (currentToolCall) {
+            const unfinishedContent = `<${currentToolCall.name}>${currentToolCall.content || ""}${buffer}`;
+            flushText(controller, unfinishedContent);
+            buffer = "";
+            currentToolCall = null;
+          } else if (buffer) {
+            flushText(controller, buffer);
+            buffer = "";
+          }
+          if (currentTextId && hasEmittedTextStart) {
+            controller.enqueue({
+              type: "text-end",
+              id: currentTextId
+            });
+            hasEmittedTextStart = false;
+            currentTextId = null;
+          }
         }
       });
     },
@@ -2372,237 +2319,516 @@ var morphXmlProtocol = (protocolOptions) => {
     }
   };
 };
-function getToolSchema(tools, toolName) {
-  var _a;
-  return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
-}
-function findClosingTagEndFlexible(text, contentStart, toolName) {
+
+// src/core/protocols/yaml-xml-protocol.ts
+var import_rxml3 = require("@ai-sdk-tool/rxml");
+var import_yaml = __toESM(require("yaml"), 1);
+var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX4 = /\s/;
+var LEADING_WHITESPACE_RE = /^(\s*)/;
+function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
   let depth = 1;
   while (pos < text.length) {
-    const tok = nextTagToken(text, pos);
-    if (tok.kind === "eof") {
+    const ltIdx = text.indexOf("<", pos);
+    if (ltIdx === -1) {
       break;
     }
-    const result = updateDepthWithToken(tok, toolName, depth);
-    depth = result.depth;
-    if (result.closedAt !== void 0) {
-      return result.closedAt;
+    const next = text[ltIdx + 1];
+    if (next === "/") {
+      const gtIdx = text.indexOf(">", ltIdx);
+      if (gtIdx === -1) {
+        break;
+      }
+      let p = ltIdx + 2;
+      while (p < gtIdx && WHITESPACE_REGEX4.test(text[p])) {
+        p++;
+      }
+      const nameStart = p;
+      while (p < gtIdx && NAME_CHAR_RE3.test(text.charAt(p))) {
+        p++;
+      }
+      const name = text.slice(nameStart, p);
+      if (name === toolName) {
+        depth--;
+        if (depth === 0) {
+          return gtIdx + 1;
+        }
+      }
+      pos = gtIdx + 1;
+    } else if (next === "!" || next === "?") {
+      const gtIdx = text.indexOf(">", ltIdx);
+      pos = gtIdx === -1 ? text.length : gtIdx + 1;
+    } else {
+      let p = ltIdx + 1;
+      while (p < text.length && WHITESPACE_REGEX4.test(text[p])) {
+        p++;
+      }
+      const nameStart = p;
+      while (p < text.length && NAME_CHAR_RE3.test(text.charAt(p))) {
+        p++;
+      }
+      const name = text.slice(nameStart, p);
+      const gtIdx = text.indexOf(">", p);
+      if (gtIdx === -1) {
+        break;
+      }
+      let r = gtIdx - 1;
+      while (r >= nameStart && WHITESPACE_REGEX4.test(text[r])) {
+        r--;
+      }
+      const selfClosing = text[r] === "/";
+      if (name === toolName && !selfClosing) {
+        depth++;
+      }
+      pos = gtIdx + 1;
     }
-    pos = tok.nextPos;
   }
   return -1;
 }
-function skipSpecialSegment(text, lt) {
-  const next = text[lt + 1];
-  if (next !== "!" && next !== "?") {
-    return null;
-  }
-  const gt = text.indexOf(">", lt + 1);
-  if (gt === -1) {
-    return null;
+function findEarliestTagPosition(openIdx, selfIdx) {
+  const hasSelf = selfIdx !== -1;
+  const hasOpen = openIdx !== -1;
+  if (hasSelf && (!hasOpen || selfIdx < openIdx)) {
+    return { tagStart: selfIdx, isSelfClosing: true };
   }
-  return gt + 1;
+  return { tagStart: openIdx, isSelfClosing: false };
 }
-function consumeClosingTag(text, lt, _toolName) {
-  let p = lt + 2;
-  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
-    p += 1;
+function collectToolCallsForName(text, toolName) {
+  const toolCalls = [];
+  let searchIndex = 0;
+  const selfTagRegex = new RegExp(`<${toolName}\\s*/>`, "g");
+  while (searchIndex < text.length) {
+    const startTag = `<${toolName}>`;
+    const openIdx = text.indexOf(startTag, searchIndex);
+    selfTagRegex.lastIndex = searchIndex;
+    const selfMatch = selfTagRegex.exec(text);
+    const selfIdx = selfMatch ? selfMatch.index : -1;
+    const selfTagLength = selfMatch ? selfMatch[0].length : 0;
+    if (openIdx === -1 && selfIdx === -1) {
+      break;
+    }
+    const { tagStart, isSelfClosing } = findEarliestTagPosition(
+      openIdx,
+      selfIdx
+    );
+    if (isSelfClosing) {
+      const endIndex = tagStart + selfTagLength;
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex,
+        content: ""
+      });
+      searchIndex = endIndex;
+      continue;
+    }
+    const contentStart = tagStart + startTag.length;
+    const fullTagEnd = findClosingTagEnd(text, contentStart, toolName);
+    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
+      const endTag = `</${toolName}>`;
+      const endTagStart = fullTagEnd - endTag.length;
+      const content = text.substring(contentStart, endTagStart);
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex: fullTagEnd,
+        content
+      });
+      searchIndex = fullTagEnd;
+    } else {
+      searchIndex = contentStart;
+    }
   }
-  const gt = text.indexOf(">", lt + 1);
-  const endPos = gt === -1 ? text.length : gt + 1;
-  return { matched: false, endPos };
+  return toolCalls;
 }
-function consumeOpenTag(text, lt) {
-  let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
-    p += 1;
+function findToolCalls2(text, toolNames) {
+  const toolCalls = toolNames.flatMap(
+    (toolName) => collectToolCallsForName(text, toolName)
+  );
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+}
+function parseYamlContent(yamlContent, options) {
+  var _a, _b, _c;
+  let normalized = yamlContent;
+  if (normalized.startsWith("\n")) {
+    normalized = normalized.slice(1);
   }
-  const nameStart = p;
-  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
-    p += 1;
+  const lines = normalized.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return {};
   }
-  const name = text.slice(nameStart, p);
-  const q = text.indexOf(">", p);
-  if (q === -1) {
-    return null;
+  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");
   }
-  let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
-    r -= 1;
+  try {
+    const doc = import_yaml.default.parseDocument(normalized);
+    if (doc.errors && doc.errors.length > 0) {
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "YAML parse error", {
+        errors: doc.errors.map((e) => e.message)
+      });
+      return null;
+    }
+    const result = doc.toJSON();
+    if (result === null) {
+      return {};
+    }
+    if (typeof result !== "object" || Array.isArray(result)) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "YAML content must be a key-value mapping", {
+        got: typeof result
+      });
+      return null;
+    }
+    return result;
+  } catch (error) {
+    (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, "Failed to parse YAML content", { error });
+    return null;
   }
-  const selfClosing = text[r] === "/";
-  return { name, selfClosing, nextPos: q + 1 };
 }
-function updateDepthWithToken(tok, toolName, depth) {
-  if (tok.kind === "close" && tok.name === toolName) {
-    const newDepth = depth - 1;
-    return newDepth === 0 ? { depth: newDepth, closedAt: tok.nextPos } : { depth: newDepth };
-  }
-  if (tok.kind === "open" && tok.name === toolName && !tok.selfClosing) {
-    return { depth: depth + 1 };
+function appendTextPart(processedElements, textPart) {
+  if (textPart.trim()) {
+    processedElements.push({
+      type: "text",
+      text: textPart
+    });
   }
-  return { depth };
 }
-function nextTagToken(text, fromPos) {
-  const lt = text.indexOf("<", fromPos);
-  if (lt === -1 || lt + 1 >= text.length) {
-    return { kind: "eof", nextPos: text.length };
+function processToolCallMatch(text, tc, currentIndex, processedElements, options) {
+  var _a;
+  if (tc.startIndex < currentIndex) {
+    return currentIndex;
   }
-  const next = text[lt + 1];
-  const specialEnd = skipSpecialSegment(text, lt);
-  if (specialEnd !== null) {
-    return { kind: "special", nextPos: specialEnd };
+  appendTextPart(
+    processedElements,
+    text.substring(currentIndex, tc.startIndex)
+  );
+  const parsedArgs = parseYamlContent(tc.content, options);
+  if (parsedArgs !== null) {
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: generateId(),
+      toolName: tc.toolName,
+      input: JSON.stringify(parsedArgs)
+    });
+  } else {
+    const originalText = text.substring(tc.startIndex, tc.endIndex);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse YAML tool call", {
+      toolCall: originalText
+    });
+    processedElements.push({ type: "text", text: originalText });
   }
-  if (next === "/") {
-    const closing = consumeClosingTag(text, lt, "");
-    let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
-      p += 1;
+  return tc.endIndex;
+}
+function createFlushTextHandler2(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
+  return (controller, text) => {
+    const content = text;
+    if (content) {
+      if (!getCurrentTextId()) {
+        const newId = generateId();
+        setCurrentTextId(newId);
+        controller.enqueue({
+          type: "text-start",
+          id: newId
+        });
+        setHasEmittedTextStart(true);
+      }
+      controller.enqueue({
+        type: "text-delta",
+        id: getCurrentTextId(),
+        textDelta: content,
+        delta: content
+      });
     }
-    const nameStart = p;
-    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
-      p += 1;
+    const currentTextId = getCurrentTextId();
+    if (currentTextId && !text) {
+      if (getHasEmittedTextStart()) {
+        controller.enqueue({
+          type: "text-end",
+          id: currentTextId
+        });
+        setHasEmittedTextStart(false);
+      }
+      setCurrentTextId(null);
+    }
+  };
+}
+function findEarliestToolTag2(buffer, toolNames) {
+  let bestIndex = -1;
+  let bestName = "";
+  let bestSelfClosing = false;
+  let bestTagLength = 0;
+  for (const name of toolNames) {
+    const openTag = `<${name}>`;
+    const selfTagRegex = new RegExp(`<${name}\\s*/>`);
+    const idxOpen = buffer.indexOf(openTag);
+    const selfMatch = selfTagRegex.exec(buffer);
+    const idxSelf = selfMatch ? selfMatch.index : -1;
+    if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
+      bestIndex = idxOpen;
+      bestName = name;
+      bestSelfClosing = false;
+      bestTagLength = openTag.length;
+    }
+    if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
+      bestIndex = idxSelf;
+      bestName = name;
+      bestSelfClosing = true;
+      bestTagLength = selfMatch ? selfMatch[0].length : 0;
     }
-    const name = text.slice(nameStart, p);
-    return { kind: "close", name, nextPos: closing.endPos };
-  }
-  const open = consumeOpenTag(text, lt);
-  if (open === null) {
-    return { kind: "eof", nextPos: text.length };
   }
   return {
-    kind: "open",
-    name: open.name,
-    selfClosing: open.selfClosing,
-    nextPos: open.nextPos
+    index: bestIndex,
+    name: bestName,
+    selfClosing: bestSelfClosing,
+    tagLength: bestTagLength
   };
 }
-function collectToolCallsFromNormalizedText(text, toolNames) {
-  var _a;
-  const normalizedText = normalizeCloseTags(text);
-  const collected = [];
-  for (const toolName of toolNames) {
-    const startTag = `<${toolName}>`;
-    let idx = 0;
-    let lastOrigIdx = 0;
-    while (idx < normalizedText.length) {
-      const tagStartNorm = normalizedText.indexOf(startTag, idx);
-      if (tagStartNorm === -1) {
-        break;
+var yamlXmlProtocol = (_protocolOptions) => {
+  return {
+    formatTools({ tools, toolSystemPromptTemplate }) {
+      const toolsForPrompt = (tools || []).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: (0, import_rxml3.unwrapJsonSchema)(tool.inputSchema)
+      }));
+      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+    },
+    formatToolCall(toolCall) {
+      let args = {};
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = { value: toolCall.input };
+      }
+      const yamlContent = import_yaml.default.stringify(args);
+      return `<${toolCall.toolName}>
+${yamlContent}</${toolCall.toolName}>`;
+    },
+    formatToolResponse(toolResult) {
+      let result = toolResult.result;
+      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
+        result = result.value;
       }
-      const contentStartNorm = tagStartNorm + startTag.length;
-      const endNorm = findClosingTagEndFlexible(
-        normalizedText,
-        contentStartNorm,
-        toolName
+      const xml = (0, import_rxml3.stringify)(
+        "tool_response",
+        {
+          tool_name: toolResult.toolName,
+          result
+        },
+        { declaration: false }
       );
-      if (endNorm > contentStartNorm) {
-        const tagStartOrig = text.indexOf(startTag, lastOrigIdx);
-        const contentStartOrig = tagStartOrig + startTag.length;
-        let endOrig = findClosingTagEndFlexible(
+      return xml;
+    },
+    parseGeneratedText({ text, tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [{ type: "text", text }];
+      }
+      const processedElements = [];
+      let currentIndex = 0;
+      const toolCalls = findToolCalls2(text, toolNames);
+      for (const tc of toolCalls) {
+        currentIndex = processToolCallMatch(
           text,
-          contentStartOrig,
-          toolName
+          tc,
+          currentIndex,
+          processedElements,
+          options
         );
-        if (endOrig === -1) {
-          const approxLen = endNorm - tagStartNorm;
-          endOrig = Math.min(text.length, tagStartOrig + approxLen);
-        }
-        const segment = text.substring(tagStartOrig, endOrig);
-        const inner = (_a = extractRawInner(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
-        collected.push({
-          toolName,
-          startIndex: tagStartOrig,
-          endIndex: endOrig,
-          content: inner,
-          segment
-        });
-        lastOrigIdx = endOrig;
-        idx = endNorm;
-      } else {
-        idx = contentStartNorm;
       }
-    }
-  }
-  return collected.sort((a, b) => a.startIndex - b.startIndex);
-}
-function getNextTagInfo(text, toolName, fromIndex) {
-  const startTag = `<${toolName}>`;
-  const selfTag = `<${toolName}/>`;
-  const openIdx = text.indexOf(startTag, fromIndex);
-  const selfIdx = text.indexOf(selfTag, fromIndex);
-  const hasOpen = openIdx !== -1;
-  const hasSelf = selfIdx !== -1;
-  if (!(hasOpen || hasSelf)) {
-    return {
-      found: false,
-      tagStart: -1,
-      selfClosing: false,
-      startTag,
-      selfTag
-    };
-  }
-  const pickSelf = hasSelf && (!hasOpen || selfIdx < openIdx);
-  const tagStart = pickSelf ? selfIdx : openIdx;
-  return { found: true, tagStart, selfClosing: pickSelf, startTag, selfTag };
-}
-function findToolCallsForName(text, toolName) {
-  var _a;
-  const toolCalls = [];
-  let searchIndex = 0;
-  while (searchIndex < text.length) {
-    const info = getNextTagInfo(text, toolName, searchIndex);
-    if (!info.found) {
-      break;
-    }
-    const { tagStart, selfClosing, startTag, selfTag } = info;
-    if (selfClosing) {
-      const endIndex = tagStart + selfTag.length;
-      const segment = text.substring(tagStart, endIndex);
-      toolCalls.push({
-        toolName,
-        startIndex: tagStart,
-        endIndex,
-        content: "",
-        segment
-      });
-      searchIndex = endIndex;
-      continue;
-    }
-    const contentStart = tagStart + startTag.length;
-    const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
-    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
-      const segment = text.substring(tagStart, fullTagEnd);
-      const inner = (_a = extractRawInner(segment, toolName)) != null ? _a : segment.substring(startTag.length, segment.lastIndexOf("<"));
-      toolCalls.push({
-        toolName,
-        startIndex: tagStart,
-        endIndex: fullTagEnd,
-        content: inner,
-        segment
+      if (currentIndex < text.length) {
+        appendTextPart(processedElements, text.substring(currentIndex));
+      }
+      return processedElements;
+    },
+    createStreamParser({ tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      let buffer = "";
+      let currentToolCall = null;
+      let currentTextId = null;
+      let hasEmittedTextStart = false;
+      const flushText = createFlushTextHandler2(
+        () => currentTextId,
+        (newId) => {
+          currentTextId = newId;
+        },
+        () => hasEmittedTextStart,
+        (value) => {
+          hasEmittedTextStart = value;
+        }
+      );
+      const processToolCallEnd = (controller, toolContent, toolName) => {
+        var _a;
+        const parsedArgs = parseYamlContent(toolContent, options);
+        flushText(controller);
+        if (parsedArgs !== null) {
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId: generateId(),
+            toolName,
+            input: JSON.stringify(parsedArgs)
+          });
+        } else {
+          const original = `<${toolName}>${toolContent}</${toolName}>`;
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
+            toolCall: original
+          });
+          flushText(controller, original);
+        }
+      };
+      const handlePendingToolCall = (controller, endTag, toolName) => {
+        const endIdx = buffer.indexOf(endTag);
+        if (endIdx === -1) {
+          return false;
+        }
+        const content = buffer.substring(0, endIdx);
+        buffer = buffer.substring(endIdx + endTag.length);
+        processToolCallEnd(controller, content, toolName);
+        currentToolCall = null;
+        return true;
+      };
+      const flushSafeText = (controller) => {
+        const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
+        const tail = Math.max(0, maxTagLen - 1);
+        const safeLen = Math.max(0, buffer.length - tail);
+        if (safeLen > 0) {
+          flushText(controller, buffer.slice(0, safeLen));
+          buffer = buffer.slice(safeLen);
+        }
+      };
+      const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
+        if (tagIndex > 0) {
+          flushText(controller, buffer.substring(0, tagIndex));
+        }
+        if (selfClosing) {
+          buffer = buffer.substring(tagIndex + tagLength);
+          processToolCallEnd(controller, "", tagName);
+        } else {
+          const startTag = `<${tagName}>`;
+          buffer = buffer.substring(tagIndex + startTag.length);
+          currentToolCall = { name: tagName, content: "" };
+        }
+      };
+      const processBuffer = (controller) => {
+        while (true) {
+          if (currentToolCall) {
+            const toolName = currentToolCall.name;
+            const endTag = `</${toolName}>`;
+            if (!handlePendingToolCall(controller, endTag, toolName)) {
+              break;
+            }
+          } else {
+            const { index, name, selfClosing, tagLength } = findEarliestToolTag2(
+              buffer,
+              toolNames
+            );
+            if (index === -1) {
+              flushSafeText(controller);
+              break;
+            }
+            handleNewToolTag(controller, index, name, selfClosing, tagLength);
+          }
+        }
+      };
+      return new TransformStream({
+        transform(chunk, controller) {
+          var _a, _b;
+          if (chunk.type !== "text-delta") {
+            if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            controller.enqueue(chunk);
+            return;
+          }
+          const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+          buffer += textContent;
+          processBuffer(controller);
+        },
+        flush(controller) {
+          if (currentToolCall) {
+            const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
+            flushText(controller, unfinishedContent);
+            buffer = "";
+            currentToolCall = null;
+          } else if (buffer) {
+            flushText(controller, buffer);
+            buffer = "";
+          }
+          if (currentTextId && hasEmittedTextStart) {
+            controller.enqueue({
+              type: "text-end",
+              id: currentTextId
+            });
+            hasEmittedTextStart = false;
+            currentTextId = null;
+          }
+        }
       });
-      searchIndex = fullTagEnd;
-    } else {
-      searchIndex = contentStart;
+    },
+    extractToolCallSegments({ text, tools }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [];
+      }
+      return findToolCalls2(text, toolNames).map(
+        (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
+      );
     }
-  }
-  return toolCalls;
-}
-function findToolCalls(text, toolNames) {
-  const toolCalls = [];
-  for (const toolName of toolNames) {
-    const calls = findToolCallsForName(text, toolName);
-    toolCalls.push(...calls);
-  }
-  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+  };
+};
+function orchestratorSystemPromptTemplate(tools, includeMultilineExample = true) {
+  const multilineExample = includeMultilineExample ? `
+
+For multiline values, use YAML's literal block syntax:
+<write_file>
+file_path: /tmp/example.txt
+contents: |
+  First line
+  Second line
+  Third line
+</write_file>` : "";
+  return `# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>${tools}</tools>
+
+# Format
+
+Use exactly one XML element whose tag name is the function name.
+Inside the XML element, specify parameters using YAML syntax (key: value pairs).
+
+# Example
+<get_weather>
+location: New York
+unit: celsius
+</get_weather>${multilineExample}
+
+# Rules
+- Parameter names and values must follow the schema exactly.
+- Use proper YAML syntax for values (strings, numbers, booleans, arrays, objects).
+- Each required parameter must appear once.
+- Do not add functions or parameters not in the schema.
+- After calling a tool, you will receive a response. Use this result to answer the user.
+- Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
+- If a task requires multiple function calls, make ALL of them at once.`;
 }
 
-// src/generate-handler.ts
-import { generateId as generateId3 } from "@ai-sdk/provider-utils";
-import { coerceBySchema } from "@ai-sdk-tool/rxml";
+// src/core/protocols/tool-call-protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
 
-// src/utils/on-error.ts
+// src/core/utils/on-error.ts
 function extractOnErrorOption(providerOptions) {
   var _a;
   if (providerOptions && typeof providerOptions === "object") {
@@ -2612,7 +2838,7 @@ function extractOnErrorOption(providerOptions) {
   return;
 }
 
-// src/utils/provider-options.ts
+// src/core/utils/provider-options.ts
 var originalToolsSchema = {
   encode: encodeOriginalTools,
   decode: decodeOriginalTools
@@ -2635,16 +2861,15 @@ function decodeOriginalTools(originalTools) {
     })
   );
 }
-function extractToolNamesFromOriginalTools(originalTools) {
-  return (originalTools == null ? void 0 : originalTools.map((t) => t.name)) || [];
-}
 function isToolChoiceActive(params) {
   var _a, _b, _c;
   const toolChoice = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.toolChoice;
   return !!(typeof params.providerOptions === "object" && params.providerOptions !== null && typeof ((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) === "object" && toolChoice && typeof toolChoice === "object" && (toolChoice.type === "tool" || toolChoice.type === "required"));
 }
 
-// src/generate-handler.ts
+// src/v6/generate-handler.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_rxml4 = require("@ai-sdk-tool/rxml");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -2688,7 +2913,7 @@ async function handleToolChoice(doGenerate, params) {
   }
   const toolCall = {
     type: "tool-call",
-    toolCallId: generateId3(),
+    toolCallId: (0, import_provider_utils.generateId)(),
     toolName: parsed.name || "unknown",
     input: JSON.stringify(parsed.arguments || {})
   };
@@ -2807,80 +3032,79 @@ function fixToolCallWithSchema(part, tools) {
     args = tc.input;
   }
   const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = coerceBySchema(args, schema);
+  const coerced = (0, import_rxml4.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
   };
 }
 
-// src/protocols/tool-call-protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
-// src/stream-handler.ts
-import { generateId as generateId4 } from "@ai-sdk/provider-utils";
-function extractToolCallSegments(protocol, fullRawText, tools) {
-  const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
-    text: fullRawText,
-    tools
-  }) : [];
-  return segments.join("\n\n");
-}
-function serializeToolCalls(parsedToolCalls) {
-  const toolCallParts = parsedToolCalls.filter(
-    (p) => p.type === "tool-call"
-  );
-  return JSON.stringify(
-    toolCallParts.map((tc) => ({
-      toolName: tc.toolName,
-      input: tc.input
-    }))
-  );
-}
-function handleDebugSummary(parsedToolCalls, origin, params) {
-  var _a, _b;
-  const dbg = (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.debugSummary;
-  if (dbg) {
-    dbg.originalText = origin;
-    try {
-      dbg.toolCalls = serializeToolCalls(parsedToolCalls);
-    } catch (e) {
-    }
-  } else {
-    logParsedSummary({
-      toolCalls: parsedToolCalls,
-      originalText: origin
-    });
+// src/v6/stream-handler.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+function mapCorePartToV3(part) {
+  switch (part.type) {
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: part.id || (0, import_provider_utils2.generateId)(),
+        delta: part.textDelta
+      };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input
+      };
+    case "tool-call-delta":
+      return {
+        type: "tool-call-delta",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        argsTextDelta: part.argsTextDelta
+      };
+    case "finish":
+      return {
+        type: "finish",
+        finishReason: part.finishReason,
+        usage: part.usage
+      };
+    case "error":
+      return {
+        type: "error",
+        error: part.error
+      };
+    default:
+      return part;
   }
 }
-function createDebugSummaryTransform({
-  protocol,
-  getFullRawText,
-  tools,
-  params
-}) {
-  return new TransformStream({
-    transform: /* @__PURE__ */ (() => {
-      const parsedToolCalls = [];
-      return (part, controller) => {
-        if (part.type === "tool-call") {
-          parsedToolCalls.push(part);
-        }
-        if (part.type === "finish") {
-          try {
-            const raw = getFullRawText();
-            logRawChunk(raw);
-            const origin = extractToolCallSegments(protocol, raw, tools);
-            handleDebugSummary(parsedToolCalls, origin, params);
-          } catch (e) {
-          }
-        }
-        controller.enqueue(part);
+function mapV3PartToCore(part) {
+  const p = part;
+  switch (p.type) {
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: p.id,
+        textDelta: p.delta || p.textDelta || ""
       };
-    })()
-  });
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: p.toolCallId,
+        toolName: p.toolName,
+        input: p.input
+      };
+    case "finish": {
+      const finishReason = p.finishReason;
+      return {
+        type: "finish",
+        finishReason: (typeof finishReason === "object" ? finishReason == null ? void 0 : finishReason.unified : finishReason) || "stop",
+        usage: p.usage
+      };
+    }
+    default:
+      return p;
+  }
 }
 async function wrapStream({
   protocol,
@@ -2902,89 +3126,39 @@ async function wrapStream({
   );
   const options = {
     ...extractOnErrorOption(params.providerOptions),
-    ...(_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware
+    ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
   };
-  if (debugLevel === "off") {
-    return {
-      stream: stream.pipeThrough(
-        protocol.createStreamParser({
-          tools,
-          options
-        })
-      ),
-      ...rest
-    };
-  }
-  if (debugLevel === "stream") {
-    const withRawTap2 = stream.pipeThrough(
-      new TransformStream(
-        {
-          transform(part, controller) {
-            logRawChunk(part);
-            controller.enqueue(part);
-          }
-        }
-      )
-    );
-    const parsed2 = withRawTap2.pipeThrough(
-      protocol.createStreamParser({
-        tools,
-        options
-      })
-    );
-    const withParsedTap = parsed2.pipeThrough(
-      new TransformStream(
-        {
-          transform(part, controller) {
-            logParsedChunk(part);
-            controller.enqueue(part);
-          }
-        }
-      )
-    );
-    return {
-      stream: withParsedTap,
-      ...rest
-    };
-  }
-  let fullRawText = "";
-  const withRawTap = stream.pipeThrough(
+  const coreStream = stream.pipeThrough(
     new TransformStream({
       transform(part, controller) {
-        if (part.type === "text-delta") {
-          const delta = part.delta;
-          if (typeof delta === "string" && delta.length > 0) {
-            fullRawText += delta;
-          }
+        if (debugLevel === "stream") {
+          logRawChunk(part);
         }
-        controller.enqueue(part);
+        controller.enqueue(mapV3PartToCore(part));
       }
     })
-  );
-  const parsed = withRawTap.pipeThrough(
-    protocol.createStreamParser({
-      tools,
-      options
-    })
-  );
-  const withSummary = parsed.pipeThrough(
-    createDebugSummaryTransform({
-      protocol,
-      getFullRawText: () => fullRawText,
-      tools,
-      params
+  ).pipeThrough(protocol.createStreamParser({ tools, options }));
+  const v3Stream = coreStream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        const v3Part = mapCorePartToV3(part);
+        if (debugLevel === "stream") {
+          logParsedChunk(v3Part);
+        }
+        controller.enqueue(v3Part);
+      }
     })
   );
   return {
-    stream: withSummary,
-    ...rest
+    ...rest,
+    stream: v3Stream
   };
 }
 async function toolChoiceStream({
   doGenerate,
   options
 }) {
-  var _a, _b, _c;
+  var _a, _b;
   const result = await doGenerate();
   let toolJson = {};
   if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
@@ -3002,62 +3176,33 @@ async function toolChoiceStream({
       toolJson = {};
     }
   }
-  const toolCallChunk = {
-    type: "tool-call",
-    toolCallId: generateId4(),
-    toolName: toolJson.name || "unknown",
-    input: JSON.stringify(toolJson.arguments || {})
-  };
-  const finishChunk = {
-    type: "finish",
-    usage: (result == null ? void 0 : result.usage) || {
-      inputTokens: {
-        total: 0,
-        noCache: void 0,
-        cacheRead: void 0,
-        cacheWrite: void 0
-      },
-      outputTokens: {
-        total: 0,
-        text: void 0,
-        reasoning: void 0
-      }
-    },
-    finishReason: { unified: "tool-calls", raw: void 0 }
-  };
   const stream = new ReadableStream({
     start(controller) {
-      controller.enqueue(toolCallChunk);
-      controller.enqueue(finishChunk);
+      controller.enqueue({
+        type: "tool-call",
+        toolCallId: (0, import_provider_utils2.generateId)(),
+        toolName: toolJson.name || "unknown",
+        input: JSON.stringify(toolJson.arguments || {})
+      });
+      controller.enqueue({
+        type: "finish",
+        usage: (result == null ? void 0 : result.usage) || {
+          inputTokens: 0,
+          outputTokens: 0
+        },
+        finishReason: "tool-calls"
+      });
       controller.close();
     }
   });
-  const debugLevel = getDebugLevel();
-  const firstText = ((_c = result == null ? void 0 : result.content) == null ? void 0 : _c[0]) && result.content[0].type === "text" && result.content[0].text || "";
-  const streamWithSummary = debugLevel === "parse" ? stream.pipeThrough(
-    new TransformStream({
-      transform(part, controller) {
-        if (part.type === "finish") {
-          try {
-            logParsedSummary({
-              toolCalls: [toolCallChunk],
-              originalText: typeof firstText === "string" ? firstText : ""
-            });
-          } catch (e) {
-          }
-        }
-        controller.enqueue(part);
-      }
-    })
-  ) : stream;
   return {
     request: (result == null ? void 0 : result.request) || {},
     response: (result == null ? void 0 : result.response) || {},
-    stream: streamWithSummary
+    stream
   };
 }
 
-// src/utils/dynamic-tool-schema.ts
+// src/core/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
   let currentSchema = {};
   const toolNames = [];
@@ -3114,7 +3259,13 @@ function createDynamicIfThenElseSchema(tools) {
   };
 }
 
-// src/transform-handler.ts
+// src/core/utils/type-guards.ts
+function isToolCallContent(content) {
+  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
+  (typeof content.input === "string" || typeof content.input === "object");
+}
+
+// src/v6/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
   const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
   if (systemIndex !== -1) {
@@ -3336,7 +3487,14 @@ function processToolMessage(content, resolvedProtocol) {
     content: [
       {
         type: "text",
-        text: content.map((toolResult) => resolvedProtocol.formatToolResponse(toolResult)).join("\n")
+        text: content.map((toolResult) => {
+          var _a, _b;
+          const tr = toolResult;
+          return resolvedProtocol.formatToolResponse({
+            ...toolResult,
+            result: (_b = (_a = tr.result) != null ? _a : tr.content) != null ? _b : tr.output
+          });
+        }).join("\n")
       }
     ]
   };
@@ -3429,7 +3587,7 @@ function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
   return processedPrompt;
 }
 
-// src/tool-call-middleware.ts
+// src/v6/tool-call-middleware.ts
 function createToolMiddleware({
   protocol,
   toolSystemPromptTemplate,
@@ -3466,19 +3624,14 @@ function createToolMiddleware({
   };
 }
 
-// src/index.ts
+// src/v6/index.ts
 var gemmaToolMiddleware = createToolMiddleware({
-  protocol: jsonMixProtocol(
-    // Customize the tool call delimiters to use markdown code fences
-    {
-      toolCallStart: "```tool_call\n",
-      // TODO: Support specifying multiple possible tags,
-      // e.g., for gemma, it would be nice to be able to set both `` and ``` at the same time.
-      toolCallEnd: "\n```",
-      toolResponseStart: "```tool_response\n",
-      toolResponseEnd: "\n```"
-    }
-  ),
+  protocol: jsonMixProtocol({
+    toolCallStart: "```tool_call\n",
+    toolCallEnd: "\n```",
+    toolResponseStart: "```tool_response\n",
+    toolResponseEnd: "\n```"
+  }),
   toolSystemPromptTemplate(tools) {
     return `You have access to functions. If you decide to invoke any of the function(s),
 you MUST put it in the format of markdown code fence block with the language name of tool_call , e.g.
@@ -3506,11 +3659,13 @@ For each function call return a json object with function name and arguments wit
 });
 var morphXmlToolMiddleware = createToolMiddleware({
   protocol: morphXmlProtocol,
-  placement: "last",
+  placement: "first",
   toolSystemPromptTemplate(tools) {
-    return `You are a function calling AI model.
+    return `# Tools
+
+You may call one or more functions to assist with the user query.
 
-Available functions are listed inside <tools></tools>.
+You are provided with function signatures within <tools></tools> XML tags:
 <tools>${tools}</tools>
 
 # Rules
@@ -3520,6 +3675,7 @@ Available functions are listed inside <tools></tools>.
 - Do not add or remove functions or parameters.
 - Each required parameter must appear once.
 - Output nothing before or after the function call.
+- After calling a tool, you will receive a response in the format: <tool_response><tool_name>NAME</tool_name><result>RESULT</result></tool_response>. Use this result to answer the user.
 
 # Example
 <get_weather>
@@ -3528,42 +3684,17 @@ Available functions are listed inside <tools></tools>.
 </get_weather>`;
   }
 });
-
-export {
-  getDebugLevel,
-  logParseFailure,
-  logRawChunk,
-  logParsedChunk,
-  logParsedSummary,
-  getPotentialStartIndex,
-  escapeRegExp,
-  transform,
-  parse,
-  stringify,
-  jsonMixProtocol,
-  applyHeuristicPipeline,
-  createIntermediateCall,
-  mergePipelineConfigs,
-  normalizeCloseTagsHeuristic,
-  escapeInvalidLtHeuristic,
-  balanceTagsHeuristic,
-  dedupeShellStringTagsHeuristic,
-  repairAgainstSchemaHeuristic,
-  defaultPipelineConfig,
-  isToolCallContent,
-  isToolResultPart,
-  hasInputProperty,
-  morphXmlProtocol,
-  extractOnErrorOption,
-  originalToolsSchema,
-  encodeOriginalTools,
-  decodeOriginalTools,
-  extractToolNamesFromOriginalTools,
-  isToolChoiceActive,
-  createDynamicIfThenElseSchema,
+var orchestratorToolMiddleware = createToolMiddleware({
+  protocol: yamlXmlProtocol(),
+  placement: "first",
+  toolSystemPromptTemplate: orchestratorSystemPromptTemplate
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   createToolMiddleware,
   gemmaToolMiddleware,
   hermesToolMiddleware,
-  morphXmlToolMiddleware
-};
-//# sourceMappingURL=chunk-LB5ALTRD.js.map
+  morphXmlToolMiddleware,
+  orchestratorToolMiddleware
+});
+//# sourceMappingURL=v6.cjs.map