@ai-sdk-tool/parser 3.0.0 → 3.1.0

package/dist/community.cjs

@@ -1309,7 +1309,7 @@ function parse2(text, optsOrReviver) {
   return parseWithTransform(text, options);
 }
 
-// src/core/protocols/json-mix-protocol.ts
+// src/core/protocols/json-protocol.ts
 function processToolCallJson(toolCallJson, fullMatch, processedElements, options) {
   var _a, _b;
   try {
@@ -1369,7 +1369,6 @@ function flushBuffer(state, controller, toolCallStart) {
   controller.enqueue({
     type: "text-delta",
     id: state.currentTextId,
-    textDelta: deltaContent,
     delta: deltaContent
   });
   state.buffer = "";
@@ -1402,7 +1401,6 @@ function emitIncompleteToolCall(state, controller, toolCallStart) {
   controller.enqueue({
     type: "text-delta",
     id: errorId,
-    textDelta: errorContent,
     delta: errorContent
   });
   controller.enqueue({
@@ -1435,7 +1433,6 @@ function publishText(text, state, controller) {
     controller.enqueue({
       type: "text-delta",
       id: state.currentTextId,
-      textDelta: text,
       delta: text
     });
   }
@@ -1468,7 +1465,6 @@ function emitToolCall(context) {
     controller.enqueue({
       type: "text-delta",
       id: errorId,
-      textDelta: errorContent,
       delta: errorContent
     });
     controller.enqueue({
@@ -1528,19 +1524,15 @@ 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 = {};
@@ -1554,13 +1546,10 @@ var jsonMixProtocol = ({
       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(
@@ -1586,7 +1575,9 @@ var jsonMixProtocol = ({
     }
     return processedElements;
   },
-  createStreamParser({ options }) {
+  createStreamParser({
+    options
+  }) {
     const state = {
       isInsideToolCall: false,
       buffer: "",
@@ -1596,7 +1587,7 @@ var jsonMixProtocol = ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a, _b;
+        var _a;
         if (chunk.type === "finish") {
           handleFinishChunk(state, controller, toolCallStart, chunk);
           return;
@@ -1605,7 +1596,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,
@@ -1632,7 +1623,12 @@ var jsonMixProtocol = ({
   }
 });
 
-// src/core/protocols/morph-xml-protocol.ts
+// src/core/protocols/protocol-interface.ts
+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_:-]/;
@@ -1967,7 +1963,6 @@ function createFlushTextHandler(getCurrentTextId, setCurrentTextId, getHasEmitte
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2129,7 +2124,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;
@@ -2169,12 +2164,7 @@ 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 = {};
@@ -2188,21 +2178,6 @@ var morphXmlProtocol = (protocolOptions) => {
         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) {
@@ -2271,7 +2246,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);
@@ -2280,7 +2255,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);
         },
@@ -2315,13 +2290,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/;
@@ -2542,7 +2511,6 @@ function createFlushTextHandler2(getCurrentTextId, setCurrentTextId, getHasEmitt
       controller.enqueue({
         type: "text-delta",
         id: getCurrentTextId(),
-        textDelta: content,
         delta: content
       });
     }
@@ -2590,15 +2558,10 @@ 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 = {};
@@ -2611,21 +2574,6 @@ var yamlXmlProtocol = (_protocolOptions) => {
       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) {
@@ -2739,7 +2687,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);
@@ -2748,7 +2696,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);
         },
@@ -2784,44 +2732,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) {
@@ -2925,9 +2835,9 @@ function isToolCallContent(content) {
   (typeof content.input === "string" || typeof content.input === "object");
 }
 
-// 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 {
@@ -3090,80 +3000,207 @@ function fixToolCallWithSchema(part, tools) {
     args = tc.input;
   }
   const schema = (_a = tools.find((t) => t.name === tc.toolName)) == null ? void 0 : _a.inputSchema;
-  const coerced = (0, import_rxml4.coerceBySchema)(args, schema);
+  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,
@@ -3187,23 +3224,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);
       }
     })
   );
@@ -3260,7 +3298,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) {
@@ -3403,10 +3441,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"
   );
@@ -3414,9 +3453,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(
@@ -3429,15 +3477,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;
@@ -3476,25 +3524,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,
@@ -3507,10 +3558,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;
 }
@@ -3573,22 +3637,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 }) => {
@@ -3613,85 +3683,38 @@ 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
 });
 
 // src/community/sijawara.ts
 var sijawaraDetailedXmlToolMiddleware = createToolMiddleware({
-  protocol: morphXmlProtocol,
+  protocol: xmlProtocol,
   toolSystemPromptTemplate(tools) {
+    const toolsJson = JSON.stringify(tools);
     return `You have access to callable functions (tools).
     Tool list/context:
-    ${tools}
+    ${toolsJson}
 
     ===============================
     TOOL CALLING FORMAT
@@ -3743,11 +3766,12 @@ var sijawaraDetailedXmlToolMiddleware = createToolMiddleware({
   }
 });
 var sijawaraConciseXmlToolMiddleware = createToolMiddleware({
-  protocol: morphXmlProtocol,
+  protocol: xmlProtocol,
   toolSystemPromptTemplate(tools) {
+    const toolsJson = JSON.stringify(tools);
     return `You have access to callable functions (tools).
     Tool list/context:
-    ${tools}
+    ${toolsJson}
 
     STRICT CALLING RULES:
     - Use the XML-like format for tool calls: