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

package/dist/chunk-QPJA5CS6.js

@@ -0,0 +1,1289 @@
+import {
+  createDynamicIfThenElseSchema,
+  extractOnErrorOption,
+  generateId,
+  getDebugLevel,
+  isProtocolFactory,
+  isToolCallContent,
+  isToolChoiceActive,
+  jsonMixProtocol,
+  logParsedChunk,
+  logParsedSummary,
+  logRawChunk,
+  morphXmlProtocol,
+  originalToolsSchema
+} from "./chunk-NOYHOQOL.js";
+
+// src/core/protocols/yaml-xml-protocol.ts
+import { unwrapJsonSchema, stringify as xmlStringify } from "@ai-sdk-tool/rxml";
+import YAML from "yaml";
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var WHITESPACE_REGEX = /\s/;
+var LEADING_WHITESPACE_RE = /^(\s*)/;
+function findClosingTagEnd(text, contentStart, toolName) {
+  let pos = contentStart;
+  let depth = 1;
+  while (pos < text.length) {
+    const ltIdx = text.indexOf("<", pos);
+    if (ltIdx === -1) {
+      break;
+    }
+    const next = text[ltIdx + 1];
+    if (next === "/") {
+      const gtIdx = text.indexOf(">", ltIdx);
+      if (gtIdx === -1) {
+        break;
+      }
+      let p = ltIdx + 2;
+      while (p < gtIdx && WHITESPACE_REGEX.test(text[p])) {
+        p++;
+      }
+      const nameStart = p;
+      while (p < gtIdx && NAME_CHAR_RE.test(text.charAt(p))) {
+        p++;
+      }
+      const name = text.slice(nameStart, p);
+      if (name === toolName) {
+        depth--;
+        if (depth === 0) {
+          return gtIdx + 1;
+        }
+      }
+      pos = gtIdx + 1;
+    } else if (next === "!" || next === "?") {
+      const gtIdx = text.indexOf(">", ltIdx);
+      pos = gtIdx === -1 ? text.length : gtIdx + 1;
+    } else {
+      let p = ltIdx + 1;
+      while (p < text.length && WHITESPACE_REGEX.test(text[p])) {
+        p++;
+      }
+      const nameStart = p;
+      while (p < text.length && NAME_CHAR_RE.test(text.charAt(p))) {
+        p++;
+      }
+      const name = text.slice(nameStart, p);
+      const gtIdx = text.indexOf(">", p);
+      if (gtIdx === -1) {
+        break;
+      }
+      let r = gtIdx - 1;
+      while (r >= nameStart && WHITESPACE_REGEX.test(text[r])) {
+        r--;
+      }
+      const selfClosing = text[r] === "/";
+      if (name === toolName && !selfClosing) {
+        depth++;
+      }
+      pos = gtIdx + 1;
+    }
+  }
+  return -1;
+}
+function findEarliestTagPosition(openIdx, selfIdx) {
+  const hasSelf = selfIdx !== -1;
+  const hasOpen = openIdx !== -1;
+  if (hasSelf && (!hasOpen || selfIdx < openIdx)) {
+    return { tagStart: selfIdx, isSelfClosing: true };
+  }
+  return { tagStart: openIdx, isSelfClosing: false };
+}
+function collectToolCallsForName(text, toolName) {
+  const toolCalls = [];
+  let searchIndex = 0;
+  const selfTagRegex = new RegExp(`<${toolName}\\s*/>`, "g");
+  while (searchIndex < text.length) {
+    const startTag = `<${toolName}>`;
+    const openIdx = text.indexOf(startTag, searchIndex);
+    selfTagRegex.lastIndex = searchIndex;
+    const selfMatch = selfTagRegex.exec(text);
+    const selfIdx = selfMatch ? selfMatch.index : -1;
+    const selfTagLength = selfMatch ? selfMatch[0].length : 0;
+    if (openIdx === -1 && selfIdx === -1) {
+      break;
+    }
+    const { tagStart, isSelfClosing } = findEarliestTagPosition(
+      openIdx,
+      selfIdx
+    );
+    if (isSelfClosing) {
+      const endIndex = tagStart + selfTagLength;
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex,
+        content: ""
+      });
+      searchIndex = endIndex;
+      continue;
+    }
+    const contentStart = tagStart + startTag.length;
+    const fullTagEnd = findClosingTagEnd(text, contentStart, toolName);
+    if (fullTagEnd !== -1 && fullTagEnd > contentStart) {
+      const endTag = `</${toolName}>`;
+      const endTagStart = fullTagEnd - endTag.length;
+      const content = text.substring(contentStart, endTagStart);
+      toolCalls.push({
+        toolName,
+        startIndex: tagStart,
+        endIndex: fullTagEnd,
+        content
+      });
+      searchIndex = fullTagEnd;
+    } else {
+      searchIndex = contentStart;
+    }
+  }
+  return toolCalls;
+}
+function findToolCalls(text, toolNames) {
+  const toolCalls = toolNames.flatMap(
+    (toolName) => collectToolCallsForName(text, toolName)
+  );
+  return toolCalls.sort((a, b) => a.startIndex - b.startIndex);
+}
+function parseYamlContent(yamlContent, options) {
+  var _a, _b, _c;
+  let normalized = yamlContent;
+  if (normalized.startsWith("\n")) {
+    normalized = normalized.slice(1);
+  }
+  const lines = normalized.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return {};
+  }
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = line.match(LEADING_WHITESPACE_RE);
+      return match ? match[1].length : 0;
+    })
+  );
+  if (minIndent > 0) {
+    normalized = lines.map((line) => line.slice(minIndent)).join("\n");
+  }
+  try {
+    const doc = YAML.parseDocument(normalized);
+    if (doc.errors && doc.errors.length > 0) {
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "YAML parse error", {
+        errors: doc.errors.map((e) => e.message)
+      });
+      return null;
+    }
+    const result = doc.toJSON();
+    if (result === null) {
+      return {};
+    }
+    if (typeof result !== "object" || Array.isArray(result)) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, "YAML content must be a key-value mapping", {
+        got: typeof result
+      });
+      return null;
+    }
+    return result;
+  } catch (error) {
+    (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, "Failed to parse YAML content", { error });
+    return null;
+  }
+}
+function appendTextPart(processedElements, textPart) {
+  if (textPart.trim()) {
+    processedElements.push({
+      type: "text",
+      text: textPart
+    });
+  }
+}
+function processToolCallMatch(text, tc, currentIndex, processedElements, options) {
+  var _a;
+  if (tc.startIndex < currentIndex) {
+    return currentIndex;
+  }
+  appendTextPart(
+    processedElements,
+    text.substring(currentIndex, tc.startIndex)
+  );
+  const parsedArgs = parseYamlContent(tc.content, options);
+  if (parsedArgs !== null) {
+    processedElements.push({
+      type: "tool-call",
+      toolCallId: generateId(),
+      toolName: tc.toolName,
+      input: JSON.stringify(parsedArgs)
+    });
+  } else {
+    const originalText = text.substring(tc.startIndex, tc.endIndex);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse YAML tool call", {
+      toolCall: originalText
+    });
+    processedElements.push({ type: "text", text: originalText });
+  }
+  return tc.endIndex;
+}
+function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmittedTextStart, setHasEmittedTextStart) {
+  return (controller, text) => {
+    const content = text;
+    if (content) {
+      if (!getCurrentTextId()) {
+        const newId = generateId();
+        setCurrentTextId(newId);
+        controller.enqueue({
+          type: "text-start",
+          id: newId
+        });
+        setHasEmittedTextStart(true);
+      }
+      controller.enqueue({
+        type: "text-delta",
+        id: getCurrentTextId(),
+        textDelta: content,
+        delta: content
+      });
+    }
+    const currentTextId = getCurrentTextId();
+    if (currentTextId && !text) {
+      if (getHasEmittedTextStart()) {
+        controller.enqueue({
+          type: "text-end",
+          id: currentTextId
+        });
+        setHasEmittedTextStart(false);
+      }
+      setCurrentTextId(null);
+    }
+  };
+}
+function findEarliestToolTag(buffer, toolNames) {
+  let bestIndex = -1;
+  let bestName = "";
+  let bestSelfClosing = false;
+  let bestTagLength = 0;
+  for (const name of toolNames) {
+    const openTag = `<${name}>`;
+    const selfTagRegex = new RegExp(`<${name}\\s*/>`);
+    const idxOpen = buffer.indexOf(openTag);
+    const selfMatch = selfTagRegex.exec(buffer);
+    const idxSelf = selfMatch ? selfMatch.index : -1;
+    if (idxOpen !== -1 && (bestIndex === -1 || idxOpen < bestIndex)) {
+      bestIndex = idxOpen;
+      bestName = name;
+      bestSelfClosing = false;
+      bestTagLength = openTag.length;
+    }
+    if (idxSelf !== -1 && (bestIndex === -1 || idxSelf < bestIndex)) {
+      bestIndex = idxSelf;
+      bestName = name;
+      bestSelfClosing = true;
+      bestTagLength = selfMatch ? selfMatch[0].length : 0;
+    }
+  }
+  return {
+    index: bestIndex,
+    name: bestName,
+    selfClosing: bestSelfClosing,
+    tagLength: bestTagLength
+  };
+}
+var yamlXmlProtocol = (_protocolOptions) => {
+  return {
+    formatTools({ tools, toolSystemPromptTemplate }) {
+      const toolsForPrompt = (tools || []).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: unwrapJsonSchema(tool.inputSchema)
+      }));
+      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+    },
+    formatToolCall(toolCall) {
+      let args = {};
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = { value: toolCall.input };
+      }
+      const yamlContent = YAML.stringify(args);
+      return `<${toolCall.toolName}>
+${yamlContent}</${toolCall.toolName}>`;
+    },
+    formatToolResponse(toolResult) {
+      let result = toolResult.result;
+      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
+        result = result.value;
+      }
+      const xml = xmlStringify(
+        "tool_response",
+        {
+          tool_name: toolResult.toolName,
+          result
+        },
+        { declaration: false }
+      );
+      return xml;
+    },
+    parseGeneratedText({ text, tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [{ type: "text", text }];
+      }
+      const processedElements = [];
+      let currentIndex = 0;
+      const toolCalls = findToolCalls(text, toolNames);
+      for (const tc of toolCalls) {
+        currentIndex = processToolCallMatch(
+          text,
+          tc,
+          currentIndex,
+          processedElements,
+          options
+        );
+      }
+      if (currentIndex < text.length) {
+        appendTextPart(processedElements, text.substring(currentIndex));
+      }
+      return processedElements;
+    },
+    createStreamParser({ tools, options }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      let buffer = "";
+      let currentToolCall = null;
+      let currentTextId = null;
+      let hasEmittedTextStart = false;
+      const flushText = createFlushTextHandler(
+        () => currentTextId,
+        (newId) => {
+          currentTextId = newId;
+        },
+        () => hasEmittedTextStart,
+        (value) => {
+          hasEmittedTextStart = value;
+        }
+      );
+      const processToolCallEnd = (controller, toolContent, toolName) => {
+        var _a;
+        const parsedArgs = parseYamlContent(toolContent, options);
+        flushText(controller);
+        if (parsedArgs !== null) {
+          controller.enqueue({
+            type: "tool-call",
+            toolCallId: generateId(),
+            toolName,
+            input: JSON.stringify(parsedArgs)
+          });
+        } else {
+          const original = `<${toolName}>${toolContent}</${toolName}>`;
+          (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(options, "Could not parse streaming YAML tool call", {
+            toolCall: original
+          });
+          flushText(controller, original);
+        }
+      };
+      const handlePendingToolCall = (controller, endTag, toolName) => {
+        const endIdx = buffer.indexOf(endTag);
+        if (endIdx === -1) {
+          return false;
+        }
+        const content = buffer.substring(0, endIdx);
+        buffer = buffer.substring(endIdx + endTag.length);
+        processToolCallEnd(controller, content, toolName);
+        currentToolCall = null;
+        return true;
+      };
+      const flushSafeText = (controller) => {
+        const maxTagLen = toolNames.length ? Math.max(...toolNames.map((n) => `<${n} />`.length)) : 0;
+        const tail = Math.max(0, maxTagLen - 1);
+        const safeLen = Math.max(0, buffer.length - tail);
+        if (safeLen > 0) {
+          flushText(controller, buffer.slice(0, safeLen));
+          buffer = buffer.slice(safeLen);
+        }
+      };
+      const handleNewToolTag = (controller, tagIndex, tagName, selfClosing, tagLength) => {
+        if (tagIndex > 0) {
+          flushText(controller, buffer.substring(0, tagIndex));
+        }
+        if (selfClosing) {
+          buffer = buffer.substring(tagIndex + tagLength);
+          processToolCallEnd(controller, "", tagName);
+        } else {
+          const startTag = `<${tagName}>`;
+          buffer = buffer.substring(tagIndex + startTag.length);
+          currentToolCall = { name: tagName, content: "" };
+        }
+      };
+      const processBuffer = (controller) => {
+        while (true) {
+          if (currentToolCall) {
+            const toolName = currentToolCall.name;
+            const endTag = `</${toolName}>`;
+            if (!handlePendingToolCall(controller, endTag, toolName)) {
+              break;
+            }
+          } else {
+            const { index, name, selfClosing, tagLength } = findEarliestToolTag(
+              buffer,
+              toolNames
+            );
+            if (index === -1) {
+              flushSafeText(controller);
+              break;
+            }
+            handleNewToolTag(controller, index, name, selfClosing, tagLength);
+          }
+        }
+      };
+      return new TransformStream({
+        transform(chunk, controller) {
+          var _a, _b;
+          if (chunk.type !== "text-delta") {
+            if (buffer) {
+              flushText(controller, buffer);
+              buffer = "";
+            }
+            controller.enqueue(chunk);
+            return;
+          }
+          const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+          buffer += textContent;
+          processBuffer(controller);
+        },
+        flush(controller) {
+          if (currentToolCall) {
+            const unfinishedContent = `<${currentToolCall.name}>${buffer}`;
+            flushText(controller, unfinishedContent);
+            buffer = "";
+            currentToolCall = null;
+          } else if (buffer) {
+            flushText(controller, buffer);
+            buffer = "";
+          }
+          if (currentTextId && hasEmittedTextStart) {
+            controller.enqueue({
+              type: "text-end",
+              id: currentTextId
+            });
+            hasEmittedTextStart = false;
+            currentTextId = null;
+          }
+        }
+      });
+    },
+    extractToolCallSegments({ text, tools }) {
+      const toolNames = tools.map((t) => t.name).filter(Boolean);
+      if (toolNames.length === 0) {
+        return [];
+      }
+      return findToolCalls(text, toolNames).map(
+        (tc) => `<${tc.toolName}>${tc.content}</${tc.toolName}>`
+      );
+    }
+  };
+};
+function orchestratorSystemPromptTemplate(tools, includeMultilineExample = true) {
+  const multilineExample = includeMultilineExample ? `
+
+For multiline values, use YAML's literal block syntax:
+<write_file>
+file_path: /tmp/example.txt
+contents: |
+  First line
+  Second line
+  Third line
+</write_file>` : "";
+  return `# Tools
+
+You may call one or more functions to assist with the user query.
+
+You are provided with function signatures within <tools></tools> XML tags:
+<tools>${tools}</tools>
+
+# Format
+
+Use exactly one XML element whose tag name is the function name.
+Inside the XML element, specify parameters using YAML syntax (key: value pairs).
+
+# Example
+<get_weather>
+location: New York
+unit: celsius
+</get_weather>${multilineExample}
+
+# Rules
+- Parameter names and values must follow the schema exactly.
+- Use proper YAML syntax for values (strings, numbers, booleans, arrays, objects).
+- Each required parameter must appear once.
+- Do not add functions or parameters not in the schema.
+- After calling a tool, you will receive a response. Use this result to answer the user.
+- Do NOT ask clarifying questions. Use reasonable defaults for optional parameters.
+- If a task requires multiple function calls, make ALL of them at once.`;
+}
+
+// src/v6/generate-handler.ts
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+import { coerceBySchema } from "@ai-sdk-tool/rxml";
+function parseToolChoiceJson(text, providerOptions) {
+  var _a;
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    const options = extractOnErrorOption(providerOptions);
+    (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+      options,
+      "Failed to parse toolChoice JSON from generated model output",
+      {
+        text,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    );
+    return {};
+  }
+}
+function logDebugSummary(debugSummary, toolCall, originText) {
+  if (debugSummary) {
+    debugSummary.originalText = originText;
+    try {
+      debugSummary.toolCalls = JSON.stringify([
+        { toolName: toolCall.toolName, input: toolCall.input }
+      ]);
+    } catch (e) {
+    }
+  } else if (getDebugLevel() === "parse") {
+    logParsedSummary({ toolCalls: [toolCall], originalText: originText });
+  }
+}
+async function handleToolChoice(doGenerate, params) {
+  var _a, _b, _c;
+  const result = await doGenerate();
+  const first = (_a = result.content) == null ? void 0 : _a[0];
+  let parsed = {};
+  if (first && first.type === "text") {
+    if (getDebugLevel() === "parse") {
+      logRawChunk(first.text);
+    }
+    parsed = parseToolChoiceJson(first.text, params.providerOptions);
+  }
+  const toolCall = {
+    type: "tool-call",
+    toolCallId: generateId2(),
+    toolName: parsed.name || "unknown",
+    input: JSON.stringify(parsed.arguments || {})
+  };
+  const originText = first && first.type === "text" ? first.text : "";
+  const debugSummary = (_c = (_b = params.providerOptions) == null ? void 0 : _b.toolCallMiddleware) == null ? void 0 : _c.debugSummary;
+  logDebugSummary(debugSummary, toolCall, originText);
+  return {
+    ...result,
+    content: [toolCall]
+  };
+}
+function parseContent(content, protocol, tools, providerOptions) {
+  const parsed = content.flatMap((contentItem) => {
+    if (contentItem.type !== "text") {
+      return [contentItem];
+    }
+    if (getDebugLevel() === "stream") {
+      logRawChunk(contentItem.text);
+    }
+    return protocol.parseGeneratedText({
+      text: contentItem.text,
+      tools,
+      options: {
+        ...extractOnErrorOption(providerOptions),
+        ...providerOptions == null ? void 0 : providerOptions.toolCallMiddleware
+      }
+    });
+  });
+  return parsed.map(
+    (part) => fixToolCallWithSchema(part, tools)
+  );
+}
+function logParsedContent(content) {
+  if (getDebugLevel() === "stream") {
+    for (const part of content) {
+      logParsedChunk(part);
+    }
+  }
+}
+function computeDebugSummary(options) {
+  var _a;
+  const { result, newContent, protocol, tools, providerOptions } = options;
+  const allText = result.content.filter(
+    (c) => c.type === "text"
+  ).map((c) => c.text).join("\n\n");
+  const segments = protocol.extractToolCallSegments ? protocol.extractToolCallSegments({ text: allText, tools }) : [];
+  const originalText = segments.join("\n\n");
+  const toolCalls = newContent.filter(
+    (p) => p.type === "tool-call"
+  );
+  const dbg = (_a = providerOptions == null ? void 0 : providerOptions.toolCallMiddleware) == null ? void 0 : _a.debugSummary;
+  if (dbg) {
+    dbg.originalText = originalText;
+    try {
+      dbg.toolCalls = JSON.stringify(
+        toolCalls.map((tc) => ({
+          toolName: tc.toolName,
+          input: tc.input
+        }))
+      );
+    } catch (e) {
+    }
+  } else if (getDebugLevel() === "parse") {
+    logParsedSummary({ toolCalls, originalText });
+  }
+}
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  params
+}) {
+  var _a, _b;
+  if (isToolChoiceActive(params)) {
+    return handleToolChoice(doGenerate, params);
+  }
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const newContent = parseContent(
+    result.content,
+    protocol,
+    tools,
+    params.providerOptions
+  );
+  logParsedContent(newContent);
+  computeDebugSummary({
+    result,
+    newContent,
+    protocol,
+    tools,
+    providerOptions: params.providerOptions
+  });
+  return {
+    ...result,
+    content: newContent
+  };
+}
+function fixToolCallWithSchema(part, tools) {
+  var _a;
+  if (part.type !== "tool-call") {
+    return part;
+  }
+  const tc = part;
+  let args = {};
+  if (typeof tc.input === "string") {
+    try {
+      args = JSON.parse(tc.input);
+    } catch (e) {
+      return part;
+    }
+  } else if (tc.input && typeof tc.input === "object") {
+    args = tc.input;
+  }
+  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = coerceBySchema(args, schema);
+  return {
+    ...part,
+    input: JSON.stringify(coerced != null ? coerced : {})
+  };
+}
+
+// src/v6/stream-handler.ts
+import { generateId as generateId3 } from "@ai-sdk/provider-utils";
+function mapCorePartToV3(part) {
+  switch (part.type) {
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: part.id || generateId3(),
+        delta: part.textDelta
+      };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input
+      };
+    case "tool-call-delta":
+      return {
+        type: "tool-call-delta",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        argsTextDelta: part.argsTextDelta
+      };
+    case "finish":
+      return {
+        type: "finish",
+        finishReason: part.finishReason,
+        usage: part.usage
+      };
+    case "error":
+      return {
+        type: "error",
+        error: part.error
+      };
+    default:
+      return part;
+  }
+}
+function mapV3PartToCore(part) {
+  const p = part;
+  switch (p.type) {
+    case "text-delta":
+      return {
+        type: "text-delta",
+        id: p.id,
+        textDelta: p.delta || p.textDelta || ""
+      };
+    case "tool-call":
+      return {
+        type: "tool-call",
+        toolCallId: p.toolCallId,
+        toolName: p.toolName,
+        input: p.input
+      };
+    case "finish": {
+      const finishReason = p.finishReason;
+      return {
+        type: "finish",
+        finishReason: (typeof finishReason === "object" ? finishReason == null ? void 0 : finishReason.unified : finishReason) || "stop",
+        usage: p.usage
+      };
+    }
+    default:
+      return p;
+  }
+}
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a, _b, _c;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
+  const debugLevel = getDebugLevel();
+  const tools = originalToolsSchema.decode(
+    (_b = (_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware) == null ? void 0 : _b.originalTools
+  );
+  const options = {
+    ...extractOnErrorOption(params.providerOptions),
+    ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
+  };
+  const coreStream = stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        if (debugLevel === "stream") {
+          logRawChunk(part);
+        }
+        controller.enqueue(mapV3PartToCore(part));
+      }
+    })
+  ).pipeThrough(protocol.createStreamParser({ tools, options }));
+  const v3Stream = coreStream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        const v3Part = mapCorePartToV3(part);
+        if (debugLevel === "stream") {
+          logParsedChunk(v3Part);
+        }
+        controller.enqueue(v3Part);
+      }
+    })
+  );
+  return {
+    ...rest,
+    stream: v3Stream
+  };
+}
+async function toolChoiceStream({
+  doGenerate,
+  options
+}) {
+  var _a, _b;
+  const result = await doGenerate();
+  let toolJson = {};
+  if ((result == null ? void 0 : result.content) && result.content.length > 0 && ((_a = result.content[0]) == null ? void 0 : _a.type) === "text") {
+    try {
+      toolJson = JSON.parse(result.content[0].text);
+    } catch (error) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+        options,
+        "Failed to parse toolChoice JSON from streamed model output",
+        {
+          text: result.content[0].text,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      );
+      toolJson = {};
+    }
+  }
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue({
+        type: "tool-call",
+        toolCallId: generateId3(),
+        toolName: toolJson.name || "unknown",
+        input: JSON.stringify(toolJson.arguments || {})
+      });
+      controller.enqueue({
+        type: "finish",
+        usage: (result == null ? void 0 : result.usage) || {
+          inputTokens: 0,
+          outputTokens: 0
+        },
+        finishReason: "tool-calls"
+      });
+      controller.close();
+    }
+  });
+  return {
+    request: (result == null ? void 0 : result.request) || {},
+    response: (result == null ? void 0 : result.response) || {},
+    stream
+  };
+}
+
+// src/v6/transform-handler.ts
+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
+    ];
+  }
+  return [
+    ...processedPrompt,
+    {
+      role: "system",
+      content: systemPrompt
+    }
+  ];
+}
+function buildBaseReturnParams(params, finalPrompt, functionTools) {
+  return {
+    ...params,
+    prompt: finalPrompt,
+    tools: [],
+    toolChoice: void 0,
+    providerOptions: {
+      ...params.providerOptions || {},
+      toolCallMiddleware: {
+        ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
+        originalTools: originalToolsSchema.encode(functionTools)
+      }
+    }
+  };
+}
+function findProviderDefinedTool(tools, selectedToolName) {
+  return tools.find((t) => {
+    if (t.type === "function") {
+      return false;
+    }
+    const anyTool = t;
+    return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
+  });
+}
+function handleToolChoiceTool(params, baseReturnParams) {
+  var _a, _b, _c;
+  const selectedToolName = (_a = params.toolChoice) == null ? void 0 : _a.toolName;
+  if (!selectedToolName) {
+    throw new Error("Tool name is required for 'tool' toolChoice type.");
+  }
+  const providerDefinedMatch = findProviderDefinedTool(
+    (_b = params.tools) != null ? _b : [],
+    selectedToolName
+  );
+  if (providerDefinedMatch) {
+    throw new Error(
+      "Provider-defined tools are not supported by this middleware. Please use custom tools."
+    );
+  }
+  const selectedTool = ((_c = params.tools) != null ? _c : []).find(
+    (t) => t.type === "function" && t.name === selectedToolName
+  );
+  if (!selectedTool) {
+    throw new Error(
+      `Tool with name '${selectedToolName}' not found in params.tools.`
+    );
+  }
+  return {
+    ...baseReturnParams,
+    responseFormat: {
+      type: "json",
+      schema: {
+        type: "object",
+        properties: {
+          name: {
+            const: selectedTool.name
+          },
+          arguments: selectedTool.inputSchema
+        },
+        required: ["name", "arguments"]
+      },
+      name: selectedTool.name,
+      description: typeof selectedTool.description === "string" ? selectedTool.description : void 0
+    },
+    providerOptions: {
+      ...baseReturnParams.providerOptions || {},
+      toolCallMiddleware: {
+        ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+        ...params.toolChoice ? { toolChoice: params.toolChoice } : {}
+      }
+    }
+  };
+}
+function handleToolChoiceRequired(params, baseReturnParams, functionTools) {
+  if (!params.tools || params.tools.length === 0) {
+    throw new Error(
+      "Tool choice type 'required' is set, but no tools are provided in params.tools."
+    );
+  }
+  return {
+    ...baseReturnParams,
+    responseFormat: {
+      type: "json",
+      schema: createDynamicIfThenElseSchema(functionTools)
+    },
+    providerOptions: {
+      ...baseReturnParams.providerOptions || {},
+      toolCallMiddleware: {
+        ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
+        toolChoice: { type: "required" }
+      }
+    }
+  };
+}
+function transformParams({
+  params,
+  protocol,
+  toolSystemPromptTemplate,
+  placement = "first"
+}) {
+  var _a, _b, _c, _d, _e;
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  const systemPrompt = resolvedProtocol.formatTools({
+    tools: functionTools,
+    toolSystemPromptTemplate
+  });
+  const processedPrompt = convertToolPrompt(
+    (_b = params.prompt) != null ? _b : [],
+    resolvedProtocol,
+    extractOnErrorOption(params.providerOptions)
+  );
+  const finalPrompt = buildFinalPrompt(
+    systemPrompt,
+    processedPrompt,
+    placement
+  );
+  const baseReturnParams = buildBaseReturnParams(
+    params,
+    finalPrompt,
+    functionTools
+  );
+  if (((_c = params.toolChoice) == null ? void 0 : _c.type) === "none") {
+    throw new Error(
+      "The 'none' toolChoice type is not supported by this middleware. Please use 'auto', 'required', or specify a tool name."
+    );
+  }
+  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "tool") {
+    return handleToolChoiceTool(params, baseReturnParams);
+  }
+  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "required") {
+    return handleToolChoiceRequired(params, baseReturnParams, functionTools);
+  }
+  return baseReturnParams;
+}
+function processAssistantContent(content, resolvedProtocol, providerOptions) {
+  var _a;
+  const newContent = [];
+  for (const item of content) {
+    if (isToolCallContent(item)) {
+      newContent.push({
+        type: "text",
+        text: resolvedProtocol.formatToolCall(item)
+      });
+    } else if (item.type === "text") {
+      newContent.push(item);
+    } else if (item.type === "reasoning") {
+      newContent.push(item);
+    } else {
+      const options = extractOnErrorOption(providerOptions);
+      (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+        options,
+        "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+        { content: item }
+      );
+      newContent.push({
+        type: "text",
+        text: JSON.stringify(item)
+      });
+    }
+  }
+  const onlyText = newContent.every((c) => c.type === "text");
+  return onlyText ? [
+    {
+      type: "text",
+      text: newContent.map((c) => c.text).join("\n")
+    }
+  ] : newContent;
+}
+function processToolMessage(content, resolvedProtocol) {
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: content.map((toolResult) => {
+          var _a, _b;
+          const tr = toolResult;
+          return resolvedProtocol.formatToolResponse({
+            ...toolResult,
+            result: (_b = (_a = tr.result) != null ? _a : tr.content) != null ? _b : tr.output
+          });
+        }).join("\n")
+      }
+    ]
+  };
+}
+function processMessage(message, resolvedProtocol, providerOptions) {
+  if (message.role === "assistant") {
+    const condensedContent = processAssistantContent(
+      message.content,
+      resolvedProtocol,
+      providerOptions
+    );
+    return {
+      role: "assistant",
+      content: condensedContent
+    };
+  }
+  if (message.role === "tool") {
+    const toolResultParts = message.content.filter(
+      (part) => part.type === "tool-result"
+    );
+    return processToolMessage(toolResultParts, resolvedProtocol);
+  }
+  return message;
+}
+function isAllTextContent(content) {
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  return content.every(
+    (c) => (c == null ? void 0 : c.type) === "text"
+  );
+}
+function joinTextContent(content) {
+  return content.map((c) => c.text).join("\n");
+}
+function createCondensedMessage(role, joinedText) {
+  if (role === "system") {
+    return {
+      role: "system",
+      content: joinedText
+    };
+  }
+  return {
+    role,
+    content: [
+      {
+        type: "text",
+        text: joinedText
+      }
+    ]
+  };
+}
+function condenseTextContent(processedPrompt) {
+  for (let i = 0; i < processedPrompt.length; i += 1) {
+    const msg = processedPrompt[i];
+    if (!Array.isArray(msg.content)) {
+      continue;
+    }
+    const shouldCondense = isAllTextContent(msg.content) && msg.content.length > 1;
+    if (shouldCondense) {
+      const joinedText = joinTextContent(msg.content);
+      processedPrompt[i] = createCondensedMessage(msg.role, joinedText);
+    }
+  }
+  return processedPrompt;
+}
+function mergeConsecutiveUserMessages(processedPrompt) {
+  for (let i = processedPrompt.length - 1; i > 0; i -= 1) {
+    const current = processedPrompt[i];
+    const prev = processedPrompt[i - 1];
+    if (current.role === "user" && prev.role === "user") {
+      const prevContent = prev.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+      const currentContent = current.content.map((c) => c.type === "text" ? c.text : "").join("\n");
+      processedPrompt[i - 1] = {
+        role: "user",
+        content: [{ type: "text", text: `${prevContent}
+${currentContent}` }]
+      };
+      processedPrompt.splice(i, 1);
+    }
+  }
+  return processedPrompt;
+}
+function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+  let processedPrompt = prompt.map(
+    (message) => processMessage(message, resolvedProtocol, providerOptions)
+  );
+  processedPrompt = condenseTextContent(processedPrompt);
+  processedPrompt = mergeConsecutiveUserMessages(processedPrompt);
+  return processedPrompt;
+}
+
+// src/v6/tool-call-middleware.ts
+function createToolMiddleware({
+  protocol,
+  toolSystemPromptTemplate,
+  placement = "last"
+}) {
+  const resolvedProtocol = isProtocolFactory(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
+      });
+    },
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({ params }) => transformParams({
+      protocol: resolvedProtocol,
+      toolSystemPromptTemplate,
+      placement,
+      params
+    })
+  };
+}
+
+// src/v6/index.ts
+var gemmaToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol({
+    toolCallStart: "```tool_call\n",
+    toolCallEnd: "\n```",
+    toolResponseStart: "```tool_response\n",
+    toolResponseEnd: "\n```"
+  }),
+  toolSystemPromptTemplate(tools) {
+    return `You have access to functions. If you decide to invoke any of the function(s),
+you MUST put it in the format of markdown code fence block with the language name of tool_call , e.g.
+\`\`\`tool_call
+{'name': <function-name>, 'arguments': <args-dict>}
+\`\`\`
+You SHOULD NOT include any other text in the response if you call a function
+${tools}`;
+  }
+});
+var hermesToolMiddleware = createToolMiddleware({
+  protocol: jsonMixProtocol,
+  toolSystemPromptTemplate(tools) {
+    return `You are a function calling AI model.
+You are provided with function signatures within <tools></tools> XML tags.
+You may call one or more functions to assist with the user query.
+Don't make assumptions about what values to plug into functions.
+Here are the available tools: <tools>${tools}</tools>
+Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
+  }
+});
+var morphXmlToolMiddleware = createToolMiddleware({
+  protocol: morphXmlProtocol,
+  placement: "first",
+  toolSystemPromptTemplate(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>${tools}</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>`;
+  }
+});
+var orchestratorToolMiddleware = createToolMiddleware({
+  protocol: yamlXmlProtocol(),
+  placement: "first",
+  toolSystemPromptTemplate: orchestratorSystemPromptTemplate
+});
+
+export {
+  yamlXmlProtocol,
+  orchestratorSystemPromptTemplate,
+  createToolMiddleware,
+  gemmaToolMiddleware,
+  hermesToolMiddleware,
+  morphXmlToolMiddleware,
+  orchestratorToolMiddleware
+};
+//# sourceMappingURL=chunk-QPJA5CS6.js.map