@ai-sdk-tool/parser 2.1.0 → 2.1.1

package/dist/index.js

@@ -4,8 +4,8 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/tool-call-middleware.ts
-import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+// src/stream-handler.ts
+import { generateId } from "@ai-sdk/provider-utils";
 
 // src/utils/dynamic-tool-schema.ts
 function createDynamicIfThenElseSchema(tools) {
@@ -415,7 +415,6 @@ function appendPair(state, obj, key, value) {
 }
 function parsePair(tokens, state, obj) {
   let token = skipPunctuation(tokens, state, [":", "string", "number", "atom"]);
-  let key;
   let value;
   if (token.type !== "string") {
     raiseUnexpected(state, token, "string key");
@@ -465,7 +464,7 @@ function parsePair(tokens, state, obj) {
     }
   }
   checkDuplicates(state, obj, token);
-  key = String(token.value);
+  const key = String(token.value);
   skipColon(tokens, state);
   value = parseAny(tokens, state);
   appendPair(state, obj, key, value);
@@ -636,7 +635,10 @@ function parse(text, optsOrReviver) {
   if (!options.relaxed && !options.warnings && !options.tolerant) {
     if (!options.duplicate) {
     } else {
-      return JSON.parse(text, options.reviver);
+      return JSON.parse(
+        text,
+        options.reviver
+      );
     }
   }
   const lexerToUse = options.relaxed ? lexer : strictLexer;
@@ -656,7 +658,7 @@ function parse(text, optsOrReviver) {
     };
     return parseAny(tokens, state, true);
   } else {
-    const newtext = tokens.reduce((str, token) => {
+    tokens.reduce((str, token) => {
       return str + token.match;
     }, "");
     if (!options.relaxed && !options.warnings && !options.tolerant && options.duplicate) {
@@ -680,8 +682,11 @@ function parse(text, optsOrReviver) {
     } else {
       tokens = lexer(text);
       tokens = stripTrailingComma(tokens);
-      const newtext2 = tokens.reduce((str, token) => str + token.match, "");
-      return JSON.parse(newtext2, options.reviver);
+      const newtext = tokens.reduce((str, token) => str + token.match, "");
+      return JSON.parse(
+        newtext,
+        options.reviver
+      );
     }
   }
 }
@@ -735,7 +740,11 @@ function isToolChoiceActive(params) {
 }
 function getFunctionTools(params) {
   var _a, _b;
-  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_a = params.providerOptions.toolCallMiddleware) == null ? void 0 : _a.toolNames) || [];
+  const functionTools = ((_a = params.tools) != null ? _a : []).filter(
+    (t) => t.type === "function"
+  );
+  if (functionTools.length > 0) return functionTools;
+  const rawToolNames = params.providerOptions && typeof params.providerOptions === "object" && ((_b = params.providerOptions.toolCallMiddleware) == null ? void 0 : _b.toolNames) || [];
   const toStringArray = (val) => Array.isArray(val) ? val.filter(
     (item) => typeof item === "string"
   ) : [];
@@ -748,9 +757,7 @@ function getFunctionTools(params) {
       inputSchema: { type: "object" }
     }));
   }
-  return ((_b = params.tools) != null ? _b : []).filter(
-    (t) => t.type === "function"
-  );
+  return [];
 }
 
 // src/utils/on-error.ts
@@ -763,8 +770,243 @@ function extractOnErrorOption(providerOptions) {
   return void 0;
 }
 
