@ai-sdk-tool/parser 3.1.3 → 3.2.1

package/dist/community.cjs

@@ -39,17 +39,11 @@ module.exports = __toCommonJS(community_exports);
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  applyHeuristicPipeline: () => applyHeuristicPipeline,
-  balanceTagsHeuristic: () => balanceTagsHeuristic,
   createDynamicIfThenElseSchema: () => createDynamicIfThenElseSchema,
-  createIntermediateCall: () => createIntermediateCall,
   createToolMiddleware: () => createToolMiddleware,
   decodeOriginalTools: () => decodeOriginalTools,
-  dedupeShellStringTagsHeuristic: () => dedupeShellStringTagsHeuristic,
-  defaultPipelineConfig: () => defaultPipelineConfig,
   encodeOriginalTools: () => encodeOriginalTools,
-  escapeInvalidLtHeuristic: () => escapeInvalidLtHeuristic,
-  escapeRegExp: () => escapeRegExp2,
+  escapeRegExp: () => escapeRegExp,
   extractOnErrorOption: () => extractOnErrorOption,
   extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
   getDebugLevel: () => getDebugLevel,
@@ -65,10 +59,7 @@ __export(src_exports, {
   logParsedChunk: () => logParsedChunk,
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
-  mergePipelineConfigs: () => mergePipelineConfigs,
-  normalizeCloseTagsHeuristic: () => normalizeCloseTagsHeuristic,
   originalToolsSchema: () => originalToolsSchema,
-  repairAgainstSchemaHeuristic: () => repairAgainstSchemaHeuristic,
   toolChoiceStream: () => toolChoiceStream,
   transformParams: () => transformParams,
   wrapGenerate: () => wrapGenerate,
@@ -80,473 +71,6 @@ __export(src_exports, {
 });
 __reExport(src_exports, require("@ai-sdk-tool/rjson"));
 
-// src/core/heuristics/engine.ts
-function applyRawSegmentUpdate(current, result) {
-  if (result.rawSegment !== void 0) {
-    return { ...current, rawSegment: result.rawSegment };
-  }
-  return current;
-}
-function applyParsedUpdate(current, result) {
-  if (result.parsed !== void 0) {
-    return { ...current, parsed: result.parsed };
-  }
-  return current;
-}
-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 attemptReparse(current, result, reparseCount, maxReparses, parse3) {
-  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
-    return { state: current, newCount: reparseCount };
-  }
-  try {
-    const reparsed = parse3(result.rawSegment, current.schema);
-    return {
-      state: { ...current, parsed: reparsed, errors: [] },
-      newCount: reparseCount + 1
-    };
-  } catch (error) {
-    return {
-      state: { ...current, errors: [...current.errors, error] },
-      newCount: reparseCount + 1
-    };
-  }
-}
-function executePhase(ctx, heuristics, options) {
-  var _a;
-  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;
-    }
-  }
-  return current;
-}
-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] };
-    }
-  }
-  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 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 result;
-}
-
-// 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;
-var WHITESPACE_REGEX = /\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_REGEX.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_REGEX.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 extractSchemaProperties(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return void 0;
-  }
-  return unwrapped.properties;
-}
-function shouldDeduplicateStringTags(schema) {
-  const props = extractSchemaProperties(schema);
-  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 props = extractSchemaProperties(schema);
-  if (!props) {
-    return [];
-  }
-  const names = [];
-  for (const key of Object.keys(props)) {
-    const prop = (0, import_rxml.unwrapJsonSchema)(props[key]);
-    if ((prop == null ? void 0 : prop.type) === "string") {
-      names.push(key);
-    }
-  }
-  return names;
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function dedupeSingleTag(xml, key) {
-  var _a, _b;
-  const escaped = escapeRegExp(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 properties = extractSchemaProperties(schema);
-  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);
-    if ((prop == null ? void 0 : prop.type) === "array" && prop.items) {
-      const itemSchema = (0, import_rxml.unwrapJsonSchema)(prop.items);
-      obj[key] = coerceArrayItems(obj[key], itemSchema);
-      continue;
-    }
-    if ((prop == null ? void 0 : prop.type) === "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/core/protocols/json-protocol.ts
 var import_rjson = require("@ai-sdk-tool/rjson");
 
@@ -729,7 +253,7 @@ function generateId() {
 }
 
 // src/core/utils/regex.ts
-function escapeRegExp2(literal) {
+function escapeRegExp(literal) {
   return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -976,8 +500,8 @@ var jsonProtocol = ({
     text,
     options
   }) {
-    const startEsc = escapeRegExp2(toolCallStart);
-    const endEsc = escapeRegExp2(toolCallEnd);
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
     const toolCallRegex = new RegExp(
       `${startEsc}([\0-\uFFFF]*?)${endEsc}`,
       "gs"
@@ -1036,8 +560,8 @@ var jsonProtocol = ({
     });
   },
   extractToolCallSegments({ text }) {
-    const startEsc = escapeRegExp2(toolCallStart);
-    const endEsc = escapeRegExp2(toolCallEnd);
+    const startEsc = escapeRegExp(toolCallStart);
+    const endEsc = escapeRegExp(toolCallEnd);
     const regex = new RegExp(`${startEsc}([\0-\uFFFF]*?)${endEsc}`, "gs");
     const segments = [];
     let m = regex.exec(text);
@@ -1058,93 +582,44 @@ function isTCMProtocolFactory(protocol) {
 }
 
 // src/core/protocols/xml-protocol.ts
-var import_rxml2 = require("@ai-sdk-tool/rxml");
-var defaultPipelineConfig2 = defaultPipelineConfig;
-var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX2 = /\s/;
+var import_rxml = require("@ai-sdk-tool/rxml");
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX = /\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(/<\/\s+([A-Za-z0-9_:-]+)\s*>/g, "</$1>");
-}
-function tryParseSecondaryXml(content, toolSchema, options) {
-  const balanced = balanceTags(content);
-  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 names = getStringPropertyNames(toolSchema);
-      let deduped = balanced;
-      for (const key of names) {
-        deduped = dedupeSingleTag(deduped, key);
-      }
-      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 processToolCallWithPipeline(params) {
-  var _a;
-  const {
-    toolCall,
-    tools,
-    options,
-    text,
-    processedElements,
-    pipelineConfig = defaultPipelineConfig2,
-    maxReparses
-  } = params;
+function processToolCall(params) {
+  var _a, _b;
+  const { toolCall, tools, options, text, processedElements, parseOptions } = params;
   const toolSchema = getToolSchema(tools, toolCall.toolName);
-  const ctx = createIntermediateCall(
-    toolCall.toolName,
-    toolCall.content,
-    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
-  });
-  if (result.parsed !== null) {
+  const parseConfig = {
+    ...parseOptions != null ? parseOptions : {},
+    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
+  };
+  try {
+    const parsed = (0, import_rxml.parse)(toolCall.content, toolSchema, parseConfig);
     processedElements.push({
       type: "tool-call",
       toolCallId: generateId(),
       toolName: toolCall.toolName,
-      input: JSON.stringify(result.parsed)
+      input: JSON.stringify(parsed)
     });
-  } else {
+  } catch (error) {
     const originalCallText = text.substring(
       toolCall.startIndex,
       toolCall.endIndex
     );
-    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
       options,
       `Could not process XML tool call: ${toolCall.toolName}`,
-      { toolCall: originalCallText, error: result.errors[0] }
+      { toolCall: originalCallText, error }
     );
     processedElements.push({ type: "text", text: originalCallText });
   }
 }
 function handleStreamingToolCallEnd(params) {
-  var _a;
+  var _a, _b;
   const {
     toolContent,
     currentToolCall,
@@ -1152,51 +627,27 @@ function handleStreamingToolCallEnd(params) {
     options,
     ctrl,
     flushText,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   } = params;
   const toolSchema = getToolSchema(tools, currentToolCall.name);
-  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 : {}
-      );
-    }
-  }
+  const parseConfig = {
+    ...parseOptions != null ? parseOptions : {},
+    onError: (_a = options == null ? void 0 : options.onError) != null ? _a : parseOptions == null ? void 0 : parseOptions.onError
+  };
   flushText(ctrl);
-  if (parsedResult !== null) {
+  try {
+    const parsedResult = (0, import_rxml.parse)(toolContent, toolSchema, parseConfig);
     ctrl.enqueue({
       type: "tool-call",
       toolCallId: generateId(),
       toolName: currentToolCall.name,
       input: JSON.stringify(parsedResult)
     });
-  } else {
+  } catch (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
+    (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "Could not process streaming XML tool call", {
+      toolCall: original,
+      error
     });
     flushText(ctrl, original);
   }
@@ -1235,11 +686,11 @@ function consumeClosingTag(text, lt) {
 }
 function consumeOpenTag(text, lt) {
   let p = lt + 1;
-  while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+  while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
     p += 1;
   }
   const nameStart = p;
-  while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+  while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
     p += 1;
   }
   const name = text.slice(nameStart, p);
@@ -1248,7 +699,7 @@ function consumeOpenTag(text, lt) {
     return null;
   }
   let r = q - 1;
-  while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
+  while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
     r -= 1;
   }
   const selfClosing = text[r] === "/";
@@ -1277,11 +728,11 @@ function nextTagToken(text, fromPos) {
   if (next === "/") {
     const closing = consumeClosingTag(text, lt);
     let p = lt + 2;
-    while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
+    while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
       p += 1;
     }
     const nameStart = p;
-    while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
+    while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
       p += 1;
     }
     const name = text.slice(nameStart, p);
@@ -1298,49 +749,111 @@ function nextTagToken(text, fromPos) {
     nextPos: open.nextPos
   };
 }
+function findNextToolTag(text, searchIndex, toolName) {
+  var _a, _b;
+  const startTag = `<${toolName}>`;
+  const openIdx = text.indexOf(startTag, searchIndex);
+  const selfMatch = findSelfClosingTag(text, toolName, searchIndex);
+  const selfIdx = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -1;
+  if (openIdx === -1 && selfIdx === -1) {
+    return null;
+  }
+  const isSelfClosing = selfIdx !== -1 && (openIdx === -1 || selfIdx < openIdx);
+  return {
+    tagStart: isSelfClosing ? selfIdx : openIdx,
+    isSelfClosing,
+    tagLength: isSelfClosing ? (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0 : startTag.length
+  };
+}
+function findLastCloseTagStart(segment, toolName) {
+  const closeTagPattern = new RegExp(
+    `</\\s*${escapeRegExp(toolName)}\\s*>`,
+    "g"
+  );
+  let closeTagStart = -1;
+  let match = closeTagPattern.exec(segment);
+  while (match !== null) {
+    closeTagStart = match.index;
+    match = closeTagPattern.exec(segment);
+  }
+  if (closeTagStart === -1) {
+    return segment.lastIndexOf("<");
+  }
+  return closeTagStart;
+}
+function pushSelfClosingToolCall(toolCalls, toolName, text, tagStart, tagLength) {
+  const endIndex = tagStart + tagLength;
+  toolCalls.push({
+    toolName,
+    startIndex: tagStart,
+    endIndex,
+    content: "",
+    segment: text.substring(tagStart, endIndex)
+  });
+  return endIndex;
+}
+var selfClosingTagCache = /* @__PURE__ */ new Map();
+function getSelfClosingTagPattern(toolName) {
+  let pattern = selfClosingTagCache.get(toolName);
+  if (!pattern) {
+    pattern = new RegExp(`<\\s*${escapeRegExp(toolName)}\\s*/>`, "g");
+    selfClosingTagCache.set(toolName, pattern);
+  }
+  return pattern;
+}
+function findSelfClosingTag(text, toolName, fromIndex) {
+  const pattern = getSelfClosingTagPattern(toolName);
+  pattern.lastIndex = fromIndex;
+  const match = pattern.exec(text);
+  if (!match || match.index === void 0) {
+    return null;
+  }
+  return { index: match.index, length: match[0].length };
+}
+function appendOpenToolCallIfComplete(toolCalls, text, toolName, tagStart, startTag) {
+  const contentStart = tagStart + startTag.length;
+  const fullTagEnd = findClosingTagEndFlexible(text, contentStart, toolName);
+  if (fullTagEnd === -1 || fullTagEnd <= contentStart) {
+    return contentStart;
+  }
+  const segment = text.substring(tagStart, fullTagEnd);
+  const closeTagStart = findLastCloseTagStart(segment, toolName);
+  const inner = closeTagStart === -1 ? segment.slice(startTag.length) : segment.slice(startTag.length, closeTagStart);
+  toolCalls.push({
+    toolName,
+    startIndex: tagStart,
+    endIndex: fullTagEnd,
+    content: inner,
+    segment
+  });
+  return fullTagEnd;
+}
 function findToolCallsForName(text, toolName) {
-  var _a;
   const toolCalls = [];
+  const startTag = `<${toolName}>`;
   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) {
+    const match = findNextToolTag(text, searchIndex, toolName);
+    if (match === null) {
       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({
+    if (match.isSelfClosing) {
+      searchIndex = pushSelfClosingToolCall(
+        toolCalls,
         toolName,
-        startIndex: tagStart,
-        endIndex,
-        content: "",
-        segment
-      });
-      searchIndex = endIndex;
+        text,
+        match.tagStart,
+        match.tagLength
+      );
       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;
-    }
+    searchIndex = appendOpenToolCallIfComplete(
+      toolCalls,
+      text,
+      toolName,
+      match.tagStart,
+      startTag
+    );
   }
   return toolCalls;
 }
@@ -1353,28 +866,114 @@ function findToolCalls(text, toolNames) {
   return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
 }
 function findEarliestToolTag(buffer, toolNames) {
+  var _a, _b;
   let bestIndex = -1;
   let bestName = "";
   let bestSelfClosing = false;
+  let bestTagLength = 0;
   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);
+      const selfMatch = findSelfClosingTag(buffer, name, 0);
+      const idxSelf = (_a = selfMatch == null ? void 0 : selfMatch.index) != null ? _a : -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 = (_b = selfMatch == null ? void 0 : selfMatch.length) != null ? _b : 0;
       }
     }
   }
-  return { index: bestIndex, name: bestName, selfClosing: bestSelfClosing };
+  return {
+    index: bestIndex,
+    name: bestName,
+    selfClosing: bestSelfClosing,
+    tagLength: bestTagLength
+  };
+}
+function isOpenTagPrefix(suffix, toolName) {
+  return `${toolName}>`.startsWith(suffix);
+}
+function consumeWhitespace(text, index) {
+  let i = index;
+  while (i < text.length && WHITESPACE_REGEX.test(text.charAt(i))) {
+    i += 1;
+  }
+  return i;
+}
+function consumeToolNamePrefix(text, index, toolName) {
+  let i = index;
+  let nameIndex = 0;
+  while (i < text.length && nameIndex < toolName.length) {
+    if (text.charAt(i) !== toolName.charAt(nameIndex)) {
+      return { index: i, done: false, valid: false };
+    }
+    i += 1;
+    nameIndex += 1;
+  }
+  return { index: i, done: nameIndex === toolName.length, valid: true };
+}
+function isSelfClosingSuffixRemainder(text, index) {
+  if (text.charAt(index) !== "/") {
+    return false;
+  }
+  if (index + 1 >= text.length) {
+    return true;
+  }
+  return index + 1 === text.length - 1 && text.charAt(index + 1) === ">";
+}
+function isSelfClosingTagPrefix(suffix, toolName) {
+  let i = consumeWhitespace(suffix, 0);
+  if (i >= suffix.length) {
+    return true;
+  }
+  const nameRemainder = suffix.slice(i);
+  if (toolName.startsWith(nameRemainder)) {
+    return true;
+  }
+  const nameResult = consumeToolNamePrefix(suffix, i, toolName);
+  if (!nameResult.valid) {
+    return false;
+  }
+  i = nameResult.index;
+  if (i >= suffix.length) {
+    return true;
+  }
+  if (!nameResult.done) {
+    return false;
+  }
+  i = consumeWhitespace(suffix, i);
+  if (i >= suffix.length) {
+    return true;
+  }
+  return isSelfClosingSuffixRemainder(suffix, i);
+}
+function findPotentialToolTagStart(buffer, toolNames) {
+  if (toolNames.length === 0 || buffer.length === 0) {
+    return -1;
+  }
+  const lastGt = buffer.lastIndexOf(">");
+  const offset = lastGt === -1 ? 0 : lastGt + 1;
+  const trailing = buffer.slice(offset);
+  for (let i = trailing.length - 1; i >= 0; i -= 1) {
+    if (trailing.charAt(i) !== "<") {
+      continue;
+    }
+    const suffix = trailing.slice(i + 1);
+    for (const name of toolNames) {
+      if (isOpenTagPrefix(suffix, name) || isSelfClosingTagPrefix(suffix, name)) {
+        return offset + i;
+      }
+    }
+  }
+  return -1;
 }
 function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
   return (controller, text) => {
@@ -1417,16 +1016,20 @@ function processToolCallInBuffer(params) {
     controller,
     flushText,
     setBuffer,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   } = params;
-  const endTag = `</${currentToolCall.name}>`;
-  const endIdx = buffer.indexOf(endTag);
-  if (endIdx === -1) {
+  const endTagPattern = new RegExp(
+    `</\\s*${escapeRegExp(currentToolCall.name)}\\s*>`
+  );
+  const endMatch = endTagPattern.exec(buffer);
+  if (!endMatch || endMatch.index === void 0) {
     return { buffer, currentToolCall, shouldBreak: true };
   }
+  const endIdx = endMatch.index;
+  const endPos = endIdx + endMatch[0].length;
   const content = buffer.substring(0, endIdx);
-  setBuffer(buffer.substring(endIdx + endTag.length));
+  const remainder = buffer.substring(endPos);
+  setBuffer(remainder);
   handleStreamingToolCallEnd({
     toolContent: content,
     currentToolCall,
@@ -1434,11 +1037,10 @@ function processToolCallInBuffer(params) {
     options,
     ctrl: controller,
     flushText,
-    pipelineConfig,
-    maxReparses
+    parseOptions
   });
   return {
-    buffer: buffer.substring(endIdx + endTag.length),
+    buffer: remainder,
     currentToolCall: null,
     shouldBreak: false
   };
@@ -1451,25 +1053,28 @@ function processNoToolCallInBuffer(params) {
     flushText,
     tools,
     options,
-    pipelineConfig,
-    maxReparses,
+    parseOptions,
     setBuffer
   } = params;
   const {
     index: earliestStartTagIndex,
     name: earliestToolName,
-    selfClosing
+    selfClosing,
+    tagLength
   } = 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);
+    const potentialStart = findPotentialToolTagStart(buffer, toolNames);
+    const safeLen = Math.max(
+      0,
+      potentialStart === -1 ? buffer.length : potentialStart
+    );
+    const remaining = buffer.slice(safeLen);
     if (safeLen > 0) {
       flushText(controller, buffer.slice(0, safeLen));
-      setBuffer(buffer.slice(safeLen));
+      setBuffer(remaining);
     }
     return {
-      buffer: buffer.slice(safeLen),
+      buffer: remaining,
       currentToolCall: null,
       shouldBreak: true,
       shouldContinue: false
@@ -1477,8 +1082,7 @@ function processNoToolCallInBuffer(params) {
   }
   flushText(controller, buffer.substring(0, earliestStartTagIndex));
   if (selfClosing) {
-    const selfTag = `<${earliestToolName}/>`;
-    const newBuffer2 = buffer.substring(earliestStartTagIndex + selfTag.length);
+    const newBuffer2 = buffer.substring(earliestStartTagIndex + tagLength);
     setBuffer(newBuffer2);
     handleStreamingToolCallEnd({
       toolContent: "",
@@ -1487,8 +1091,7 @@ function processNoToolCallInBuffer(params) {
       options,
       ctrl: controller,
       flushText,
-      pipelineConfig,
-      maxReparses
+      parseOptions
     });
     return {
       buffer: newBuffer2,
@@ -1507,7 +1110,7 @@ function processNoToolCallInBuffer(params) {
     shouldContinue: true
   };
 }
-function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, pipelineConfig, maxReparses) {
+function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, setCurrentToolCall, tools, options, toolNames, flushText, parseOptions) {
   return (controller) => {
     while (true) {
       const currentToolCall = getCurrentToolCall();
@@ -1520,8 +1123,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           controller,
           flushText,
           setBuffer,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         setBuffer(result.buffer);
         setCurrentToolCall(result.currentToolCall);
@@ -1536,8 +1138,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
           flushText,
           tools,
           options,
-          pipelineConfig,
-          maxReparses,
+          parseOptions,
           setBuffer
         });
         setBuffer(result.buffer);
@@ -1554,43 +1155,12 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
   };
 }
 var xmlProtocol = (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.heuristics) && protocolOptions.heuristics.length > 0) {
-    const heuristicsConfig = {
-      preParse: [],
-      fallbackReparse: [],
-      postParse: []
-    };
-    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: [
-          ...(_d = pipelineConfig.preParse) != null ? _d : [],
-          ...(_e = heuristicsConfig.preParse) != null ? _e : []
-        ],
-        fallbackReparse: [
-          ...(_f = pipelineConfig.fallbackReparse) != null ? _f : [],
-          ...(_g = heuristicsConfig.fallbackReparse) != null ? _g : []
-        ],
-        postParse: [
-          ...(_h = pipelineConfig.postParse) != null ? _h : [],
-          ...(_i = heuristicsConfig.postParse) != null ? _i : []
-        ]
-      };
-    } else {
-      pipelineConfig = heuristicsConfig;
-    }
-  }
+  var _a;
+  const parseOptions = {
+    repair: true,
+    noChildNodes: [],
+    ...(_a = protocolOptions == null ? void 0 : protocolOptions.parseOptions) != null ? _a : {}
+  };
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
       return toolSystemPromptTemplate(tools || []);
@@ -1604,7 +1174,7 @@ var xmlProtocol = (protocolOptions) => {
           args = toolCall.input;
         }
       }
