@ai-sdk-tool/parser 3.0.0 → 3.1.1

package/dist/index.cjs

@@ -43,32 +43,34 @@ __export(src_exports, {
   escapeRegExp: () => escapeRegExp2,
   extractOnErrorOption: () => extractOnErrorOption,
   extractToolNamesFromOriginalTools: () => extractToolNamesFromOriginalTools,
-  gemmaToolMiddleware: () => gemmaToolMiddleware,
   getDebugLevel: () => getDebugLevel,
   getPotentialStartIndex: () => getPotentialStartIndex,
   hasInputProperty: () => hasInputProperty,
   hermesToolMiddleware: () => hermesToolMiddleware,
   isProtocolFactory: () => isProtocolFactory,
-  isToolCallContent: () => isToolCallContent,
+  isTCMProtocolFactory: () => isTCMProtocolFactory,
   isToolChoiceActive: () => isToolChoiceActive,
   isToolResultPart: () => isToolResultPart,
-  jsonMixProtocol: () => jsonMixProtocol,
+  jsonProtocol: () => jsonProtocol,
   logParseFailure: () => logParseFailure,
   logParsedChunk: () => logParsedChunk,
   logParsedSummary: () => logParsedSummary,
   logRawChunk: () => logRawChunk,
   mergePipelineConfigs: () => mergePipelineConfigs,
-  morphXmlProtocol: () => morphXmlProtocol,
-  morphXmlToolMiddleware: () => morphXmlToolMiddleware,
   normalizeCloseTagsHeuristic: () => normalizeCloseTagsHeuristic,
-  orchestratorSystemPromptTemplate: () => orchestratorSystemPromptTemplate,
-  orchestratorToolMiddleware: () => orchestratorToolMiddleware,
   originalToolsSchema: () => originalToolsSchema,
   parse: () => parse2,
   repairAgainstSchemaHeuristic: () => repairAgainstSchemaHeuristic,
   stringify: () => stringify,
+  toolChoiceStream: () => toolChoiceStream,
   transform: () => transform,
-  yamlXmlProtocol: () => yamlXmlProtocol
+  transformParams: () => transformParams,
+  wrapGenerate: () => wrapGenerate,
+  wrapStream: () => wrapStream,
+  xmlProtocol: () => xmlProtocol,
+  xmlToolMiddleware: () => xmlToolMiddleware,
+  yamlProtocol: () => yamlProtocol,
+  yamlToolMiddleware: () => yamlToolMiddleware
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -406,12 +408,15 @@ function handleOpeningTagSegment(src, lt, out, stack) {
   }
   return q + 1;
 }
-function shouldDeduplicateStringTags(schema) {
+function extractSchemaProperties(schema) {
   const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
   if (!unwrapped || typeof unwrapped !== "object") {
-    return false;
+    return void 0;
   }
-  const props = unwrapped.properties;
+  return unwrapped.properties;
+}
+function shouldDeduplicateStringTags(schema) {
+  const props = extractSchemaProperties(schema);
   if (!props) {
     return false;
   }
@@ -423,21 +428,14 @@ function shouldDeduplicateStringTags(schema) {
   return (command == null ? void 0 : command.type) === "array";
 }
 function getStringPropertyNames(schema) {
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return [];
-  }
-  const props = unwrapped.properties;
+  const props = extractSchemaProperties(schema);
   if (!props) {
     return [];
   }
   const names = [];
   for (const key of Object.keys(props)) {
-    const prop = (0, import_rxml.unwrapJsonSchema)(
-      props[key]
-    );
-    const type = prop.type;
-    if (type === "string") {
+    const prop = (0, import_rxml.unwrapJsonSchema)(props[key]);
+    if ((prop == null ? void 0 : prop.type) === "string") {
       names.push(key);
     }
   }
@@ -472,11 +470,7 @@ function repairParsedAgainstSchema(input, schema) {
   if (!input || typeof input !== "object") {
     return input;
   }
-  const unwrapped = (0, import_rxml.unwrapJsonSchema)(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return input;
-  }
-  const properties = unwrapped.properties;
+  const properties = extractSchemaProperties(schema);
   if (!properties) {
     return input;
   }
@@ -490,14 +484,12 @@ function applySchemaProps(obj, properties) {
       continue;
     }
     const prop = (0, import_rxml.unwrapJsonSchema)(propSchema);
-    const propType = prop.type;
-    if (propType === "array" && prop.items) {
-      const itemSchemaRaw = prop.items;
-      const itemSchema = (0, import_rxml.unwrapJsonSchema)(itemSchemaRaw);
+    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 (propType === "object") {
+    if ((prop == null ? void 0 : prop.type) === "object") {
       const val = obj[key];
       if (val && typeof val === "object") {
         obj[key] = repairParsedAgainstSchema(val, prop);
@@ -1397,7 +1389,7 @@ function stringify(obj) {
   return "null";
 }
 
-// src/core/protocols/json-mix-protocol.ts
+// src/core/protocols/json-protocol.ts
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a, _b;
   try {
@@ -1457,7 +1449,6 @@ function flushBuffer(state, controller, toolCallStart) {
   controller.enqueue({
     type: "text-delta",
     id: state.currentTextId,
-    textDelta: deltaContent,
     delta: deltaContent
   });
   state.buffer = "";
@@ -1490,7 +1481,6 @@ function emitIncompleteToolCall(state, controller, toolCallStart) {
   controller.enqueue({
     type: "text-delta",
     id: errorId,
-    textDelta: errorContent,
     delta: errorContent
   });
   controller.enqueue({
@@ -1523,7 +1513,6 @@ function publishText(text, state, controller) {
     controller.enqueue({
       type: "text-delta",
       id: state.currentTextId,
-      textDelta: text,
       delta: text
     });
   }
@@ -1556,7 +1545,6 @@ function emitToolCall(context) {
     controller.enqueue({
       type: "text-delta",
       id: errorId,
-      textDelta: errorContent,
       delta: errorContent
     });
     controller.enqueue({
@@ -1616,39 +1604,34 @@ function handlePartialTag(state, controller, toolCallStart) {
     state.buffer = "";
   }
 }
-var jsonMixProtocol = ({
+var jsonProtocol = ({
   toolCallStart = "<tool_call>",
-  toolCallEnd = "</tool_call>",
-  toolResponseStart = "<tool_response>",
-  toolResponseEnd = "</tool_response>"
+  toolCallEnd = "</tool_call>"
 } = {}) => ({
-  formatTools({ tools, toolSystemPromptTemplate }) {
-    const toolsForPrompt = (tools || []).filter((tool) => tool.type === "function").map((tool) => ({
-      name: tool.name,
-      description: tool.type === "function" && typeof tool.description === "string" ? tool.description : void 0,
-      parameters: tool.inputSchema
-    }));
-    return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+  formatTools({
+    tools,
+    toolSystemPromptTemplate
+  }) {
+    return toolSystemPromptTemplate(tools || []);
   },
   formatToolCall(toolCall) {
     let args = {};
-    try {
-      args = JSON.parse(toolCall.input);
-    } catch (e) {
-      args = toolCall.input;
+    if (toolCall.input != null) {
+      try {
+        args = JSON.parse(toolCall.input);
+      } catch (e) {
+        args = toolCall.input;
+      }
     }
     return `${toolCallStart}${JSON.stringify({
       name: toolCall.toolName,
       arguments: args
     })}${toolCallEnd}`;
   },
-  formatToolResponse(toolResult) {
-    return `${toolResponseStart}${JSON.stringify({
-      toolName: toolResult.toolName,
-      result: toolResult.result
-    })}${toolResponseEnd}`;
-  },
-  parseGeneratedText({ text, options }) {
+  parseGeneratedText({
+    text,
+    options
+  }) {
     const startEsc = escapeRegExp2(toolCallStart);
     const endEsc = escapeRegExp2(toolCallEnd);
     const toolCallRegex = new RegExp(
@@ -1674,7 +1657,9 @@ var jsonMixProtocol = ({
     }
     return processedElements;
   },
-  createStreamParser({ options }) {
+  createStreamParser({
+    options
+  }) {
     const state = {
       isInsideToolCall: false,
       buffer: "",
@@ -1684,7 +1669,7 @@ var jsonMixProtocol = ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a, _b;
+        var _a;
         if (chunk.type === "finish") {
           handleFinishChunk(state, controller, toolCallStart, chunk);
           return;
@@ -1693,7 +1678,7 @@ var jsonMixProtocol = ({
           controller.enqueue(chunk);
           return;
         }
-        const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+        const textContent = (_a = chunk.delta) != null ? _a : "";
         state.buffer += textContent;
         processBufferTags({
           state,
@@ -1720,7 +1705,15 @@ var jsonMixProtocol = ({
   }
 });
 
-// src/core/protocols/morph-xml-protocol.ts
+// src/core/protocols/protocol-interface.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+function isTCMProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
+// 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_:-]/;
@@ -2055,7 +2048,6 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2217,7 +2209,7 @@ function createProcessBufferHandler(getBuffer, setBuffer, getCurrentToolCall, se
     }
   };
 }
-var morphXmlProtocol = (protocolOptions) => {
+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;
@@ -2257,40 +2249,22 @@ var morphXmlProtocol = (protocolOptions) => {
   }
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      const toolsForPrompt = (tools || []).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, import_rxml2.unwrapJsonSchema)(tool.inputSchema)
-      }));
-      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+      return toolSystemPromptTemplate(tools || []);
     },
     formatToolCall(toolCall) {
       let args = {};
-      try {
-        args = JSON.parse(toolCall.input);
-      } catch (e) {
-        args = toolCall.input;
+      if (toolCall.input != null) {
+        try {
+          args = JSON.parse(toolCall.input);
+        } catch (e) {
+          args = toolCall.input;
+        }
       }
       return (0, import_rxml2.stringify)(toolCall.toolName, args, {
         suppressEmptyNode: false,
         format: false
       });
     },
-    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 = (0, import_rxml2.stringify)(
-        "tool_response",
-        {
-          tool_name: toolResult.toolName,
-          result
-        },
-        { declaration: false }
-      );
-      return xml;
-    },
     parseGeneratedText({ text, tools, options }) {
       const toolNames = tools.map((t) => t.name).filter(Boolean);
       if (toolNames.length === 0) {
@@ -2359,7 +2333,7 @@ var morphXmlProtocol = (protocolOptions) => {
       );
       return new TransformStream({
         transform(chunk, controller) {
-          var _a2, _b2;
+          var _a2;
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -2368,7 +2342,7 @@ var morphXmlProtocol = (protocolOptions) => {
             controller.enqueue(chunk);
             return;
           }
-          const textContent = (_b2 = (_a2 = chunk.textDelta) != null ? _a2 : chunk.delta) != null ? _b2 : "";
+          const textContent = (_a2 = chunk.delta) != null ? _a2 : "";
           buffer += textContent;
           processBuffer(controller);
         },
@@ -2403,13 +2377,7 @@ var morphXmlProtocol = (protocolOptions) => {
   };
 };
 
-// src/core/protocols/tool-call-protocol.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
-}
-
-// src/core/protocols/yaml-xml-protocol.ts
-var import_rxml3 = require("@ai-sdk-tool/rxml");
+// src/core/protocols/yaml-protocol.ts
 var import_yaml = __toESM(require("yaml"), 1);
 var NAME_CHAR_RE3 = /[A-Za-z0-9_:-]/;
 var WHITESPACE_REGEX4 = /\s/;
@@ -2630,7 +2598,6 @@ function createFlushTextHandler2(getCurrentTextId, setCurrentTextId, getHasEmitt
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2678,42 +2645,24 @@ function findEarliestToolTag2(buffer, toolNames) {
     tagLength: bestTagLength
   };
 }
-var yamlXmlProtocol = (_protocolOptions) => {
+var yamlProtocol = (_protocolOptions) => {
   return {
     formatTools({ tools, toolSystemPromptTemplate }) {
-      const toolsForPrompt = (tools || []).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: (0, import_rxml3.unwrapJsonSchema)(tool.inputSchema)
-      }));
-      return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
+      return toolSystemPromptTemplate(tools || []);
     },
     formatToolCall(toolCall) {
       let args = {};
-      try {
-        args = JSON.parse(toolCall.input);
-      } catch (e) {
-        args = { value: toolCall.input };
+      if (toolCall.input != null) {
+        try {
+          args = JSON.parse(toolCall.input);
+        } catch (e) {
+          args = { value: toolCall.input };
+        }
       }
       const yamlContent = import_yaml.default.stringify(args);
       return `<${toolCall.toolName}>
 ${yamlContent}</${toolCall.toolName}>`;
     },
-    formatToolResponse(toolResult) {
-      let result = toolResult.result;
-      if (result && typeof result === "object" && "type" in result && result.type === "json" && "value" in result) {
-        result = result.value;
-      }
-      const xml = (0, import_rxml3.stringify)(
-        "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) {
@@ -2827,7 +2776,7 @@ ${yamlContent}</${toolCall.toolName}>`;
       };
       return new TransformStream({
         transform(chunk, controller) {
-          var _a, _b;
+          var _a;
           if (chunk.type !== "text-delta") {
             if (buffer) {
               flushText(controller, buffer);
@@ -2836,7 +2785,7 @@ ${yamlContent}</${toolCall.toolName}>`;
             controller.enqueue(chunk);
             return;
           }
-          const textContent = (_b = (_a = chunk.textDelta) != null ? _a : chunk.delta) != null ? _b : "";
+          const textContent = (_a = chunk.delta) != null ? _a : "";
           buffer += textContent;
           processBuffer(controller);
         },
@@ -2872,44 +2821,6 @@ ${yamlContent}</${toolCall.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/core/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
@@ -3011,21 +2922,20 @@ function isToolChoiceActive(params) {
 }
 
 // src/core/utils/type-guards.ts
-function isToolCallContent(content) {
-  return content.type === "tool-call" && typeof content.toolName === "string" && // input may be a JSON string or an already-parsed object depending on provider/runtime
-  (typeof content.input === "string" || typeof content.input === "object");
-}
 function isToolResultPart(content) {
+  if (!content || typeof content !== "object") {
+    return false;
+  }
   const c = content;
-  return !!c && c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
+  return c.type === "tool-result" && typeof c.toolName === "string" && typeof c.toolCallId === "string" && "output" in c;
 }
 function hasInputProperty(obj) {
   return typeof obj === "object" && obj !== null && "input" in obj;
 }
 
-// src/v6/generate-handler.ts
+// src/generate-handler.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_rxml4 = require("@ai-sdk-tool/rxml");
+var import_rxml3 = require("@ai-sdk-tool/rxml");
 function parseToolChoiceJson(text, providerOptions) {
   var _a;
   try {
@@ -3176,92 +3086,218 @@ function fixToolCallWithSchema(part, tools) {
   if (part.type !== "tool-call") {
     return part;
   }
-  const tc = part;
   let args = {};
-  if (typeof tc.input === "string") {
+  if (typeof part.input === "string") {
     try {
-      args = JSON.parse(tc.input);
+      args = JSON.parse(part.input);
     } catch (e) {
       return part;
     }
-  } else if (tc.input && typeof tc.input === "object") {
-    args = tc.input;
+  } else if (part.input && typeof part.input === "object") {
+    args = part.input;
   }
-  const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml4.coerceBySchema)(args, schema);
+  const schema = (_a = tools.find((t) => t.name === part.toolName)) == null ? void 0 : _a.inputSchema;
+  const coerced = (0, import_rxml3.coerceBySchema)(args, schema);
   return {
     ...part,
     input: JSON.stringify(coerced != null ? coerced : {})
   };
 }
 
-// src/v6/stream-handler.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-function mapCorePartToV3(part) {
-  switch (part.type) {
-    case "text-delta":
-      return {
-        type: "text-delta",
-        id: part.id || (0, import_provider_utils2.generateId)(),
-        delta: part.textDelta
-      };
-    case "tool-call":
-      return {
-        type: "tool-call",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        input: part.input
-      };
-    case "tool-call-delta":
-      return {
-        type: "tool-call-delta",
-        toolCallId: part.toolCallId,
-        toolName: part.toolName,
-        argsTextDelta: part.argsTextDelta
-      };
-    case "finish":
-      return {
-        type: "finish",
-        finishReason: part.finishReason,
-        usage: part.usage
-      };
-    case "error":
-      return {
-        type: "error",
-        error: part.error
-      };
-    default:
-      return part;
+// src/core/prompts/hermes-system-prompt.ts
+function hermesSystemPromptTemplate(tools) {
+  const toolsJson = JSON.stringify(tools);
+  return `You are a function calling AI model.
+You are provided with function signatures within <tools></tools> XML tags.
+You may call one or more functions to assist with the user query.
+Don't make assumptions about what values to plug into functions.
+Here are the available tools: <tools>${toolsJson}</tools>
+Use the following pydantic model json schema for each tool call you will make: {"title": "FunctionCall", "type": "object", "properties": {"arguments": {"title": "Arguments", "type": "object"}, "name": {"title": "Name", "type": "string"}}, "required": ["arguments", "name"]}
+For each function call return a json object with function name and arguments within <tool_call></tool_call> XML tags as follows:
+<tool_call>
+{"name": "<function-name>", "arguments": <args-dict>}
+</tool_call>`;
+}
+
+// src/core/prompts/tool-response.ts
+function unwrapToolResult(result) {
+  var _a, _b;
+  switch (result.type) {
+    case "text":
+      return (_a = result.value) != null ? _a : "";
+    case "json":
+      return result.value;
+    case "execution-denied": {
+      const reason = result.reason;
+      return reason ? `[Execution Denied: ${reason}]` : "[Execution Denied]";
+    }
+    case "error-text":
+      return `[Error: ${(_b = result.value) != null ? _b : ""}]`;
+    case "error-json":
+      return `[Error: ${JSON.stringify(result.value)}]`;
+    case "content": {
+      return result.value.map((part) => {
+        var _a2;
+        const contentPart = part;
+        switch (contentPart.type) {
+          case "text":
+            return (_a2 = contentPart.text) != null ? _a2 : "";
+          case "image-data":
+            return `[Image: ${contentPart.mediaType}]`;
+          case "image-url":
+            return `[Image URL: ${contentPart.url}]`;
+          case "image-file-id": {
+            const fileId = contentPart.fileId;
+            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+            return `[Image ID: ${displayId}]`;
+          }
+          case "file-data": {
+            const filePart = contentPart;
+            if (filePart.filename) {
+              return `[File: ${filePart.filename} (${filePart.mediaType})]`;
+            }
+            return `[File: ${filePart.mediaType}]`;
+          }
+          case "file-url":
+            return `[File URL: ${contentPart.url}]`;
+          case "file-id": {
+            const fileId = contentPart.fileId;
+            const displayId = typeof fileId === "string" ? fileId : JSON.stringify(fileId);
+            return `[File ID: ${displayId}]`;
+          }
+          case "media":
+            return `[Media: ${contentPart.mediaType}]`;
+          case "custom":
+            return "[Custom content]";
+          default:
+            return "[Unknown content]";
+        }
+      }).join("\n");
+    }
+    default: {
+      const _exhaustive = result;
+      return _exhaustive;
+    }
   }
 }
-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
-      };
+function formatToolResponseAsJsonInXml(toolResult) {
+  const unwrappedResult = unwrapToolResult(toolResult.output);
+  return `<tool_response>${JSON.stringify({
+    toolName: toolResult.toolName,
+    result: unwrappedResult
+  })}</tool_response>`;
+}
+function formatToolResponseAsXml(toolResult) {
+  const unwrappedResult = unwrapToolResult(toolResult.output);
+  const toolNameXml = `<tool_name>${toolResult.toolName}</tool_name>`;
+  const resultLines = formatXmlNode("result", unwrappedResult, 1);
+  return [
+    "<tool_response>",
+    `  ${toolNameXml}`,
+    ...resultLines,
+    "</tool_response>"
+  ].join("\n");
+}
+function formatXmlNode(tagName, value, depth) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return [`${indent}<${tagName}>${String(value)}</${tagName}>`];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return [`${indent}<${tagName}></${tagName}>`];
     }
-    default:
-      return p;
+    const lines2 = [`${indent}<${tagName}>`];
+    for (const item of value) {
+      lines2.push(...formatXmlNode("item", item, depth + 1));
+    }
+    lines2.push(`${indent}</${tagName}>`);
+    return lines2;
   }
+  const entries = Object.entries(value);
+  if (entries.length === 0) {
+    return [`${indent}<${tagName}></${tagName}>`];
+  }
+  const lines = [`${indent}<${tagName}>`];
+  for (const [key, entryValue] of entries) {
+    lines.push(...formatXmlNode(key, entryValue, depth + 1));
+  }
+  lines.push(`${indent}</${tagName}>`);
+  return lines;
+}
+
+// src/core/prompts/xml-system-prompt.ts
+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>`;
 }
+
+// src/core/prompts/yaml-system-prompt.ts
+function yamlSystemPromptTemplate(tools, includeMultilineExample = true) {
+  const toolsJson = JSON.stringify(tools);
+  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>${toolsJson}</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/stream-handler.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
 async function wrapStream({
   protocol,
   doStream,
@@ -3285,23 +3321,24 @@ async function wrapStream({
     ...((_c = params.providerOptions) == null ? void 0 : _c.toolCallMiddleware) || {}
   };
   const coreStream = stream.pipeThrough(
-    new TransformStream({
-      transform(part, controller) {
-        if (debugLevel === "stream") {
-          logRawChunk(part);
+    new TransformStream(
+      {
+        transform(part, controller) {
+          if (debugLevel === "stream") {
+            logRawChunk(part);
+          }
+          controller.enqueue(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);
+          logParsedChunk(part);
         }
-        controller.enqueue(v3Part);
+        controller.enqueue(part);
       }
     })
   );
@@ -3358,7 +3395,7 @@ async function toolChoiceStream({
   };
 }
 
-// src/v6/transform-handler.ts
+// src/transform-handler.ts
 function buildFinalPrompt(systemPrompt, processedPrompt, placement) {
   const systemIndex = processedPrompt.findIndex((m) => m.role === "system");
   if (systemIndex !== -1) {
@@ -3501,10 +3538,11 @@ function transformParams({
   params,
   protocol,
   toolSystemPromptTemplate,
+  toolResponsePromptTemplate,
   placement = "first"
 }) {
-  var _a, _b, _c, _d, _e;
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  var _a, _b, _c, _d;
+  const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   const functionTools = ((_a = params.tools) != null ? _a : []).filter(
     (t) => t.type === "function"
   );
@@ -3512,9 +3550,18 @@ function transformParams({
     tools: functionTools,
     toolSystemPromptTemplate
   });
+  let normalizedPrompt;
+  if (Array.isArray(params.prompt)) {
+    normalizedPrompt = params.prompt;
+  } else if (params.prompt) {
+    normalizedPrompt = [params.prompt];
+  } else {
+    normalizedPrompt = [];
+  }
   const processedPrompt = convertToolPrompt(
-    (_b = params.prompt) != null ? _b : [],
+    normalizedPrompt,
     resolvedProtocol,
+    toolResponsePromptTemplate,
     extractOnErrorOption(params.providerOptions)
   );
   const finalPrompt = buildFinalPrompt(
@@ -3527,15 +3574,15 @@ function transformParams({
     finalPrompt,
     functionTools
   );
-  if (((_c = params.toolChoice) == null ? void 0 : _c.type) === "none") {
+  if (((_b = params.toolChoice) == null ? void 0 : _b.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") {
+  if (((_c = params.toolChoice) == null ? void 0 : _c.type) === "tool") {
     return handleToolChoiceTool(params, baseReturnParams);
   }
-  if (((_e = params.toolChoice) == null ? void 0 : _e.type) === "required") {
+  if (((_d = params.toolChoice) == null ? void 0 : _d.type) === "required") {
     return handleToolChoiceRequired(params, baseReturnParams, functionTools);
   }
   return baseReturnParams;
@@ -3544,26 +3591,29 @@ 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)
-      });
+    switch (item.type) {
+      case "tool-call":
+        newContent.push({
+          type: "text",
+          text: resolvedProtocol.formatToolCall(item)
+        });
+        break;
+      case "text":
+      case "reasoning":
+        newContent.push(item);
+        break;
+      default: {
+        const options = extractOnErrorOption(providerOptions);
+        (_a = options == null ? void 0 : options.onError) == null ? void 0 : _a.call(
+          options,
+          "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
+          { content: item }
+        );
+        newContent.push({
+          type: "text",
+          text: JSON.stringify(item)
+        });
+      }
     }
   }
   const onlyText = newContent.every((c) => c.type === "text");
@@ -3574,25 +3624,28 @@ function processAssistantContent(content, resolvedProtocol, providerOptions) {
     }
   ] : newContent;
 }
-function processToolMessage(content, resolvedProtocol) {
+function formatApprovalResponse(part) {
+  const status = part.approved ? "Approved" : "Denied";
+  const reason = part.reason ? `: ${part.reason}` : "";
+  return `[Tool Approval ${status}${reason}]`;
+}
+function processToolMessage(toolResults, approvalResponses, toolResponsePromptTemplate) {
+  const resultTexts = toolResults.map((toolResult) => {
+    return toolResponsePromptTemplate(toolResult);
+  });
+  const approvalTexts = approvalResponses.map(formatApprovalResponse);
+  const allTexts = [...resultTexts, ...approvalTexts];
   return {
     role: "user",
     content: [
       {
         type: "text",
-        text: 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")
+        text: allTexts.join("\n")
       }
     ]
   };
 }
-function processMessage(message, resolvedProtocol, providerOptions) {
+function processMessage(message, resolvedProtocol, providerOptions, toolResponsePromptTemplate) {
   if (message.role === "assistant") {
     const condensedContent = processAssistantContent(
       message.content,
@@ -3605,10 +3658,23 @@ function processMessage(message, resolvedProtocol, providerOptions) {
     };
   }
   if (message.role === "tool") {
-    const toolResultParts = message.content.filter(
+    const toolContent = message.content;
+    const toolResultParts = toolContent.filter(
       (part) => part.type === "tool-result"
     );
-    return processToolMessage(toolResultParts, resolvedProtocol);
+    const approvalResponseParts = toolContent.filter(
+      (part) => part.type === "tool-approval-response"
+    );
+    if (!toolResponsePromptTemplate) {
+      throw new Error(
+        'toolResponsePromptTemplate is required when processing messages with role "tool". This parameter is optional for other roles but is required here so tool-result content can be converted into a prompt. Ensure your middleware or transform configuration passes a toolResponsePromptTemplate when tool message processing is enabled.'
+      );
+    }
+    return processToolMessage(
+      toolResultParts,
+      approvalResponseParts,
+      toolResponsePromptTemplate
+    );
   }
   return message;
 }
@@ -3671,22 +3737,28 @@ ${currentContent}` }]
   }
   return processedPrompt;
 }
-function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+function convertToolPrompt(prompt, resolvedProtocol, toolResponsePromptTemplate, providerOptions) {
   let processedPrompt = prompt.map(
-    (message) => processMessage(message, resolvedProtocol, providerOptions)
+    (message) => processMessage(
+      message,
+      resolvedProtocol,
+      providerOptions,
+      toolResponsePromptTemplate
+    )
   );
   processedPrompt = condenseTextContent(processedPrompt);
   processedPrompt = mergeConsecutiveUserMessages(processedPrompt);
   return processedPrompt;
 }
 
-// src/v6/tool-call-middleware.ts
+// src/tool-call-middleware.ts
 function createToolMiddleware({
   protocol,
   toolSystemPromptTemplate,
+  toolResponsePromptTemplate,
   placement = "last"
 }) {
-  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  const resolvedProtocol = isTCMProtocolFactory(protocol) ? protocol() : protocol;
   return {
     specificationVersion: "v3",
     wrapStream: ({ doStream, doGenerate, params }) => {
@@ -3711,76 +3783,28 @@ function createToolMiddleware({
     transformParams: async ({ params }) => transformParams({
       protocol: resolvedProtocol,
       toolSystemPromptTemplate,
+      toolResponsePromptTemplate,
       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}`;
-  }
-});
+// src/preconfigured-middleware.ts
 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>`;
-  }
+  protocol: jsonProtocol({}),
+  toolSystemPromptTemplate: hermesSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsJsonInXml
 });
-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 xmlToolMiddleware = createToolMiddleware({
+  protocol: xmlProtocol({}),
+  toolSystemPromptTemplate: xmlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsXml
 });
-var orchestratorToolMiddleware = createToolMiddleware({
-  protocol: yamlXmlProtocol(),
-  placement: "first",
-  toolSystemPromptTemplate: orchestratorSystemPromptTemplate
+var yamlToolMiddleware = createToolMiddleware({
+  protocol: yamlProtocol({}),
+  toolSystemPromptTemplate: yamlSystemPromptTemplate,
+  toolResponsePromptTemplate: formatToolResponseAsXml
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3797,31 +3821,33 @@ var orchestratorToolMiddleware = createToolMiddleware({
   escapeRegExp,
   extractOnErrorOption,
   extractToolNamesFromOriginalTools,
-  gemmaToolMiddleware,
   getDebugLevel,
   getPotentialStartIndex,
   hasInputProperty,
   hermesToolMiddleware,
   isProtocolFactory,
-  isToolCallContent,
+  isTCMProtocolFactory,
   isToolChoiceActive,
   isToolResultPart,
-  jsonMixProtocol,
+  jsonProtocol,
   logParseFailure,
   logParsedChunk,
   logParsedSummary,
   logRawChunk,
   mergePipelineConfigs,
-  morphXmlProtocol,
-  morphXmlToolMiddleware,
   normalizeCloseTagsHeuristic,
-  orchestratorSystemPromptTemplate,
-  orchestratorToolMiddleware,
   originalToolsSchema,
   parse,
   repairAgainstSchemaHeuristic,
   stringify,
+  toolChoiceStream,
   transform,
-  yamlXmlProtocol
+  transformParams,
+  wrapGenerate,
+  wrapStream,
+  xmlProtocol,
+  xmlToolMiddleware,
+  yamlProtocol,
+  yamlToolMiddleware
 });
 //# sourceMappingURL=index.cjs.map