+// src/utils/coercion.ts
+function unwrapJsonSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const s = schema;
+  if (s.jsonSchema && typeof s.jsonSchema === "object") {
+    return unwrapJsonSchema(s.jsonSchema);
+  }
+  return schema;
+}
+function getSchemaType(schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") return void 0;
+  const t = unwrapped.type;
+  if (typeof t === "string") return t;
+  if (Array.isArray(t)) {
+    const preferred = [
+      "object",
+      "array",
+      "boolean",
+      "number",
+      "integer",
+      "string"
+    ];
+    for (const p of preferred) if (t.includes(p)) return p;
+  }
+  const s = unwrapped;
+  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
+    return "object";
+  }
+  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
+    return "array";
+  }
+  return void 0;
+}
+function coerceBySchema(value, schema) {
+  const unwrapped = unwrapJsonSchema(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    if (typeof value === "string") {
+      const s = value.trim();
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+      if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
+        try {
+          const parsed = JSON.parse(s);
+          return coerceBySchema(parsed, void 0);
+        } catch (e) {
+        }
+      }
+    }
+    return value;
+  }
+  const schemaType = getSchemaType(unwrapped);
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "object") {
+      try {
+        let normalized = s.replace(/'/g, '"');
+        normalized = normalized.replace(/^\{\s*\}$/s, "{}");
+        const obj = JSON.parse(normalized);
+        if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+          const props = unwrapped.properties;
+          const out = {};
+          for (const [k, v] of Object.entries(obj)) {
+            const propSchema = props ? props[k] : void 0;
+            out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+          }
+          return out;
+        }
+      } catch (e) {
+      }
+    }
+    if (schemaType === "array") {
+      try {
+        const normalized = s.replace(/'/g, '"');
+        const arr = JSON.parse(normalized);
+        if (Array.isArray(arr)) {
+          const u = unwrapped;
+          const prefixItems = Array.isArray(
+            u.prefixItems
+          ) ? u.prefixItems : void 0;
+          const itemsSchema = u.items;
+          if (prefixItems && arr.length === prefixItems.length) {
+            return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+          }
+          return arr.map((v) => coerceBySchema(v, itemsSchema));
+        }
+      } catch (e) {
+        const csv = s.includes("\n") ? s.split(/\n+/) : s.split(/,\s*/);
+        const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
+        const u = unwrapped;
+        const prefixItems = Array.isArray(
+          u.prefixItems
+        ) ? u.prefixItems : void 0;
+        const itemsSchema = u.items;
+        if (prefixItems && trimmed.length === prefixItems.length) {
+          return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
+        }
+        return trimmed.map((x) => coerceBySchema(x, itemsSchema));
+      }
+    }
+  }
+  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
+    const out = {};
+    const props = unwrapped.properties;
+    for (const [k, v] of Object.entries(value)) {
+      const propSchema = props ? props[k] : void 0;
+      out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
+    }
+    return out;
+  }
+  if (schemaType === "array") {
+    const u = unwrapped;
+    const itemsSchema = u.items;
+    const prefixItems = Array.isArray(
+      u.prefixItems
+    ) ? u.prefixItems : void 0;
+    if (Array.isArray(value)) {
+      if (prefixItems && value.length === prefixItems.length) {
+        return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
+      }
+      return value.map((v) => coerceBySchema(v, itemsSchema));
+    }
+    if (value && typeof value === "object") {
+      const maybe = value;
+      if (Object.prototype.hasOwnProperty.call(maybe, "item")) {
+        const items = maybe.item;
+        const arr = Array.isArray(items) ? items : [items];
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+        }
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
+      }
+      const keys = Object.keys(maybe);
+      if (keys.length === 1) {
+        const singleKey = keys[0];
+        const singleValue = maybe[singleKey];
+        if (Array.isArray(singleValue)) {
+          const coercedArray = singleValue.map(
+            (v) => coerceBySchema(v, itemsSchema)
+          );
+          return coercedArray;
+        }
+      }
+      if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
+        const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
+        if (prefixItems && arr.length === prefixItems.length) {
+          return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
+        }
+        return arr.map((v) => coerceBySchema(v, itemsSchema));
+      }
+    }
+    if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      if (prefixItems && prefixItems.length > 0) {
+        return [coerceBySchema(value, prefixItems[0])];
+      }
+      return [coerceBySchema(value, itemsSchema)];
+    }
+  }
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (schemaType === "boolean") {
+      const lower = s.toLowerCase();
+      if (lower === "true") return true;
+      if (lower === "false") return false;
+    }
+    if (schemaType === "number" || schemaType === "integer") {
+      if (/^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(s)) {
+        const num = Number(s);
+        if (Number.isFinite(num)) return num;
+      }
+    }
+  }
+  return value;
+}
+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 : {})
+  };
+}
+function coerceToolCallInput(part, tools) {
+  return fixToolCallWithSchema(part, tools);
+}
+
+// src/utils/protocol.ts
+function isProtocolFactory(protocol) {
+  return typeof protocol === "function";
+}
+
 // src/stream-handler.ts