-      return (0, import_rxml2.stringify)(toolCall.toolName, args, {
+      return (0, import_rxml.stringify)(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: true,
         minimalEscaping: true
@@ -1625,14 +1195,13 @@ var xmlProtocol = (protocolOptions) => {
             text: text.substring(currentIndex, tc.startIndex)
           });
         }
-        processToolCallWithPipeline({
+        processToolCall({
           toolCall: tc,
           tools,
           options,
           text,
           processedElements,
-          pipelineConfig,
-          maxReparses
+          parseOptions
         });
         currentIndex = tc.endIndex;
       }
@@ -1673,8 +1242,7 @@ var xmlProtocol = (protocolOptions) => {
         options,
         toolNames,
         flushText,
-        pipelineConfig,
-        maxReparses
+        parseOptions
       );
       return new TransformStream({
         transform(chunk, controller) {
@@ -1724,8 +1292,8 @@ var xmlProtocol = (protocolOptions) => {
 
 // src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
-var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
-var WHITESPACE_REGEX3 = /\s/;
+var NAME_CHAR_RE2 = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX2 = /\s/;
 var LEADING_WHITESPACE_RE = /^(\s*)/;
 function findClosingTagEnd(text, contentStart, toolName) {
   let pos = contentStart;
@@ -1742,11 +1310,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let p = ltIdx + 2;
-      while (p < gtIdx && WHITESPACE_REGEX3.test(text[p])) {
+      while (p < gtIdx && WHITESPACE_REGEX2.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < gtIdx && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < gtIdx && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1762,11 +1330,11 @@ function findClosingTagEnd(text, contentStart, toolName) {
       pos = gtIdx === -1 ? text.length : gtIdx + 1;
     } else {
       let p = ltIdx + 1;
-      while (p < text.length && WHITESPACE_REGEX3.test(text[p])) {
+      while (p < text.length && WHITESPACE_REGEX2.test(text[p])) {
         p++;
       }
       const nameStart = p;
-      while (p < text.length && NAME_CHAR_RE3.test(text.charAt(p))) {
+      while (p < text.length && NAME_CHAR_RE2.test(text.charAt(p))) {
         p++;
       }
       const name = text.slice(nameStart, p);
@@ -1775,7 +1343,7 @@ function findClosingTagEnd(text, contentStart, toolName) {
         break;
       }
       let r = gtIdx - 1;
-      while (r >= nameStart && WHITESPACE_REGEX3.test(text[r])) {
+      while (r >= nameStart && WHITESPACE_REGEX2.test(text[r])) {
         r--;
       }
       const selfClosing = text[r] === "/";
@@ -2280,7 +1848,7 @@ function hasInputProperty(obj) {
 
 // src/generate-handler.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_rxml3 = require("@ai-sdk-tool/rxml");
+var import_schema_coerce = require("@ai-sdk-tool/schema-coerce");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -2442,7 +2010,7 @@ function fixToolCallWithSchema(part, tools) {
     args = part.input;
   }
   const schema = (_a = tools.find((t) => t.name === part.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml3.coerceBySchema)(args, schema);
+  const coerced = (0, import_schema_coerce.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
@@ -2575,29 +2143,230 @@ function formatXmlNode(tagName, value, depth) {
 }
 
 // src/core/prompts/xml-system-prompt.ts
+var import_dedent = __toESM(require("dedent"), 1);
 function xmlSystemPromptTemplate(tools) {
-  const toolsJson = JSON.stringify(tools);
-  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>${toolsJson}</tools>
-
-# Rules
-- Use exactly one XML element whose tag name is the function name.
-- Put each parameter as a child element.
-- Values must follow the schema exactly (numbers, arrays, objects, enums \u2192 copy as-is).
-- 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>
-  <location>New York</location>
-  <unit>celsius</unit>
-</get_weather>`;
+  const toolsText = renderToolsForXmlPrompt(tools);
+  const header = import_dedent.default`
+    # Tools
+    You may call one or more functions to assist with the user query.
+  `;
+  const definitions = [
+    "You have access to the following functions:",
+    "<tools>",
+    toolsText,
+    "</tools>"
+  ].join("\n");
+  const rules = import_dedent.default`
+    <rules>
+    - Use exactly one XML element whose tag name is the function name.
+    - Put each parameter as a child element.
+    - Values must follow the schema exactly (numbers, arrays, objects, enums → copy as-is).
+    - Do not add or remove functions or parameters.
+    - Each required parameter must appear once.
+    - Output nothing before or after the function call.
+    - It is also possible to call multiple types of functions in one turn or to call a single function multiple times.
+    </rules>
+  `;
+  const examples = import_dedent.default`
+    For each function call, output the function name and parameter in the following format:
+    <example_function_name>
+      <example_parameter_1>value_1</example_parameter_1>
+      <example_parameter_2>This is the value for the second parameter
+    that can span
+    multiple lines</example_parameter_2>
+    </example_function_name>
+  `;
+  return [header, definitions, rules, examples].join("\n\n");
+}
+var INDENT = "  ";
+function renderToolsForXmlPrompt(tools) {
+  if (!tools.length) {
+    return "none";
+  }
+  return tools.map(renderToolForXmlPrompt).join("\n\n");
+}
+function renderToolForXmlPrompt(tool) {
+  const lines = [`name: ${tool.name}`];
+  if (tool.description) {
+    lines.push(`description: ${tool.description}`);
+  }
+  lines.push("parameters:");
+  const normalizedSchema = normalizeSchema(tool.inputSchema);
+  lines.push(...renderParametersSummary(normalizedSchema, 1));
+  lines.push(`schema: ${stringifySchema(normalizedSchema)}`);
+  return lines.join("\n");
+}
+function normalizeSchema(schema) {
+  if (typeof schema === "string") {
+    try {
+      return JSON.parse(schema);
+    } catch (e) {
+      return { type: "string", const: schema };
+    }
+  }
+  return schema;
+}
+function renderParametersSummary(schema, indentLevel) {
+  var _a, _b;
+  const indent = INDENT.repeat(indentLevel);
+  if (schema === void 0 || schema === null) {
+    return [`${indent}(none)`];
+  }
+  if (schema === true) {
+    return [`${indent}(any)`];
+  }
+  if (schema === false) {
+    return [`${indent}(no valid parameters)`];
+  }
+  if (typeof schema !== "object") {
+    return [`${indent}- value (${String(schema)})`];
+  }
+  const schemaType = [];
+  if (Array.isArray(schema.type)) {
+    schemaType.push(...schema.type);
+  } else if (schema.type) {
+    schemaType.push(schema.type);
+  }
+  const isObjectLike = schemaType.includes("object") || !!schema.properties;
+  if (isObjectLike) {
+    const properties = (_a = schema.properties) != null ? _a : {};
+    const requiredSet = new Set((_b = schema.required) != null ? _b : []);
+    const propertyNames = Object.keys(properties).sort();
+    if (propertyNames.length === 0) {
+      return [`${indent}(no named parameters)`];
+    }
+    const lines = [];
+    for (const propName of propertyNames) {
+      const propSchema = properties[propName];
+      lines.push(
+        renderPropertySummaryLine({
+          indent,
+          propName,
+          propSchema,
+          required: requiredSet.has(propName)
+        })
+      );
+    }
+    return lines.length ? lines : [`${indent}(no parameters)`];
+  }
+  return [`${indent}- value (${summarizeType(schema)})`];
+}
+function renderPropertySummaryLine({
+  indent,
+  propName,
+  propSchema,
+  required
+}) {
+  const typeLabel = summarizeType(propSchema);
+  const requiredLabel = required ? "required" : "optional";
+  const extras = collectPropertyExtras(propSchema);
+  const extraText = extras.length ? ` - ${extras.join("; ")}` : "";
+  return `${indent}- ${propName} (${typeLabel}, ${requiredLabel})${extraText}`;
+}
+function collectPropertyExtras(propSchema) {
+  if (!propSchema || typeof propSchema !== "object") {
+    return [];
+  }
+  const extras = [];
+  if (propSchema.enum) {
+    extras.push(`enum: ${formatEnumForSummary(propSchema.enum)}`);
+  }
+  if (propSchema.default !== void 0) {
+    extras.push(`default: ${formatValue(propSchema.default)}`);
+  }
+  if (propSchema.description) {
+    extras.push(propSchema.description);
+  }
+  return extras;
+}
+function summarizeType(schema) {
+  var _a;
+  if (schema === void 0 || schema === null) {
+    return "unknown";
+  }
+  if (schema === true) {
+    return "any";
+  }
+  if (schema === false) {
+    return "never";
+  }
+  if (typeof schema !== "object") {
+    return String(schema);
+  }
+  const schemaType = schema.type;
+  let baseType = "";
+  if (Array.isArray(schemaType) && schemaType.length) {
+    baseType = schemaType.join(" | ");
+  } else if (typeof schemaType === "string") {
+    baseType = schemaType;
+  } else if (schema.enum) {
+    const inferred = Array.from(
+      new Set(schema.enum.map((value) => typeof value))
+    );
+    if (inferred.length === 1) {
+      baseType = (_a = inferred[0]) != null ? _a : "";
+    }
+  } else if (schema.const !== void 0) {
+    baseType = typeof schema.const;
+  }
+  if (!baseType) {
+    baseType = "any";
+  }
+  if (baseType === "array" && schema.items) {
+    const itemType = Array.isArray(schema.items) ? schema.items.map((item) => summarizeType(item)).join(" | ") : summarizeType(schema.items);
+    return `array<${itemType}>`;
+  }
+  if (baseType === "string" && schema.format) {
+    return `string (${schema.format})`;
+  }
+  return baseType;
+}
+var ENUM_MAX_INLINE = 6;
+var ENUM_PREVIEW_LIMIT = 5;
+function formatEnumForSummary(values) {
+  if (values.length <= ENUM_MAX_INLINE) {
+    return formatValue(values);
+  }
+  const preview = values.slice(0, ENUM_PREVIEW_LIMIT).map((value) => formatValue(value));
+  return `[${preview.join(", ")}, ... (${values.length} total)]`;
+}
+function formatValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(formatValue).join(", ")}]`;
+  }
+  return JSON.stringify(value);
+}
+function stringifySchema(schema) {
+  if (schema === void 0) {
+    return "null";
+  }
+  return JSON.stringify(stripSchemaKeys(schema));
+}
+function stripSchemaKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stripSchemaKeys(entry));
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    const cleaned = {};
+    for (const [key, entry] of Object.entries(record)) {
+      if (key === "$schema") {
+        continue;
+      }
+      cleaned[key] = stripSchemaKeys(entry);
+    }
+    return cleaned;
+  }
+  return value;
 }
 
 // src/core/prompts/yaml-system-prompt.ts
@@ -3106,20 +2875,12 @@ function createToolMiddleware({
   const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   return {
     specificationVersion: "v3",
-    wrapStream: ({ doStream, doGenerate, params }) => {
-      if (isToolChoiceActive(params)) {
-        return toolChoiceStream({
-          doGenerate,
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      }
-      return wrapStream({
-        protocol: resolvedProtocol,
-        doStream,
-        doGenerate,
-        params
-      });
-    },
+    wrapStream: ({ doStream, doGenerate, params }) => wrapStream({
+      protocol: resolvedProtocol,
+      doStream,
+      doGenerate,
+      params
+    }),
     wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
       protocol: resolvedProtocol,
       doGenerate,