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

package/dist/index.cjs

@@ -20,11 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  RJSON: () => robust_json_exports,
+  applyHeuristicPipeline: () => applyHeuristicPipeline,
+  balanceTagsHeuristic: () => balanceTagsHeuristic,
   createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
+  createIntermediateCall: () => createIntermediateCall,
   createToolMiddleware: () => createToolMiddleware,
   decodeOriginalTools: () => decodeOriginalTools,
+  dedupeShellStringTagsHeuristic: () => dedupeShellStringTagsHeuristic,
+  defaultPipelineConfig: () => defaultPipelineConfig,
   encodeOriginalTools: () => encodeOriginalTools,
+  escapeInvalidLtHeuristic: () => escapeInvalidLtHeuristic,
   escapeRegExp: () => escapeRegExp,
   extractOnErrorOption: () => extractOnErrorOption,
   extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
@@ -37,23 +42,24 @@ __export(src_exports, {
   isToolChoiceActive: () => isToolChoiceActive,
   isToolResultPart: () => isToolResultPart,
   jsonMixProtocol: () => jsonMixProtocol,
+  logParseFailure: () => logParseFailure,
   logParsedChunk: () => logParsedChunk,
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
+  mergePipelineConfigs: () => mergePipelineConfigs,
   morphXmlProtocol: () => morphXmlProtocol,
   morphXmlToolMiddleware: () => morphXmlToolMiddleware,
+  normalizeCloseTagsHeuristic: () => normalizeCloseTagsHeuristic,
   originalToolsSchema: () => originalToolsSchema,
   parseRJSON: () => parse,
+  repairAgainstSchemaHeuristic: () => repairAgainstSchemaHeuristic,
   stringifyRJSON: () => stringify,
   transformRJSON: () => transform
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/protocols/dummy-protocol.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-
 // src/protocols/json-mix-protocol.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
 // src/utils/debug.ts
 var LINE_SPLIT_REGEX = /\r?\n/;
@@ -101,6 +107,7 @@ var cBgGreen = color(ANSI_BG_GREEN);
 var cInverse = color(ANSI_INVERSE);
 var cUnderline = color(ANSI_UNDERLINE);
 var cBold = color(ANSI_BOLD);
+var MAX_SNIPPET_LENGTH = 800;
 function safeStringify(value) {
   try {
     return `
@@ -109,6 +116,41 @@ ${typeof value === "string" ? value : JSON.stringify(value, null, 2)}`;
     return String(value);
   }
 }
+function formatError(error) {
+  if (error instanceof Error) {
+    const stack = error.stack ? `
+${error.stack}` : "";
+    return `
+${error.name}: ${error.message}${stack}`;
+  }
+  return safeStringify(error);
+}
+function truncateSnippet(snippet) {
+  if (snippet.length <= MAX_SNIPPET_LENGTH) {
+    return snippet;
+  }
+  return `${snippet.slice(0, MAX_SNIPPET_LENGTH)}
+\u2026[truncated ${snippet.length - MAX_SNIPPET_LENGTH} chars]`;
+}
+function logParseFailure({
+  phase,
+  reason,
+  snippet,
+  error
+}) {
+  if (getDebugLevel() !== "parse") {
+    return;
+  }
+  const label = cBgBlue(`[${phase}]`);
+  console.log(cGray("[debug:mw:fail]"), label, cYellow(reason));
+  if (snippet) {
+    const formatted = truncateSnippet(snippet);
+    console.log(cGray("[debug:mw:fail:snippet]"), formatted);
+  }
+  if (error) {
+    console.log(cGray("[debug:mw:fail:error]"), cCyan(formatError(error)));
+  }
+}
 function logRawChunk(part) {
   console.log(cGray("[debug:mw:raw]"), cYellow(safeStringify(part)));
 }
@@ -174,63 +216,6 @@ ${rendered}`);
   }
 }
 
-// src/utils/dynamic-tool-schema.ts
-function createDynamicIfThenElseSchema(tools) {
-  let currentSchema = {};
-  const toolNames = [];
-  for (let i = tools.length - 1; i >= 0; i -= 1) {
-    const tool = tools[i];
-    if (tool.type === "provider-defined") {
-      throw new Error(
-        "Provider-defined tools are not supported by this middleware. Please use custom tools."
-      );
-    }
-    toolNames.unshift(tool.name);
-    const toolCondition = {
-      if: {
-        properties: {
-          name: {
-            const: tool.name
-          }
-        },
-        required: ["name"]
-      },
-      // biome-ignore lint/suspicious/noThenProperty: JSON Schema uses 'then' as a keyword
-      then: {
-        properties: {
-          name: {
-            const: tool.name
-          },
-          arguments: tool.inputSchema
-        },
-        required: ["name", "arguments"]
-      }
-    };
-    if (Object.keys(currentSchema).length > 0) {
-      toolCondition.else = currentSchema;
-    }
-    currentSchema = toolCondition;
-  }
-  return {
-    type: "object",
-    // Explicitly specify type as "object"
-    properties: {
-      name: {
-        type: "string",
-        description: "Name of the tool to call",
-        enum: toolNames
-      },
-      arguments: {
-        type: "object",
-        // By default, arguments is also specified as object type
-        description: "Argument object to be passed to the tool"
-      }
-    },
-    required: ["name", "arguments"],
-    ...currentSchema
-  };
-}
-
 // src/utils/get-potential-start-index.ts
 function getPotentialStartIndex(text, searchedText) {
   if (searchedText.length === 0) {
@@ -249,60 +234,12 @@ function getPotentialStartIndex(text, searchedText) {
   return null;
 }
 
-// src/utils/on-error.ts
-function extractOnErrorOption(providerOptions) {
-  var _a;
-  if (providerOptions && typeof providerOptions === "object") {
-    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
-    return onError ? { onError } : void 0;
-  }
-  return;
-}
-
-// src/utils/provider-options.ts
-var originalToolsSchema = {
-  encode: encodeOriginalTools,
-  decode: decodeOriginalTools
-};
-function encodeOriginalTools(tools) {
-  return (tools == null ? void 0 : tools.map((t) => ({
-    name: t.name,
-    inputSchema: JSON.stringify(t.inputSchema)
-  }))) || [];
-}
-function decodeOriginalTools(originalTools) {
-  if (!originalTools) {
-    return [];
-  }
-  return originalTools.map(
-    (t) => ({
-      type: "function",
-      name: t.name,
-      inputSchema: JSON.parse(t.inputSchema)
-    })
-  );
-}
-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/utils/regex.ts
 function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 // src/utils/robust-json.ts
-var robust_json_exports = {};
-__export(robust_json_exports, {
-  parse: () => parse,
-  stringify: () => stringify,
-  transform: () => transform
-});
 var WHITESPACE_TEST_REGEX = /\s/;
 var WHITESPACE_REGEX = /^\s+/;
 var OBJECT_START_REGEX = /^\{/;
@@ -967,19 +904,6 @@ function stringify(obj) {
   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/json-mix-protocol.ts
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a;
@@ -987,11 +911,17 @@ function processToolCallJson(toolCallJson, fullMatch, processedElements, options
     const parsedToolCall = parse(toolCallJson);
     processedElements.push({
       type: "tool-call",
-      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolCallId: (0, import_provider_utils.generateId)(),
       toolName: parsedToolCall.name,
       input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
     });
   } catch (error) {
+    logParseFailure({
+      phase: "generated-text",
+      reason: "Failed to parse tool call JSON segment",
+      snippet: fullMatch,
+      error
+    });
     if (options == null ? void 0 : options.onError) {
       options.onError(
         "Could not process JSON tool call, keeping original text.",
@@ -1024,7 +954,7 @@ function flushBuffer(state, controller, toolCallStart) {
     return;
   }
   if (!state.currentTextId) {
-    state.currentTextId = (0, import_provider_utils2.generateId)();
+    state.currentTextId = (0, import_provider_utils.generateId)();
     controller.enqueue({ type: "text-start", id: state.currentTextId });
     state.hasEmittedTextStart = true;
   }
@@ -1047,7 +977,12 @@ function emitIncompleteToolCall(state, controller, toolCallStart) {
   if (!state.currentToolCallJson) {
     return;
   }
-  const errorId = (0, import_provider_utils2.generateId)();
+  logParseFailure({
+    phase: "stream",
+    reason: "Incomplete streaming tool call segment emitted as text",
+    snippet: `${toolCallStart}${state.currentToolCallJson}`
+  });
+  const errorId = (0, import_provider_utils.generateId)();
   controller.enqueue({ type: "text-start", id: errorId });
   controller.enqueue({
     type: "text-delta",
@@ -1071,7 +1006,7 @@ function publishText(text, state, controller) {
     state.currentToolCallJson += text;
   } else if (text.length > 0) {
     if (!state.currentTextId) {
-      state.currentTextId = (0, import_provider_utils2.generateId)();
+      state.currentTextId = (0, import_provider_utils.generateId)();
       controller.enqueue({ type: "text-start", id: state.currentTextId });
       state.hasEmittedTextStart = true;
     }
@@ -1086,16 +1021,22 @@ function emitToolCall(context) {
   var _a;
   const { state, controller, toolCallStart, toolCallEnd, options } = context;
   try {
-    const parsedToolCall = robust_json_exports.parse(state.currentToolCallJson);
+    const parsedToolCall = parse(state.currentToolCallJson);
     closeTextBlock(state, controller);
     controller.enqueue({
       type: "tool-call",
-      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolCallId: (0, import_provider_utils.generateId)(),
       toolName: parsedToolCall.name,
       input: JSON.stringify((_a = parsedToolCall.arguments) != null ? _a : {})
     });
-  } catch (e) {
-    const errorId = (0, import_provider_utils2.generateId)();
+  } catch (error) {
+    logParseFailure({
+      phase: "stream",
+      reason: "Failed to parse streaming tool call JSON segment",
+      snippet: `${toolCallStart}${state.currentToolCallJson}${toolCallEnd}`,
+      error
+    });
+    const errorId = (0, import_provider_utils.generateId)();
     controller.enqueue({ type: "text-start", id: errorId });
     controller.enqueue({
       type: "text-delta",
@@ -1260,162 +1201,900 @@ var jsonMixProtocol = ({
 });
 
 // src/protocols/morph-xml-protocol.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_rxml = require("@ai-sdk-tool/rxml");
-var WHITESPACE_REGEX2 = /\s/;
-function processTextBeforeToolCall(text, currentIndex, toolCallStartIndex, processedElements) {
-  if (toolCallStartIndex > currentIndex) {
-    const textSegment = text.substring(currentIndex, toolCallStartIndex);
-    if (textSegment.trim()) {
-      processedElements.push({ type: "text", text: textSegment });
-    }
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_rxml2 = require("@ai-sdk-tool/rxml");
+
+// src/heuristics/engine.ts
+function applyRawSegmentUpdate(current, result) {
+  if (result.rawSegment !== void 0) {
+    return { ...current, rawSegment: result.rawSegment };
   }
-  return currentIndex;
+  return current;
 }
-function processToolCall(params) {
-  var _a;
-  const { toolCall, tools, options, text, processedElements } = params;
-  try {
-    const toolSchema = getToolSchema(tools, toolCall.toolName);
-    const parsed = (0, import_rxml.parse)(toolCall.content, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      // Disable HTML self-closing tag behavior to allow base, meta, link etc. as regular tags
-      noChildNodes: []
-    });
-    processedElements.push({
-      type: "tool-call",
-      toolCallId: (0, import_provider_utils3.generateId)(),
-      toolName: toolCall.toolName,
-      input: JSON.stringify(parsed)
-    });
-  } catch (error) {
-    const originalCallText = text.substring(
-      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
-    });
-    processedElements.push({ type: "text", text: originalCallText });
+function applyParsedUpdate(current, result) {
+  if (result.parsed !== void 0) {
+    return { ...current, parsed: result.parsed };
   }
+  return current;
 }
-function addRemainingText(text, currentIndex, processedElements) {
-  if (currentIndex < text.length) {
-    const remainingText = text.substring(currentIndex);
-    if (remainingText.trim()) {
-      processedElements.push({ type: "text", text: remainingText });
-    }
+function applyWarningsUpdate(current, result) {
+  var _a, _b;
+  if (result.warnings && result.warnings.length > 0) {
+    const meta = (_a = current.meta) != null ? _a : {};
+    const existingWarnings = (_b = meta.warnings) != null ? _b : [];
+    return {
+      ...current,
+      meta: { ...meta, warnings: [...existingWarnings, ...result.warnings] }
+    };
   }
+  return current;
 }
-function handleStreamingToolCallEnd(params) {
-  const { toolContent, currentToolCall, tools, options, ctrl, flushText } = params;
+function attemptReparse(current, result, reparseCount, maxReparses, parse4) {
+  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
+    return { state: current, newCount: reparseCount };
+  }
   try {
-    const toolSchema = getToolSchema(tools, currentToolCall.name);
-    const parsed = (0, import_rxml.parse)(toolContent, toolSchema, {
-      onError: options == null ? void 0 : options.onError,
-      noChildNodes: []
-    });
-    flushText(ctrl);
-    ctrl.enqueue({
-      type: "tool-call",
-      toolCallId: (0, import_provider_utils3.generateId)(),
-      toolName: currentToolCall.name,
-      input: JSON.stringify(parsed)
-    });
+    const reparsed = parse4(result.rawSegment, current.schema);
+    return {
+      state: { ...current, parsed: reparsed, errors: [] },
+      newCount: reparseCount + 1
+    };
   } catch (error) {
-    handleStreamingToolCallError({
-      error,
-      currentToolCall,
-      toolContent,
-      options,
-      ctrl,
-      flushText
-    });
+    return {
+      state: { ...current, errors: [...current.errors, error] },
+      newCount: reparseCount + 1
+    };
   }
 }
-function handleStreamingToolCallError(params) {
+function executePhase(ctx, heuristics, options) {
   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 import_rxml.RXMLDuplicateStringTagError) {
-    message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof import_rxml.RXMLCoercionError) {
-    message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
-  } else if (error instanceof import_rxml.RXMLParseError) {
-    message = `Failed to parse XML for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  let current = ctx;
+  let reparseCount = 0;
+  const maxReparses = (_a = options.maxReparses) != null ? _a : 2;
+  for (const heuristic of heuristics) {
+    if (!heuristic.applies(current)) {
+      continue;
+    }
+    const result = heuristic.run(current);
+    current = applyRawSegmentUpdate(current, result);
+    current = applyParsedUpdate(current, result);
+    current = applyWarningsUpdate(current, result);
+    const reparseResult = attemptReparse(
+      current,
+      result,
+      reparseCount,
+      maxReparses,
+      options.parse
+    );
+    current = reparseResult.state;
+    reparseCount = reparseResult.newCount;
+    if (result.stop) {
+      break;
+    }
   }
-  (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, message, {
-    toolCall: originalCallText,
-    toolName: currentToolCall.name,
-    error
-  });
-  flushText(ctrl, originalCallText);
+  return current;
 }
-function findEarliestToolTag(buffer, toolNames) {
-  let earliestStartTagIndex = -1;
-  let earliestToolName = "";
-  if (toolNames.length > 0) {
-    for (const name of toolNames) {
-      const startTag = `<${name}>`;
-      const index = buffer.indexOf(startTag);
-      if (index !== -1 && (earliestStartTagIndex === -1 || index < earliestStartTagIndex)) {
-        earliestStartTagIndex = index;
-        earliestToolName = name;
-      }
+function applyHeuristicPipeline(ctx, config, options) {
+  let current = ctx;
+  if (config.preParse && config.preParse.length > 0) {
+    current = executePhase(current, config.preParse, options);
+  }
+  if (current.parsed === null && current.errors.length === 0) {
+    try {
+      const parsed = options.parse(current.rawSegment, current.schema);
+      current = { ...current, parsed, errors: [] };
+    } catch (error) {
+      current = { ...current, errors: [error] };
     }
   }
-  return { index: earliestStartTagIndex, name: earliestToolName };
+  if (current.errors.length > 0 && config.fallbackReparse && config.fallbackReparse.length > 0) {
+    current = executePhase(current, config.fallbackReparse, options);
+  }
+  if (current.parsed !== null && config.postParse && config.postParse.length > 0) {
+    current = executePhase(current, config.postParse, options);
+  }
+  return current;
 }
-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 createIntermediateCall(toolName, rawSegment, schema) {
+  return {
+    toolName,
+    schema,
+    rawSegment,
+    parsed: null,
+    errors: [],
+    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 { buffer, shouldContinue: false };
+  return result;
 }
-function processToolCallInBuffer(params) {
-  const {
-    buffer,
-    currentToolCall,
-    tools,
+
+// src/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;
+var WHITESPACE_REGEX2 = /\s/;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var NAME_START_CHAR_RE = /[A-Za-z_:]/;
+var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
+var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
+var normalizeCloseTagsHeuristic = {
+  id: "normalize-close-tags",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const normalized = ctx.rawSegment.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    if (normalized !== ctx.rawSegment) {
+      return { rawSegment: normalized };
+    }
+    return {};
+  }
+};
+var escapeInvalidLtHeuristic = {
+  id: "escape-invalid-lt",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const escaped = escapeInvalidLt(ctx.rawSegment);
+    if (escaped !== ctx.rawSegment) {
+      return { rawSegment: escaped };
+    }
+    return {};
+  }
+};
+var balanceTagsHeuristic = {
+  id: "balance-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const balanced = balanceTags(original);
+    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
+    if (!hasMalformedClose && balanced.length > normalized.length) {
+      return false;
+    }
+    return balanced !== normalized;
+  },
+  run: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const balanced = balanceTags(original);
+    const escaped = escapeInvalidLt(balanced);
+    return { rawSegment: escaped, reparse: true };
+  }
+};
+var dedupeShellStringTagsHeuristic = {
+  id: "dedupe-shell-string-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => shouldDeduplicateStringTags(ctx.schema),
+  run: (ctx) => {
+    const names = getStringPropertyNames(ctx.schema);
+    let deduped = ctx.rawSegment;
+    for (const key of names) {
+      deduped = dedupeSingleTag(deduped, key);
+    }
+    if (deduped !== ctx.rawSegment) {
+      return { rawSegment: deduped, reparse: true };
+    }
+    return {};
+  }
+};
+var repairAgainstSchemaHeuristic = {
+  id: "repair-against-schema",
+  phase: "post-parse",
+  applies: (ctx) => ctx.parsed !== null && typeof ctx.parsed === "object",
+  run: (ctx) => {
+    const repaired = repairParsedAgainstSchema(ctx.parsed, ctx.schema);
+    if (repaired !== ctx.parsed) {
+      return { parsed: repaired };
+    }
+    return {};
+  }
+};
+var defaultPipelineConfig = {
+  preParse: [normalizeCloseTagsHeuristic, escapeInvalidLtHeuristic],
+  fallbackReparse: [balanceTagsHeuristic, dedupeShellStringTagsHeuristic],
+  postParse: [repairAgainstSchemaHeuristic]
+};
+var INDEX_TAG_RE = /^<(\d+)(?:>|\/?>)/;
+function isIndexTagAt(xml, pos) {
+  const remaining = xml.slice(pos);
+  return INDEX_TAG_RE.test(remaining);
+}
+function escapeInvalidLt(xml) {
+  const len = xml.length;
+  let out = "";
+  for (let i = 0; i < len; i += 1) {
+    const ch = xml[i];
+    if (ch === "<") {
+      const next = i + 1 < len ? xml[i + 1] : "";
+      const isValidStart = NAME_START_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?";
+      const isIndexTag = !isValidStart && isIndexTagAt(xml, i);
+      if (!(isValidStart || isIndexTag)) {
+        out += "&lt;";
+        continue;
+      }
+    }
+    out += ch;
+  }
+  return out;
+}
+function balanceTags(xml) {
+  const src = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>").replace(STATUS_TO_STEP_BOUNDARY_RE, "</status></step><step>");
+  let i = 0;
+  const len = src.length;
+  const out = [];
+  const stack = [];
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      out.push(src.slice(i));
+      break;
+    }
+    out.push(src.slice(i, lt));
+    if (lt + 1 >= len) {
+      break;
+    }
+    const next = src[lt + 1];
+    if (next === "!" || next === "?") {
+      i = handleSpecialTagSegment(src, lt, out);
+      continue;
+    }
+    if (next === "/") {
+      i = handleClosingTagSegment(src, lt, out, stack);
+      continue;
+    }
+    i = handleOpeningTagSegment(src, lt, out, stack);
+  }
+  for (let k = stack.length - 1; k >= 0; k -= 1) {
+    out.push(`</${stack[k]}>`);
+  }
+  return out.join("");
+}
+function skipWs(s, p, len) {
+  let idx = p;
+  while (idx < len && WHITESPACE_REGEX2.test(s[idx])) {
+    idx += 1;
+  }
+  return idx;
+}
+function parseTagNameAt(s, p, len) {
+  let idx = p;
+  const start = idx;
+  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
+    idx += 1;
+  }
+  return { name: s.slice(start, idx), pos: idx };
+}
+function handleSpecialTagSegment(src, lt, out) {
+  const gt = src.indexOf(">", lt + 1);
+  if (gt === -1) {
+    out.push(src.slice(lt));
+    return src.length;
+  }
+  out.push(src.slice(lt, gt + 1));
+  return gt + 1;
+}
+function handleClosingTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 2, len);
+  const { name, pos } = parseTagNameAt(src, p, len);
+  p = pos;
+  const gt = src.indexOf(">", p);
+  const closingText = gt === -1 ? src.slice(lt) : src.slice(lt, gt + 1);
+  const idx = stack.lastIndexOf(name);
+  if (idx !== -1) {
+    for (let k = stack.length - 1; k > idx; k -= 1) {
+      out.push(`</${stack[k]}>`);
+      stack.pop();
+    }
+    out.push(closingText);
+    stack.pop();
+  }
+  return gt === -1 ? len : gt + 1;
+}
+function handleOpeningTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 1, len);
+  const nameStart = p;
+  const parsed = parseTagNameAt(src, p, len);
+  p = parsed.pos;
+  const name = src.slice(nameStart, p);
+  const q = src.indexOf(">", p);
+  if (q === -1) {
+    out.push(src.slice(lt));
+    return len;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX2.test(src[r])) {
+    r -= 1;
+  }
+  const selfClosing = src[r] === "/";
+  out.push(src.slice(lt, q + 1));
+  if (!selfClosing && name) {
+    stack.push(name);
+  }
+  return q + 1;
+}
+function shouldDeduplicateStringTags(schema) {
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return false;
+  }
+  const props = unwrapped.properties;
+  if (!props) {
+    return false;
+  }
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = (0, import_rxml.unwrapJsonSchema)(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
+}
+function getStringPropertyNames(schema) {
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return [];
+  }
+  const props = unwrapped.properties;
+  if (!props) {
+    return [];
+  }
+  const names = [];
+  for (const key of Object.keys(props)) {
+    const prop = (0, import_rxml.unwrapJsonSchema)(
+      props[key]
+    );
+    const type = prop.type;
+    if (type === "string") {
+      names.push(key);
+    }
+  }
+  return names;
+}
+function escapeRegExp2(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function dedupeSingleTag(xml, key) {
+  var _a, _b;
+  const escaped = escapeRegExp2(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
+  }
+  const last = matches.at(-1);
+  let result = "";
+  let cursor = 0;
+  for (const m of matches) {
+    const idx = (_a = m.index) != null ? _a : 0;
+    result += xml.slice(cursor, idx);
+    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
+      result += m[0];
+    }
+    cursor = idx + m[0].length;
+  }
+  result += xml.slice(cursor);
+  return result;
+}
+function repairParsedAgainstSchema(input, schema) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return input;
+  }
+  const properties = unwrapped.properties;
+  if (!properties) {
+    return input;
+  }
+  applySchemaProps(input, properties);
+  return input;
+}
+function applySchemaProps(obj, properties) {
+  for (const key of Object.keys(obj)) {
+    const propSchema = properties[key];
+    if (!propSchema) {
+      continue;
+    }
+    const prop = (0, import_rxml.unwrapJsonSchema)(propSchema);
+    const propType = prop.type;
+    if (propType === "array" && prop.items) {
+      const itemSchemaRaw = prop.items;
+      const itemSchema = (0, import_rxml.unwrapJsonSchema)(itemSchemaRaw);
+      obj[key] = coerceArrayItems(obj[key], itemSchema);
+      continue;
+    }
+    if (propType === "object") {
+      const val = obj[key];
+      if (val && typeof val === "object") {
+        obj[key] = repairParsedAgainstSchema(val, prop);
+      }
+    }
+  }
+}
+function coerceArrayItems(val, itemSchema) {
+  if (!Array.isArray(val)) {
+    return val;
+  }
+  return val.map((v) => coerceArrayItem(v, itemSchema));
+}
+function coerceArrayItem(v, itemSchema) {
+  const itemType = itemSchema == null ? void 0 : itemSchema.type;
+  if (typeof v === "string" && itemType === "object") {
+    const parsed = tryParseStringToSchemaObject(v, itemSchema);
+    if (parsed !== null) {
+      return parsed;
+    }
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
+    );
+    if (fallback) {
+      return fallback;
+    }
+    return v;
+  }
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(v, itemSchema);
+  }
+  return v;
+}
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = (0, import_rxml.parse)(normalized, itemSchema, { noChildNodes: [] });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
+  }
+}
+function extractStepStatusFromString(normXml) {
+  const stepMatch = normXml.match(STEP_TAG_RE);
+  const statusMatch = normXml.match(STATUS_TAG_RE);
+  if (stepMatch && statusMatch) {
+    return { step: stepMatch[1], status: statusMatch[1] };
+  }
+  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
+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_:-]/;
+function normalizeCloseTags(xml) {
+  return xml.replace(MALFORMED_CLOSE_RE_G2, "</$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 = (0, import_rxml2.parse)(balanced, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
+    return parsed;
+  } catch (e) {
+    if (shouldDeduplicateStringTags(toolSchema)) {
+      const deduped = dedupeStringTagsAgainstSchema(balanced, toolSchema);
+      if (deduped !== balanced) {
+        try {
+          let reparsed = (0, import_rxml2.parse)(deduped, toolSchema, {
+            onError: options == null ? void 0 : options.onError,
+            noChildNodes: []
+          });
+          reparsed = repairParsedAgainstSchema(reparsed, toolSchema);
+          return reparsed;
+        } catch (e2) {
+          return null;
+        }
+      }
+    }
+    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 {
+    toolCall,
+    tools,
     options,
-    controller,
+    text,
+    processedElements,
+    pipelineConfig = defaultPipelineConfig2,
+    maxReparses
+  } = params;
+  const toolSchema = getToolSchema(tools, toolCall.toolName);
+  const ctx = createIntermediateCall2(
+    toolCall.toolName,
+    toolCall.content,
+    toolSchema
+  );
+  const result = applyHeuristicPipeline2(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: (0, import_provider_utils2.generateId)(),
+      toolName: toolCall.toolName,
+      input: JSON.stringify(result.parsed)
+    });
+  } else {
+    const originalCallText = text.substring(
+      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 = (0, import_rxml2.parse)(primary, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      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: (0, import_provider_utils2.generateId)(),
+        toolName: toolCall.toolName,
+        input: JSON.stringify(reparsed)
+      });
+      return;
+    }
+    const originalCallText = text.substring(
+      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
+    });
+    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) {
+  var _a;
+  const {
+    toolContent,
+    currentToolCall,
+    tools,
+    options,
+    ctrl,
     flushText,
-    setBuffer
+    pipelineConfig = defaultPipelineConfig2,
+    maxReparses
   } = params;
-  const endTag = `</${currentToolCall.name}>`;
-  const endTagIndex = buffer.indexOf(endTag);
-  if (endTagIndex !== -1) {
-    const toolContent = buffer.substring(0, endTagIndex);
-    const newBuffer = buffer.substring(endTagIndex + endTag.length);
-    setBuffer("");
-    handleStreamingToolCallEnd({
-      toolContent,
+  const toolSchema = getToolSchema(tools, currentToolCall.name);
+  const ctx = createIntermediateCall2(
+    currentToolCall.name,
+    toolContent,
+    toolSchema
+  );
+  const result = applyHeuristicPipeline2(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
+  });
+  flushText(ctrl);
+  if (result.parsed !== null) {
+    ctrl.enqueue({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      toolName: currentToolCall.name,
+      input: JSON.stringify(result.parsed)
+    });
+  } 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 import_rxml2.RXMLDuplicateStringTagError) {
+      message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+    } else if (error instanceof import_rxml2.RXMLCoercionError) {
+      message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+    } else if (error instanceof import_rxml2.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 handleStreamingToolCallEnd(params) {
+  const { toolContent, currentToolCall, tools, options, ctrl, flushText } = params;
+  const toolSchema = getToolSchema(tools, currentToolCall.name);
+  try {
+    const primary = escapeInvalidLt(normalizeCloseTags(toolContent));
+    let parsed = (0, import_rxml2.parse)(primary, toolSchema, {
+      onError: options == null ? void 0 : options.onError,
+      noChildNodes: []
+    });
+    parsed = repairParsedAgainstSchema(parsed, toolSchema);
+    flushText(ctrl);
+    ctrl.enqueue({
+      type: "tool-call",
+      toolCallId: (0, import_provider_utils2.generateId)(),
+      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: (0, import_provider_utils2.generateId)(),
+        toolName: currentToolCall.name,
+        input: JSON.stringify(parsed)
+      });
+      return;
+    }
+    handleStreamingToolCallError({
+      error,
       currentToolCall,
-      tools,
+      toolContent,
       options,
-      ctrl: controller,
+      ctrl,
       flushText
     });
+  }
+}
+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 import_rxml2.RXMLDuplicateStringTagError) {
+    message = `Duplicate string tags detected in streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  } else if (error instanceof import_rxml2.RXMLCoercionError) {
+    message = `Failed to coerce arguments for streaming tool call '${currentToolCall.name}'; emitting original text.`;
+  } else if (error instanceof import_rxml2.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;
+      }
+    }
+  }
+  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+}
+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 };
+  }
+  return { buffer, shouldContinue: false };
+}
+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 };
   }
-  return { buffer, currentToolCall, shouldBreak: true };
+  return { buffer: effectiveBuffer, currentToolCall, shouldBreak: true };
 }
 function processNoToolCallInBuffer(params) {
-  const { buffer, toolNames, maxStartTagLen, controller, flushText } = params;
-  const { index: earliestStartTagIndex, name: earliestToolName } = findEarliestToolTag(buffer, toolNames);
+  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
+      };
+    }
     const startTag = `<${earliestToolName}>`;
     const newBuffer = buffer.substring(earliestStartTagIndex + startTag.length);
     return {
@@ -1444,7 +2123,7 @@ function createFlushTextHandler(getBuffer, setBuffer, getCurrentTextId, setCurre
     if (content) {
       const currentTextId2 = getCurrentTextId();
       if (!currentTextId2) {
-        const newId = (0, import_provider_utils3.generateId)();
+        const newId = (0, import_provider_utils2.generateId)();
         setCurrentTextId(newId);
         controller.enqueue({ type: "text-start", id: newId });
       }
@@ -1472,7 +2151,9 @@ function processBufferWithToolCall(params, controller) {
     setCurrentToolCall,
     tools,
     options,
-    flushText
+    flushText,
+    pipelineConfig,
+    maxReparses
   } = params;
   const currentToolCall = getCurrentToolCall();
   if (!currentToolCall) {
@@ -1485,7 +2166,9 @@ function processBufferWithToolCall(params, controller) {
     options,
     controller,
     flushText,
-    setBuffer
+    setBuffer,
+    pipelineConfig,
+    maxReparses
   });
   setBuffer(result.buffer);
   setCurrentToolCall(result.currentToolCall);
@@ -1496,16 +2179,24 @@ function processBufferWithoutToolCall(params, controller) {
     getBuffer,
     setBuffer,
     setCurrentToolCall,
+    tools,
+    options,
     toolNames,
     maxStartTagLen,
-    flushText
+    flushText,
+    pipelineConfig,
+    maxReparses
   } = params;
   const result = processNoToolCallInBuffer({
     buffer: getBuffer(),
     toolNames,
     maxStartTagLen,
     controller,
-    flushText
+    flushText,
+    tools,
+    options,
+    pipelineConfig,
+    maxReparses
   });
   setBuffer(result.buffer);
   setCurrentToolCall(result.currentToolCall);
@@ -1525,196 +2216,427 @@ function processBufferLoop(params, controller) {
     } else {
       const { shouldBreak, shouldContinue } = processBufferWithoutToolCall(
         params,
-        controller
-      );
-      if (shouldContinue) {
-        continue;
-      }
-      if (shouldBreak) {
-        break;
-      }
-    }
-  }
-}
-function createProcessBufferHandler(params) {
-  return (controller) => {
-    processBufferLoop(params, controller);
-  };
-}
-var morphXmlProtocol = () => ({
-  formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      parameters: (0, import_rxml.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;
-    }
-    return (0, import_rxml.stringify)(toolCall.toolName, args, {
-      suppressEmptyNode: false,
-      format: false
-    });
-  },
-  formatToolResponse(toolResult) {
-    return (0, import_rxml.stringify)("tool_response", {
-      tool_name: toolResult.toolName,
-      result: toolResult.output
-    });
-  },
-  parseGeneratedText({ text, tools, options }) {
-    const toolNames = tools.map((t) => t.name).filter((name) => name != null);
-    if (toolNames.length === 0) {
-      return [{ type: "text", text }];
-    }
-    const processedElements = [];
-    let currentIndex = 0;
-    const toolCalls = findToolCalls(text, toolNames);
-    for (const toolCall of toolCalls) {
-      currentIndex = processTextBeforeToolCall(
-        text,
-        currentIndex,
-        toolCall.startIndex,
-        processedElements
-      );
-      processToolCall({ toolCall, tools, options, text, processedElements });
-      currentIndex = toolCall.endIndex;
-    }
-    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;
-    let buffer = "";
-    let currentToolCall = null;
-    let currentTextId = null;
-    const flushText = createFlushTextHandler(
-      () => buffer,
-      (newBuffer) => {
-        buffer = newBuffer;
-      },
-      () => currentTextId,
-      (newId) => {
-        currentTextId = newId;
+        controller
+      );
+      if (shouldContinue) {
+        continue;
       }
-    );
-    const processChunk = (chunk, controller) => {
-      if (chunk.type !== "text-delta") {
-        if (buffer) {
-          flushText(controller);
-        }
-        controller.enqueue(chunk);
-        return;
+      if (shouldBreak) {
+        break;
       }
-      buffer += chunk.delta;
-      processBuffer(controller);
+    }
+  }
+}
+function createProcessBufferHandler(params) {
+  return (controller) => {
+    processBufferLoop(params, controller);
+  };
+}
+function buildPipelineOptions(protocolOptions) {
+  var _a, _b, _c;
+  const maxReparses = protocolOptions == null ? void 0 : protocolOptions.maxReparses;
+  if (protocolOptions == null ? void 0 : protocolOptions.pipeline) {
+    return {
+      pipelineConfig: mergePipelineConfigs2(
+        defaultPipelineConfig2,
+        protocolOptions.pipeline
+      ),
+      maxReparses
     };
-    const processBuffer = createProcessBufferHandler({
-      getBuffer: () => buffer,
-      setBuffer: (newBuffer) => {
-        buffer = newBuffer;
-      },
-      getCurrentToolCall: () => currentToolCall,
-      setCurrentToolCall: (newToolCall) => {
-        currentToolCall = newToolCall;
+  }
+  if (protocolOptions == null ? void 0 : protocolOptions.heuristics) {
+    return {
+      pipelineConfig: {
+        ...defaultPipelineConfig2,
+        preParse: [
+          ...(_a = defaultPipelineConfig2.preParse) != null ? _a : [],
+          ...protocolOptions.heuristics.filter((h) => h.phase === "pre-parse")
+        ],
+        fallbackReparse: [
+          ...(_b = defaultPipelineConfig2.fallbackReparse) != null ? _b : [],
+          ...protocolOptions.heuristics.filter(
+            (h) => h.phase === "fallback-reparse"
+          )
+        ],
+        postParse: [
+          ...(_c = defaultPipelineConfig2.postParse) != null ? _c : [],
+          ...protocolOptions.heuristics.filter((h) => h.phase === "post-parse")
+        ]
       },
-      tools,
-      options,
-      toolNames,
-      maxStartTagLen,
-      flushText
-    });
-    const flushBuffer2 = (controller) => {
-      if (currentToolCall) {
-        const unfinishedCall = `<${currentToolCall.name}>${buffer}`;
-        flushText(controller, unfinishedCall);
-      } else if (buffer) {
-        flushText(controller);
+      maxReparses
+    };
+  }
+  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: (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;
       }
-      if (currentTextId) {
-        controller.enqueue({ type: "text-end", id: currentTextId });
+      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
+        suppressEmptyNode: false,
+        format: false
+      });
+    },
+    formatToolResponse(toolResult) {
+      return (0, import_rxml2.stringify)("tool_response", {
+        tool_name: toolResult.toolName,
+        result: toolResult.output
+      });
+    },
+    parseGeneratedText({ text, tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter((name) => name != null);
+      if (toolNames.length === 0) {
+        return [{ type: "text", text }];
       }
-    };
-    return new TransformStream({
-      transform(chunk, controller) {
-        processChunk(chunk, controller);
-      },
-      flush(controller) {
-        flushBuffer2(controller);
+      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
+          });
+        }
+        currentIndex = toolCall.endIndex;
       }
-    });
-  },
-  extractToolCallSegments({ text, tools }) {
-    const toolNames = tools.map((t) => t.name).filter(Boolean);
-    if (toolNames.length === 0) {
-      return [];
+      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;
+      let buffer = "";
+      let currentToolCall = null;
+      let currentTextId = null;
+      const flushText = createFlushTextHandler(
+        () => buffer,
+        (newBuffer) => {
+          buffer = newBuffer;
+        },
+        () => currentTextId,
+        (newId) => {
+          currentTextId = newId;
+        }
+      );
+      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) => {
+          buffer = newBuffer;
+        },
+        getCurrentToolCall: () => currentToolCall,
+        setCurrentToolCall: (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);
+        },
+        flush(controller) {
+          flushBuffer2(controller);
+        }
+      });
+    },
+    extractToolCallSegments({ text, tools }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [];
+      }
+      return findToolCalls(text, toolNames).map((tc) => tc.segment);
     }
-    return findToolCalls(text, toolNames).map((tc) => tc.segment);
-  }
-});
+  };
+};
 function getToolSchema(tools, toolName) {
   var _a;
   return (_a = tools.find((t) => t.name === toolName)) == null ? void 0 : _a.inputSchema;
 }
-function computeFullTagEnd(text, contentEnd, toolName) {
-  let fullTagEnd = contentEnd + `</${toolName}>`.length;
-  const closeHead = text.indexOf(`</${toolName}`, contentEnd);
-  if (closeHead === contentEnd) {
-    let p = closeHead + 2 + toolName.length;
-    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+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;
+    }
+    const result = updateDepthWithToken(tok, toolName, depth);
+    depth = result.depth;
+    if (result.closedAt !== void 0) {
+      return result.closedAt;
+    }
+    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;
+  }
+  return gt + 1;
+}
+function consumeClosingTag(text, lt, _toolName) {
+  let p = lt + 2;
+  while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
+    p += 1;
+  }
+  const gt = text.indexOf(">", lt + 1);
+  const endPos = gt === -1 ? text.length : gt + 1;
+  return { matched: false, endPos };
+}
+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;
+  }
+  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 };
+  }
+  return { depth };
+}
+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;
     }
-    if (text[p] === ">") {
-      fullTagEnd = p + 1;
+    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 };
   }
-  return fullTagEnd;
+  return {
+    kind: "open",
+    name: open.name,
+    selfClosing: open.selfClosing,
+    nextPos: open.nextPos
+  };
 }
-function extractToolCallInfo(text, tagStart, toolName, range) {
+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;
+      }
+      const contentStartNorm = tagStartNorm + startTag.length;
+      const endNorm = findClosingTagEndFlexible(
+        normalizedText,
+        contentStartNorm,
+        toolName
+      );
+      if (endNorm > contentStartNorm) {
+        const tagStartOrig = text.indexOf(startTag, lastOrigIdx);
+        const contentStartOrig = tagStartOrig + startTag.length;
+        let endOrig = findClosingTagEndFlexible(
+          text,
+          contentStartOrig,
+          toolName
+        );
+        if (endOrig === -1) {
+          const approxLen = endNorm - tagStartNorm;
+          endOrig = Math.min(text.length, tagStartOrig + approxLen);
+        }
+        const segment = text.substring(tagStartOrig, endOrig);
+        const inner = (_a = (0, import_rxml2.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 contentStart = tagStart + startTag.length;
-  const contentEnd = contentStart + (range.end - range.start);
-  const fullTagEnd = computeFullTagEnd(text, contentEnd, toolName);
-  const segment = text.substring(tagStart, fullTagEnd);
-  const content = (_a = (0, import_rxml.extractRawInner)(segment, toolName)) != null ? _a : text.substring(contentStart, contentEnd);
-  return {
-    toolName,
-    startIndex: tagStart,
-    endIndex: fullTagEnd,
-    content,
-    segment
-  };
+  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 = [];
-  const startTag = `<${toolName}>`;
   let searchIndex = 0;
   while (searchIndex < text.length) {
-    const tagStart = text.indexOf(startTag, searchIndex);
-    if (tagStart === -1) {
+    const info = getNextTagInfo(text, toolName, searchIndex);
+    if (!info.found) {
       break;
     }
-    const remainingText = text.substring(tagStart);
-    const range = (0, import_rxml.findFirstTopLevelRange)(remainingText, toolName);
-    if (range) {
-      const toolCallInfo = extractToolCallInfo(text, tagStart, toolName, range);
-      toolCalls.push(toolCallInfo);
-      searchIndex = toolCallInfo.endIndex;
+    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 = (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 = tagStart + startTag.length;
+      searchIndex = contentStart;
     }
   }
   return toolCalls;
@@ -1728,14 +2650,53 @@ function findToolCalls(text, toolNames) {
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 
-// src/protocols/tool-call-protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/generate-handler.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_rxml3 = require("@ai-sdk-tool/rxml");
+
+// src/utils/on-error.ts
+function extractOnErrorOption(providerOptions) {
+  var _a;
+  if (providerOptions && typeof providerOptions === "object") {
+    const onError = (_a = providerOptions.toolCallMiddleware) == null ? void 0 : _a.onError;
+    return onError ? { onError } : void 0;
+  }
+  return;
+}
+
+// src/utils/provider-options.ts
+var originalToolsSchema = {
+  encode: encodeOriginalTools,
+  decode: decodeOriginalTools
+};
+function encodeOriginalTools(tools) {
+  return (tools == null ? void 0 : tools.map((t) => ({
+    name: t.name,
+    inputSchema: JSON.stringify(t.inputSchema)
+  }))) || [];
+}
+function decodeOriginalTools(originalTools) {
+  if (!originalTools) {
+    return [];
+  }
+  return originalTools.map(
+    (t) => ({
+      type: "function",
+      name: t.name,
+      inputSchema: JSON.parse(t.inputSchema)
+    })
+  );
+}
+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
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_rxml2 = require("@ai-sdk-tool/rxml");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -1779,7 +2740,7 @@ async function handleToolChoice(doGenerate, params) {
   }
   const toolCall = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils4.generateId)(),
+    toolCallId: (0, import_provider_utils3.generateId)(),
     toolName: parsed.name || "unknown",
     input: JSON.stringify(parsed.arguments || {})
   };
@@ -1898,15 +2859,20 @@ function fixToolCallWithSchema(part, tools) {
     args = tc.input;
   }
   const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml2.coerceBySchema)(args, schema);
+  const coerced = (0, import_rxml3.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
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 function extractToolCallSegments(protocol, fullRawText, tools) {
   const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({
     text: fullRawText,
@@ -1943,7 +2909,7 @@ function handleDebugSummary(parsedToolCalls, origin, params) {
 }
 function createDebugSummaryTransform({
   protocol,
-  fullRawText,
+  getFullRawText,
   tools,
   params
 }) {
@@ -1956,11 +2922,9 @@ function createDebugSummaryTransform({
         }
         if (part.type === "finish") {
           try {
-            const origin = extractToolCallSegments(
-              protocol,
-              fullRawText,
-              tools
-            );
+            const raw = getFullRawText();
+            logRawChunk(raw);
+            const origin = extractToolCallSegments(protocol, raw, tools);
             handleDebugSummary(parsedToolCalls, origin, params);
           } catch (e) {
           }
@@ -2058,7 +3022,7 @@ async function wrapStream({
   const withSummary = parsed.pipeThrough(
     createDebugSummaryTransform({
       protocol,
-      fullRawText,
+      getFullRawText: () => fullRawText,
       tools,
       params
     })
@@ -2092,19 +3056,26 @@ async function toolChoiceStream({
   }
   const toolCallChunk = {
     type: "tool-call",
-    toolCallId: (0, import_provider_utils5.generateId)(),
+    toolCallId: (0, import_provider_utils4.generateId)(),
     toolName: toolJson.name || "unknown",
     input: JSON.stringify(toolJson.arguments || {})
   };
   const finishChunk = {
     type: "finish",
-    usage: (result == null ? void 0 : result.usage) || // TODO: If possible, try to return a certain amount of LLM usage.
-    {
-      inputTokens: 0,
-      outputTokens: 0,
-      totalTokens: 0
+    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: "tool-calls"
+    finishReason: { unified: "tool-calls", raw: void 0 }
   };
   const stream = new ReadableStream({
     start(controller) {
@@ -2138,26 +3109,106 @@ async function toolChoiceStream({
   };
 }
 
+// src/utils/dynamic-tool-schema.ts
+function createDynamicIfThenElseSchema(tools) {
+  let currentSchema = {};
+  const toolNames = [];
+  for (let i = tools.length - 1; i >= 0; i -= 1) {
+    const tool = tools[i];
+    if (tool.type === "provider") {
+      throw new Error(
+        "Provider tools are not supported by this middleware. Please use function tools."
+      );
+    }
+    toolNames.unshift(tool.name);
+    const toolCondition = {
+      if: {
+        properties: {
+          name: {
+            const: tool.name
+          }
+        },
+        required: ["name"]
+      },
+      // biome-ignore lint/suspicious/noThenProperty: JSON Schema uses 'then' as a keyword
+      then: {
+        properties: {
+          name: {
+            const: tool.name
+          },
+          arguments: tool.inputSchema
+        },
+        required: ["name", "arguments"]
+      }
+    };
+    if (Object.keys(currentSchema).length > 0) {
+      toolCondition.else = currentSchema;
+    }
+    currentSchema = toolCondition;
+  }
+  return {
+    type: "object",
+    // Explicitly specify type as "object"
+    properties: {
+      name: {
+        type: "string",
+        description: "Name of the tool to call",
+        enum: toolNames
+      },
+      arguments: {
+        type: "object",
+        // By default, arguments is also specified as object type
+        description: "Argument object to be passed to the tool"
+      }
+    },
+    required: ["name", "arguments"],
+    ...currentSchema
+  };
+}
+
 // src/transform-handler.ts
-function buildFinalPrompt(systemPrompt, processedPrompt) {
-  var _a;
-  if (((_a = processedPrompt[0]) == null ? void 0 : _a.role) === "system") {
+function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
+  const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
+  if (systemIndex !== -1) {
+    const existing = processedPrompt[systemIndex].content;
+    let existingText = "";
+    if (typeof existing === "string") {
+      existingText = existing;
+    } else if (Array.isArray(existing)) {
+      existingText = existing.map((p) => {
+        var _a;
+        return (p == null ? void 0 : p.type) === "text" ? (_a = p.text) != null ? _a : "" : "";
+      }).filter(Boolean).join("\n");
+    } else {
+      existingText = String(existing != null ? existing : "");
+    }
+    const mergedContent = placement === "first" ? `${systemPrompt}
+
+${existingText}` : `${existingText}
+
+${systemPrompt}`;
+    return processedPrompt.map(
+      (m, idx) => idx === systemIndex ? {
+        ...m,
+        content: mergedContent
+      } : m
+    );
+  }
+  if (placement === "first") {
     return [
       {
         role: "system",
-        content: `${systemPrompt}
-
-${processedPrompt[0].content}`
+        content: systemPrompt
       },
-      ...processedPrompt.slice(1)
+      ...processedPrompt
     ];
   }
   return [
+    ...processedPrompt,
     {
       role: "system",
       content: systemPrompt
-    },
-    ...processedPrompt
+    }
   ];
 }
 function buildBaseReturnParams(params, finalPrompt, functionTools) {
@@ -2257,7 +3308,8 @@ function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
 function transformParams({
   params,
   protocol,
-  toolSystemPromptTemplate
+  toolSystemPromptTemplate,
+  placement = "first"
 }) {
   var _a, _b, _c, _d, _e;
   const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
@@ -2273,7 +3325,11 @@ function transformParams({
     resolvedProtocol,
     extractOnErrorOption(params.providerOptions)
   );
-  const finalPrompt = buildFinalPrompt(systemPrompt, processedPrompt);
+  const finalPrompt = buildFinalPrompt(
+    systemPrompt,
+    processedPrompt,
+    placement
+  );
   const baseReturnParams = buildBaseReturnParams(
     params,
     finalPrompt,
@@ -2350,7 +3406,10 @@ function processMessage(message, resolvedProtocol, providerOptions) {
     };
   }
   if (message.role === "tool") {
-    return processToolMessage(message.content, resolvedProtocol);
+    const toolResultParts = message.content.filter(
+      (part) => part.type === "tool-result"
+    );
+    return processToolMessage(toolResultParts, resolvedProtocol);
   }
   return message;
 }
@@ -2425,7 +3484,8 @@ function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
 // src/tool-call-middleware.ts
 function createToolMiddleware({
   protocol,
-  toolSystemPromptTemplate
+  toolSystemPromptTemplate,
+  placement = "last"
 }) {
   const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
   return {
@@ -2452,6 +3512,7 @@ function createToolMiddleware({
     transformParams: async ({ params }) => transformParams({
       protocol: resolvedProtocol,
       toolSystemPromptTemplate,
+      placement,
       params
     })
   };
@@ -2497,6 +3558,7 @@ For each function call return a json object with function name and arguments wit
 });
 var morphXmlToolMiddleware = createToolMiddleware({
   protocol: morphXmlProtocol,
+  placement: "last",
   toolSystemPromptTemplate(tools) {
     return `You are a function calling AI model.
 
@@ -2520,11 +3582,16 @@ Available functions are listed inside <tools></tools>.
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RJSON,
+  applyHeuristicPipeline,
+  balanceTagsHeuristic,
   createDynamicIfThenElseSchema,
+  createIntermediateCall,
   createToolMiddleware,
   decodeOriginalTools,
+  dedupeShellStringTagsHeuristic,
+  defaultPipelineConfig,
   encodeOriginalTools,
+  escapeInvalidLtHeuristic,
   escapeRegExp,
   extractOnErrorOption,
   extractToolNamesFromOriginalTools,
@@ -2537,13 +3604,17 @@ Available functions are listed inside <tools></tools>.
   isToolChoiceActive,
   isToolResultPart,
   jsonMixProtocol,
+  logParseFailure,
   logParsedChunk,
   logParsedSummary,
   logRawChunk,
+  mergePipelineConfigs,
   morphXmlProtocol,
   morphXmlToolMiddleware,
+  normalizeCloseTagsHeuristic,
   originalToolsSchema,
   parseRJSON,
+  repairAgainstSchemaHeuristic,
   stringifyRJSON,
   transformRJSON
 });