-import { generateId } from "@ai-sdk/provider-utils";
+async function wrapStream({
+  protocol,
+  doStream,
+  doGenerate,
+  params
+}) {
+  var _a;
+  if (isToolChoiceActive(params)) {
+    return toolChoiceStream({
+      doGenerate,
+      options: extractOnErrorOption(params.providerOptions)
+    });
+  }
+  const { stream, ...rest } = await doStream();
+  return {
+    stream: stream.pipeThrough(
+      protocol.createStreamParser({
+        tools: getFunctionTools(params),
+        options: {
+          ...extractOnErrorOption(params.providerOptions),
+          ...(_a = params.providerOptions) == null ? void 0 : _a.toolCallMiddleware
+        }
+      })
+    ),
+    ...rest
+  };
+}
 async function toolChoiceStream({
   doGenerate,
   options
@@ -817,283 +1059,337 @@ async function toolChoiceStream({
   };
 }
 
-// src/tool-call-middleware.ts
-function isProtocolFactory(protocol) {
-  return typeof protocol === "function";
+// src/generate-handler.ts
+import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+async function wrapGenerate({
+  protocol,
+  doGenerate,
+  params
+}) {
+  var _a, _b;
+  if (isToolChoiceActive(params)) {
+    const result2 = await doGenerate();
+    let parsed2 = {};
+    const first = (_a = result2.content) == null ? void 0 : _a[0];
+    if (first && first.type === "text") {
+      try {
+        parsed2 = JSON.parse(first.text);
+      } catch (error) {
+        const options = extractOnErrorOption(params.providerOptions);
+        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
+          options,
+          "Failed to parse toolChoice JSON from generated model output",
+          {
+            text: first.text,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        );
+        parsed2 = {};
+      }
+    }
+    const toolCall = {
+      type: "tool-call",
+      toolCallId: generateId2(),
+      toolName: parsed2.name || "unknown",
+      input: JSON.stringify(parsed2.arguments || {})
+    };
+    return {
+      ...result2,
+      content: [toolCall]
+    };
+  }
+  const result = await doGenerate();
+  if (result.content.length === 0) {
+    return result;
+  }
+  const parsed = result.content.flatMap((contentItem) => {
+    var _a2;
+    if (contentItem.type !== "text") {
+      return [contentItem];
+    }
+    return protocol.parseGeneratedText({
+      text: contentItem.text,
+      tools: getFunctionTools(params),
+      options: {
+        ...extractOnErrorOption(params.providerOptions),
+        ...(_a2 = params.providerOptions) == null ? void 0 : _a2.toolCallMiddleware
+      }
+    });
+  });
+  const tools = getFunctionTools(params);
+  const newContent = parsed.map(
+    (part) => coerceToolCallInput(part, tools)
+  );
+  return {
+    ...result,
+    content: newContent
+  };
 }
-function createToolMiddleware({
+
+// src/transform-handler.ts
+async function transformParams({
+  params,
   protocol,
   toolSystemPromptTemplate
 }) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
   const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
-  return {
-    middlewareVersion: "v2",
-    wrapStream: async ({ doStream, doGenerate, params }) => {
-      if (isToolChoiceActive(params)) {
-        return toolChoiceStream({
-          doGenerate,
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      }
-      const { stream, ...rest } = await doStream();
-      return {
-        stream: stream.pipeThrough(
-          resolvedProtocol.createStreamParser({
-            tools: getFunctionTools(params),
-            options: extractOnErrorOption(params.providerOptions)
-          })
-        ),
-        ...rest
-      };
+  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 = ((_c = processedPrompt[0]) == null ? void 0 : _c.role) === "system" ? [
+    {
+      role: "system",
+      content: systemPrompt + "\n\n" + processedPrompt[0].content
     },
-    wrapGenerate: async ({ doGenerate, params }) => {
-      var _a, _b;
-      if (isToolChoiceActive(params)) {
-        const result2 = await doGenerate();
-        let parsed = {};
-        const first = (_a = result2.content) == null ? void 0 : _a[0];
-        if (first && first.type === "text") {
-          try {
-            parsed = JSON.parse(first.text);
-          } catch (error) {
-            const options = extractOnErrorOption(params.providerOptions);
-            (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(
-              options,
-              "Failed to parse toolChoice JSON from generated model output",
-              {
-                text: first.text,
-                error: error instanceof Error ? error.message : String(error)
-              }
-            );
-            parsed = {};
-          }
+    ...processedPrompt.slice(1)
+  ] : [
+    {
+      role: "system",
+      content: systemPrompt
+    },
+    ...processedPrompt
+  ];
+  const baseReturnParams = {
+    ...params,
+    prompt: finalPrompt,
+    tools: [],
+    toolChoice: void 0,
+    providerOptions: {
+      ...params.providerOptions || {},
+      toolCallMiddleware: {
+        ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
+        toolNames: functionTools.map((t) => t.name)
+      }
+    }
+  };
+  if (((_d = params.toolChoice) == null ? void 0 : _d.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 (((_e = params.toolChoice) == null ? void 0 : _e.type) === "tool") {
+    const selectedToolName = params.toolChoice.toolName;
+    const providerDefinedMatch = ((_f = params.tools) != null ? _f : []).find((t) => {
+      if (t.type === "function") return false;
+      const anyTool = t;
+      return anyTool.id === selectedToolName || anyTool.name === selectedToolName;
+    });
+    if (providerDefinedMatch) {
+      throw new Error(
+        "Provider-defined tools are not supported by this middleware. Please use custom tools."
+      );
+    }
+    const selectedTool = ((_g = params.tools) != null ? _g : []).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 || {},
+          toolChoice: params.toolChoice
         }
-        return {
-          ...result2,
-          content: [
-            {
-              type: "tool-call",
-              toolCallId: generateId2(),
-              toolName: parsed.name || "unknown",
-              input: JSON.stringify(parsed.arguments || {})
-            }
-          ]
-        };
       }
-      const result = await doGenerate();
-      if (result.content.length === 0) {
-        return result;
+    };
+  }
+  if (((_h = params.toolChoice) == null ? void 0 : _h.type) === "required") {
+    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" }
+        }
       }
-      const newContent = result.content.flatMap((contentItem) => {
-        if (contentItem.type !== "text") {
-          return [contentItem];
+    };
+  }
+  return baseReturnParams;
+}
+function convertToolPrompt(prompt, resolvedProtocol, providerOptions) {
+  const processedPrompt = prompt.map((message) => {
+    var _a;
+    if (message.role === "assistant") {
+      const newContent = [];
+      for (const content of message.content) {
+        if (isToolCallContent(content)) {
+          newContent.push({
+            type: "text",
+            text: resolvedProtocol.formatToolCall(content)
+          });
+        } else if (content.type === "text") {
+          newContent.push(content);
+        } else if (content.type === "reasoning") {
+          newContent.push(content);
+        } 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 }
+          );
+          newContent.push({
+            type: "text",
+            text: JSON.stringify(content)
+          });
         }
-        return resolvedProtocol.parseGeneratedText({
-          text: contentItem.text,
-          tools: getFunctionTools(params),
-          options: extractOnErrorOption(params.providerOptions)
-        });
-      });
+      }
+      const onlyText = newContent.every((c) => c.type === "text");
+      const condensedAssistant = onlyText ? [
+        {
+          type: "text",
+          text: newContent.map((c) => c.text).join("\n")
+        }
+      ] : newContent;
+      return { role: "assistant", content: condensedAssistant };
+    }
+    if (message.role === "tool") {
       return {
-        ...result,
-        content: newContent
+        role: "user",
+        // Map tool results to text response blocks, then condense into a single text block
+        content: [
+          {
+            type: "text",
+            text: message.content.map(
+              (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
+                toolResult
+              )
+            ).join("\n")
+          }
+        ]
       };
-    },
-    transformParams: async ({ params }) => {
-      var _a, _b, _c, _d, _e, _f;
-      const convertToolPrompt = (prompt) => {
-        const processedPrompt2 = prompt.map((message) => {
-          var _a2;
-          if (message.role === "assistant") {
-            const newContent = [];
-            for (const content of message.content) {
-              if (isToolCallContent(content)) {
-                newContent.push({
-                  type: "text",
-                  text: resolvedProtocol.formatToolCall(content)
-                });
-              } else if (content.type === "text") {
-                newContent.push(content);
-              } else if (content.type === "reasoning") {
-                newContent.push(content);
-              } else {
-                const options = extractOnErrorOption(params.providerOptions);
-                (_a2 = options == null ? void 0 : options.onError) == null ? void 0 : _a2.call(
-                  options,
-                  "tool-call-middleware: unknown assistant content; stringifying for provider compatibility",
-                  { content }
-                );
-                newContent.push({
-                  type: "text",
-                  text: JSON.stringify(content)
-                });
+    }
+    return message;
+  });
+  for (let i = 0; i < processedPrompt.length; i++) {
+    const msg = processedPrompt[i];
+    if (Array.isArray(msg.content)) {
+      const allText = msg.content.every(
+        (c) => (c == null ? void 0 : c.type) === "text"
+      );
+      if (allText && msg.content.length > 1) {
+        const joinedText = msg.content.map((c) => c.text).join("\n");
+        if (msg.role === "system") {
+          processedPrompt[i] = {
+            role: "system",
+            content: joinedText
+          };
+        } else if (msg.role === "assistant") {
+          processedPrompt[i] = {
+            role: "assistant",
+            content: [
+              {
+                type: "text",
+                text: joinedText
               }
-            }
-            const onlyText = newContent.every((c) => c.type === "text");
-            const condensedAssistant = onlyText ? [
+            ]
+          };
+        } else {
+          processedPrompt[i] = {
+            role: "user",
+            content: [
               {
                 type: "text",
-                text: newContent.map((c) => c.text).join("\n")
+                text: joinedText
               }
-            ] : newContent;
-            return { role: "assistant", content: condensedAssistant };
-          }
-          if (message.role === "tool") {
-            return {
-              role: "user",
-              // Map tool results to text response blocks, then condense into a single text block
-              content: [
-                {
-                  type: "text",
-                  text: message.content.map(
-                    (toolResult) => isToolResultPart(toolResult) ? resolvedProtocol.formatToolResponse(toolResult) : resolvedProtocol.formatToolResponse(
-                      toolResult
-                    )
-                  ).join("\n")
-                }
-              ]
-            };
-          }
-          return message;
-        });
-        for (let i = 0; i < processedPrompt2.length; i++) {
-          const msg = processedPrompt2[i];
-          if (Array.isArray(msg.content)) {
-            const allText = msg.content.every((c) => (c == null ? void 0 : c.type) === "text");
-            if (allText && msg.content.length > 1) {
-              processedPrompt2[i] = {
-                role: msg.role,
-                content: [
-                  {
-                    type: "text",
-                    text: msg.content.map((c) => c.text).join("\n")
-                  }
-                ]
-              };
-            }
-          }
-        }
-        for (let i = processedPrompt2.length - 1; i > 0; i--) {
-          const current = processedPrompt2[i];
-          const prev = processedPrompt2[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");
-            processedPrompt2[i - 1] = {
-              role: "user",
-              content: [
-                { type: "text", text: prevContent + "\n" + currentContent }
-              ]
-            };
-            processedPrompt2.splice(i, 1);
-          }
-        }
-        return processedPrompt2;
-      };
-      const functionTools = ((_a = params.tools) != null ? _a : []).filter(
-        (t) => t.type === "function"
-      );
-      const systemPrompt = resolvedProtocol.formatTools({
-        tools: functionTools,
-        toolSystemPromptTemplate
-      });
-      const processedPrompt = convertToolPrompt(params.prompt);
-      const finalPrompt = ((_b = processedPrompt[0]) == null ? void 0 : _b.role) === "system" ? [
-        {
-          role: "system",
-          content: systemPrompt + "\n\n" + processedPrompt[0].content
-        },
-        ...processedPrompt.slice(1)
-      ] : [
-        {
-          role: "system",
-          content: systemPrompt
-        },
-        ...processedPrompt
-      ];
-      const baseReturnParams = {
-        ...params,
-        prompt: finalPrompt,
-        tools: [],
-        toolChoice: void 0,
-        providerOptions: {
-          ...params.providerOptions || {},
-          toolCallMiddleware: {
-            ...params.providerOptions && typeof params.providerOptions === "object" && params.providerOptions.toolCallMiddleware || {},
-            toolNames: functionTools.map((t) => t.name)
-          }
-        }
-      };
-      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") {
-        const selectedToolName = params.toolChoice.toolName;
-        const selectedTool = (_e = params.tools) == null ? void 0 : _e.find(
-          (tool) => tool.type === "function" ? tool.name === selectedToolName : tool.id === selectedToolName
-        );
-        if (!selectedTool) {
-          throw new Error(
-            `Tool with name '${selectedToolName}' not found in params.tools.`
-          );
-        }
-        if (selectedTool.type === "provider-defined") {
-          throw new Error(
-            "Provider-defined tools are not supported by this middleware. Please use custom tools."
-          );
+            ]
+          };
         }
-        return {
-          ...baseReturnParams,
-          responseFormat: {
-            type: "json",
-            schema: {
-              type: "object",
-              properties: {
-                name: {
-                  const: selectedTool.name
-                },
-                arguments: selectedTool.inputSchema
-              },
-              required: ["name", "arguments"]
-            },
-            name: selectedTool.name,
-            description: selectedTool.type === "function" && typeof selectedTool.description === "string" ? selectedTool.description : void 0
-          },
-          providerOptions: {
-            ...baseReturnParams.providerOptions || {},
-            toolCallMiddleware: {
-              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-              toolChoice: params.toolChoice
-            }
-          }
-        };
       }
-      if (((_f = params.toolChoice) == null ? void 0 : _f.type) === "required") {
-        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(
-              params.tools.filter((t) => t.type === "function")
-            )
-          },
-          providerOptions: {
-            ...baseReturnParams.providerOptions || {},
-            toolCallMiddleware: {
-              ...baseReturnParams.providerOptions && typeof baseReturnParams.providerOptions === "object" && baseReturnParams.providerOptions.toolCallMiddleware || {},
-              toolChoice: { type: "required" }
-            }
-          }
-        };
+    }
+  }
+  for (let i = processedPrompt.length - 1; i > 0; i--) {
+    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 + "\n" + currentContent }]
+      };
+      processedPrompt.splice(i, 1);
+    }
+  }
+  return processedPrompt;
+}
+
+// src/tool-call-middleware.ts
+function createToolMiddleware({
+  protocol,
+  toolSystemPromptTemplate
+}) {
+  const resolvedProtocol = isProtocolFactory(protocol) ? protocol() : protocol;
+  return {
+    middlewareVersion: "v2",
+    wrapStream: async ({ doStream, doGenerate, params }) => {
+      if (isToolChoiceActive(params)) {
+        return toolChoiceStream({
+          doGenerate,
+          options: extractOnErrorOption(params.providerOptions)
+        });
+      } else {
+        return wrapStream({
+          protocol: resolvedProtocol,
+          doStream,
+          doGenerate,
+          params
+        });
       }
-      return baseReturnParams;
+    },
+    wrapGenerate: async ({ doGenerate, params }) => wrapGenerate({
+      protocol: resolvedProtocol,
+      doGenerate,
+      params
+    }),
+    transformParams: async ({
+      params
+    }) => {
+      return transformParams({
+        protocol: resolvedProtocol,
+        toolSystemPromptTemplate,
+        params
+      });
     }
   };
 }
@@ -1334,7 +1630,7 @@ var xmlProtocol = () => ({
     const toolsForPrompt = (tools || []).map((tool) => ({
       name: tool.name,
       description: tool.description,
-      parameters: tool.inputSchema
+      parameters: unwrapJsonSchema(tool.inputSchema)
     }));
     return toolSystemPromptTemplate(JSON.stringify(toolsForPrompt));
   },
@@ -1367,7 +1663,8 @@ var xmlProtocol = () => ({
     return xmlContent;
   },
   parseGeneratedText({ text, tools, options }) {
-    var _a, _b;
+    var _a, _b, _c;
+    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
     if (toolNames.length === 0) {
       return [{ type: "text", text }];
@@ -1405,17 +1702,87 @@ var xmlProtocol = () => ({
           if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
             val = v == null ? void 0 : v["#text"];
           }
+          if (Array.isArray(v)) {
+            val = v.map((item) => {
+              if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                const textVal = item == null ? void 0 : item["#text"];
+                return typeof textVal === "string" ? textVal.trim() : textVal;
+              }
+              return typeof item === "string" ? item.trim() : item;
+            });
+          } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
+            const obj = v;
+            const keys = Object.keys(obj);
+            if (keys.length === 1 && keys[0] === "item") {
+              const itemValue = obj.item;
+              if (Array.isArray(itemValue)) {
+                val = itemValue.map((item) => {
+                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                    const textVal = item == null ? void 0 : item["#text"];
+                    const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
+                    if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
+                      const num = Number(trimmed2);
+                      if (Number.isFinite(num)) return num;
+                    }
+                    return trimmed2;
+                  }
+                  const trimmed = typeof item === "string" ? item.trim() : item;
+                  if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                    const num = Number(trimmed);
+                    if (Number.isFinite(num)) return num;
+                  }
+                  return trimmed;
+                });
+              } else {
+                const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+                if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                  const num = Number(trimmed);
+                  if (Number.isFinite(num)) {
+                    val = num;
+                  } else {
+                    val = trimmed;
+                  }
+                } else {
+                  val = trimmed;
+                }
+              }
+            } else {
+              const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
+                const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
+                return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+              })();
+              if (isIndexedTuple) {
+                const sortedKeys = keys.sort(
+                  (a, b) => parseInt(a) - parseInt(b)
+                );
+                val = sortedKeys.map((key) => {
+                  const item = obj[key];
+                  if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                    const textVal = item == null ? void 0 : item["#text"];
+                    return typeof textVal === "string" ? textVal.trim() : textVal;
+                  }
+                  return typeof item === "string" ? item.trim() : item;
+                });
+              } else {
+                val = v;
+              }
+            }
+          }
           args[k] = typeof val === "string" ? val.trim() : val;
         }
+        const originalSchema = originalSchemas[toolName];
+        const fallbackSchema = (_b = tools.find((t) => t.name === toolName)) == null ? void 0 : _b.inputSchema;
+        const schema = originalSchema || fallbackSchema;
+        const coercedArgs = coerceBySchema(args, schema);
         processedElements.push({
           type: "tool-call",
           toolCallId: generateId4(),
           toolName,
-          input: JSON.stringify(args)
+          input: JSON.stringify(coercedArgs)
         });
       } catch (error) {
         const message = `Could not process XML tool call, keeping original text: ${match[0]}`;
-        (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, message, { toolCall: match[0], toolName, error });
+        (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, message, { toolCall: match[0], toolName, error });
         processedElements.push({ type: "text", text: match[0] });
       }
       currentIndex = startIndex + match[0].length;
@@ -1429,6 +1796,7 @@ var xmlProtocol = () => ({
     return processedElements;
   },
   createStreamParser({ tools, options }) {
+    const originalSchemas = (options == null ? void 0 : options.originalToolSchemas) || {};
     const toolNames = tools.map((t) => t.name).filter((name) => name != null);
     let buffer = "";
     let currentToolCall = null;
@@ -1456,7 +1824,7 @@ var xmlProtocol = () => ({
     };
     return new TransformStream({
       transform(chunk, controller) {
-        var _a;
+        var _a, _b;
         if (chunk.type !== "text-delta") {
           if (buffer) flushText(controller);
           controller.enqueue(chunk);
@@ -1485,14 +1853,86 @@ var xmlProtocol = () => ({
                   if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "#text")) {
                     val = v == null ? void 0 : v["#text"];
                   }
+                  if (Array.isArray(v)) {
+                    val = v.map((item) => {
+                      if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                        const textVal = item == null ? void 0 : item["#text"];
+                        return typeof textVal === "string" ? textVal.trim() : textVal;
+                      }
+                      return typeof item === "string" ? item.trim() : item;
+                    });
+                  } else if (v && typeof v === "object" && !Object.prototype.hasOwnProperty.call(v, "#text")) {
+                    const obj = v;
+                    const keys = Object.keys(obj);
+                    if (keys.length === 1 && keys[0] === "item") {
+                      const itemValue = obj.item;
+                      if (Array.isArray(itemValue)) {
+                        val = itemValue.map((item) => {
+                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                            const textVal = item == null ? void 0 : item["#text"];
+                            const trimmed2 = typeof textVal === "string" ? textVal.trim() : textVal;
+                            if (typeof trimmed2 === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed2)) {
+                              const num = Number(trimmed2);
+                              if (Number.isFinite(num)) return num;
+                            }
+                            return trimmed2;
+                          }
+                          const trimmed = typeof item === "string" ? item.trim() : item;
+                          if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                            const num = Number(trimmed);
+                            if (Number.isFinite(num)) return num;
+                          }
+                          return trimmed;
+                        });
+                      } else {
+                        const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
+                        if (typeof trimmed === "string" && /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/.test(trimmed)) {
+                          const num = Number(trimmed);
+                          if (Number.isFinite(num)) {
+                            val = num;
+                          } else {
+                            val = trimmed;
+                          }
+                        } else {
+                          val = trimmed;
+                        }
+                      }
+                    } else {
+                      const isIndexedTuple = keys.length > 0 && keys.every((key) => /^\d+$/.test(key)) && (() => {
+                        const indices = keys.map((k2) => parseInt(k2)).sort((a, b) => a - b);
+                        return indices[0] === 0 && indices.every((val2, idx) => val2 === idx);
+                      })();
+                      if (isIndexedTuple) {
+                        const sortedKeys = keys.sort(
+                          (a, b) => parseInt(a) - parseInt(b)
+                        );
+                        val = sortedKeys.map((key) => {
+                          const item = obj[key];
+                          if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, "#text")) {
+                            const textVal = item == null ? void 0 : item["#text"];
+                            return typeof textVal === "string" ? textVal.trim() : textVal;
+                          }
+                          return typeof item === "string" ? item.trim() : item;
+                        });
+                      } else {
+                        val = v;
+                      }
+                    }
+                  }
                   args[k] = typeof val === "string" ? val.trim() : val;
                 }
+                const originalSchema = originalSchemas[currentToolCall.name];
+                const fallbackSchema = (_b = tools.find(
+                  (t) => t.name === currentToolCall.name
+                )) == null ? void 0 : _b.inputSchema;
+                const toolSchema = originalSchema || fallbackSchema;
+                const coercedArgs = coerceBySchema(args, toolSchema);
                 flushText(controller);
                 controller.enqueue({
                   type: "tool-call",
                   toolCallId: generateId4(),
                   toolName: currentToolCall.name,
-                  input: JSON.stringify(args)
+                  input: JSON.stringify(coercedArgs)
                 });
               } catch (e) {
                 const originalCallText = `<${currentToolCall.name}>${toolContent}${endTag}`;
@@ -1596,13 +2036,14 @@ For each function call return a json object with function name and arguments wit
 var xmlToolMiddleware = createToolMiddleware({
   protocol: xmlProtocol,
   toolSystemPromptTemplate(tools) {
-    return `You are KorinAI, a function-calling AI model.
+    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>
-For each function call return a tool call in an XML tag that matches the tool's name, and nothing else.
-Example KorinAI-style call (text form):
+For a function call, return exactly one XML element whose tag name matches the tool's name, and nothing else.
+When an argument is an array, write each item inside a single element on one line separated by commas (or provide a JSON-like list). When an argument is an object, provide a JSON-like value.
+Examples:
 <get_weather>
 <location>
 San Fransisco
@@ -1611,10 +2052,14 @@ San Fransisco
   }
 });
 export {
+  coerceBySchema,
   createToolMiddleware,
+  fixToolCallWithSchema,
   gemmaToolMiddleware,
+  getSchemaType,
   hermesToolMiddleware,
   jsonMixProtocol,
+  unwrapJsonSchema,
   xmlProtocol,
   xmlToolMiddleware
 };