ai 5.0.0-beta.28 → 5.0.0-beta.29

package/dist/index.mjs

@@ -8,8 +8,10 @@ var __export = (target, all) => {
 import {
   asSchema as asSchema5,
   createIdGenerator as createIdGenerator5,
+  dynamicTool as dynamicTool2,
   generateId as generateId2,
-  jsonSchema as jsonSchema2
+  jsonSchema as jsonSchema2,
+  tool as tool2
 } from "@ai-sdk/provider-utils";
 
 // src/generate-text/generate-text.ts
@@ -874,6 +876,7 @@ function prepareToolsAndToolChoice({
       const toolType = tool3.type;
       switch (toolType) {
         case void 0:
+        case "dynamic":
         case "function":
           return {
             type: "function",
@@ -1703,7 +1706,15 @@ async function doParseToolCall({
       cause: parseResult.error
     });
   }
-  return {
+  return tool3.type === "dynamic" ? {
+    type: "tool-call",
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    input: parseResult.value,
+    providerExecuted: toolCall.providerExecuted,
+    providerMetadata: toolCall.providerMetadata,
+    dynamic: true
+  } : {
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName,
@@ -2246,7 +2257,8 @@ async function executeTools({
               toolCallId,
               toolName,
               input,
-              output: result
+              output: result,
+              dynamic: tool3.type === "dynamic"
             };
           } catch (error) {
             recordErrorOnSpan(span, error);
@@ -2255,7 +2267,8 @@ async function executeTools({
               toolCallId,
               toolName,
               input,
-              error
+              error,
+              dynamic: tool3.type === "dynamic"
             };
           }
         }
@@ -2387,7 +2400,8 @@ function asContent({
               toolName: part.toolName,
               input: toolCall.input,
               error: part.result,
-              providerExecuted: true
+              providerExecuted: true,
+              dynamic: toolCall.dynamic
             };
           }
           return {
@@ -2396,7 +2410,8 @@ function asContent({
             toolName: part.toolName,
             input: toolCall.input,
             output: part.result,
-            providerExecuted: true
+            providerExecuted: true,
+            dynamic: toolCall.dynamic
           };
         }
       }
@@ -2580,7 +2595,8 @@ var uiMessageChunkSchema = z7.union([
     type: z7.literal("tool-input-start"),
     toolCallId: z7.string(),
     toolName: z7.string(),
-    providerExecuted: z7.boolean().optional()
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional()
   }),
   z7.strictObject({
     type: z7.literal("tool-input-delta"),
@@ -2593,19 +2609,22 @@ var uiMessageChunkSchema = z7.union([
     toolName: z7.string(),
     input: z7.unknown(),
     providerExecuted: z7.boolean().optional(),
-    providerMetadata: providerMetadataSchema.optional()
+    providerMetadata: providerMetadataSchema.optional(),
+    dynamic: z7.boolean().optional()
   }),
   z7.strictObject({
     type: z7.literal("tool-output-available"),
     toolCallId: z7.string(),
     output: z7.unknown(),
-    providerExecuted: z7.boolean().optional()
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional()
   }),
   z7.strictObject({
     type: z7.literal("tool-output-error"),
     toolCallId: z7.string(),
     errorText: z7.string(),
-    providerExecuted: z7.boolean().optional()
+    providerExecuted: z7.boolean().optional(),
+    dynamic: z7.boolean().optional()
   }),
   z7.strictObject({
     type: z7.literal("reasoning"),
@@ -3094,7 +3113,33 @@ function processUIMessageStream({
       async transform(chunk, controller) {
         await runUpdateMessageJob(async ({ state, write }) => {
           var _a16, _b, _c, _d;
-          function updateToolInvocationPart(options) {
+          function getToolInvocation(toolCallId) {
+            const toolInvocations = state.message.parts.filter(isToolUIPart);
+            const toolInvocation = toolInvocations.find(
+              (invocation) => invocation.toolCallId === toolCallId
+            );
+            if (toolInvocation == null) {
+              throw new Error(
+                "tool-output-error must be preceded by a tool-input-available"
+              );
+            }
+            return toolInvocation;
+          }
+          function getDynamicToolInvocation(toolCallId) {
+            const toolInvocations = state.message.parts.filter(
+              (part) => part.type === "dynamic-tool"
+            );
+            const toolInvocation = toolInvocations.find(
+              (invocation) => invocation.toolCallId === toolCallId
+            );
+            if (toolInvocation == null) {
+              throw new Error(
+                "tool-output-error must be preceded by a tool-input-available"
+              );
+            }
+            return toolInvocation;
+          }
+          function updateToolPart(options) {
             var _a17;
             const part = state.message.parts.find(
               (part2) => isToolUIPart(part2) && part2.toolCallId === options.toolCallId
@@ -3123,6 +3168,34 @@ function processUIMessageStream({
               });
             }
           }
+          function updateDynamicToolPart(options) {
+            const part = state.message.parts.find(
+              (part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId
+            );
+            const anyOptions = options;
+            const anyPart = part;
+            if (part != null) {
+              part.state = options.state;
+              anyPart.toolName = options.toolName;
+              anyPart.input = anyOptions.input;
+              anyPart.output = anyOptions.output;
+              anyPart.errorText = anyOptions.errorText;
+              if (anyOptions.providerMetadata != null && part.state === "input-available") {
+                part.callProviderMetadata = anyOptions.providerMetadata;
+              }
+            } else {
+              state.message.parts.push({
+                type: "dynamic-tool",
+                toolName: options.toolName,
+                toolCallId: options.toolCallId,
+                state: options.state,
+                input: anyOptions.input,
+                output: anyOptions.output,
+                errorText: anyOptions.errorText,
+                ...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
+              });
+            }
+          }
           async function updateMessageMetadata(metadata) {
             if (metadata != null) {
               const mergedMetadata = state.message.metadata != null ? mergeObjects(state.message.metadata, metadata) : metadata;
@@ -3227,15 +3300,25 @@ function processUIMessageStream({
               state.partialToolCalls[chunk.toolCallId] = {
                 text: "",
                 toolName: chunk.toolName,
-                index: toolInvocations.length
+                index: toolInvocations.length,
+                dynamic: chunk.dynamic
               };
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-                state: "input-streaming",
-                input: void 0,
-                providerExecuted: chunk.providerExecuted
-              });
+              if (chunk.dynamic) {
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "input-streaming",
+                  input: void 0
+                });
+              } else {
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "input-streaming",
+                  input: void 0,
+                  providerExecuted: chunk.providerExecuted
+                });
+              }
               write();
               break;
             }
@@ -3245,26 +3328,45 @@ function processUIMessageStream({
               const { value: partialArgs } = await parsePartialJson(
                 partialToolCall.text
               );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: partialToolCall.toolName,
-                state: "input-streaming",
-                input: partialArgs
-              });
+              if (partialToolCall.dynamic) {
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: partialToolCall.toolName,
+                  state: "input-streaming",
+                  input: partialArgs
+                });
+              } else {
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: partialToolCall.toolName,
+                  state: "input-streaming",
+                  input: partialArgs
+                });
+              }
               write();
               break;
             }
             case "tool-input-available": {
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName: chunk.toolName,
-                state: "input-available",
-                input: chunk.input,
-                providerExecuted: chunk.providerExecuted,
-                providerMetadata: chunk.providerMetadata
-              });
+              if (chunk.dynamic) {
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "input-available",
+                  input: chunk.input,
+                  providerMetadata: chunk.providerMetadata
+                });
+              } else {
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: chunk.toolName,
+                  state: "input-available",
+                  input: chunk.input,
+                  providerExecuted: chunk.providerExecuted,
+                  providerMetadata: chunk.providerMetadata
+                });
+              }
               write();
-              if (onToolCall && !chunk.providerExecuted) {
+              if (onToolCall && !chunk.providerExecuted && !chunk.dynamic) {
                 await onToolCall({
                   toolCall: chunk
                 });
@@ -3272,56 +3374,53 @@ function processUIMessageStream({
               break;
             }
             case "tool-output-available": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              if (toolInvocations == null) {
-                throw new Error("tool_result must be preceded by a tool_call");
-              }
-              const toolInvocationIndex = toolInvocations.findIndex(
-                (invocation) => invocation.toolCallId === chunk.toolCallId
-              );
-              if (toolInvocationIndex === -1) {
-                throw new Error(
-                  "tool_result must be preceded by a tool_call with the same toolCallId"
+              if (chunk.dynamic) {
+                const toolInvocation = getDynamicToolInvocation(
+                  chunk.toolCallId
                 );
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: toolInvocation.toolName,
+                  state: "output-available",
+                  input: toolInvocation.input,
+                  output: chunk.output
+                });
+              } else {
+                const toolInvocation = getToolInvocation(chunk.toolCallId);
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: getToolName(toolInvocation),
+                  state: "output-available",
+                  input: toolInvocation.input,
+                  output: chunk.output,
+                  providerExecuted: chunk.providerExecuted
+                });
               }
-              const toolName = getToolName(
-                toolInvocations[toolInvocationIndex]
-              );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName,
-                state: "output-available",
-                input: toolInvocations[toolInvocationIndex].input,
-                output: chunk.output,
-                providerExecuted: chunk.providerExecuted
-              });
               write();
               break;
             }
             case "tool-output-error": {
-              const toolInvocations = state.message.parts.filter(isToolUIPart);
-              if (toolInvocations == null) {
-                throw new Error("tool_result must be preceded by a tool_call");
-              }
-              const toolInvocationIndex = toolInvocations.findIndex(
-                (invocation) => invocation.toolCallId === chunk.toolCallId
-              );
-              if (toolInvocationIndex === -1) {
-                throw new Error(
-                  "tool_result must be preceded by a tool_call with the same toolCallId"
+              if (chunk.dynamic) {
+                const toolInvocation = getDynamicToolInvocation(
+                  chunk.toolCallId
                 );
+                updateDynamicToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: toolInvocation.toolName,
+                  state: "output-error",
+                  input: toolInvocation.input,
+                  errorText: chunk.errorText
+                });
+              } else {
+                const toolInvocation = getToolInvocation(chunk.toolCallId);
+                updateToolPart({
+                  toolCallId: chunk.toolCallId,
+                  toolName: getToolName(toolInvocation),
+                  state: "output-error",
+                  input: toolInvocation.input,
+                  errorText: chunk.errorText
+                });
               }
-              const toolName = getToolName(
-                toolInvocations[toolInvocationIndex]
-              );
-              updateToolInvocationPart({
-                toolCallId: chunk.toolCallId,
-                toolName,
-                state: "output-error",
-                input: toolInvocations[toolInvocationIndex].input,
-                errorText: chunk.errorText,
-                providerExecuted: chunk.providerExecuted
-              });
               write();
               break;
             }
@@ -4572,7 +4671,10 @@ var DefaultStreamTextResult = class {
                           abortSignal
                         });
                       }
-                      controller.enqueue(chunk);
+                      controller.enqueue({
+                        ...chunk,
+                        dynamic: (tool3 == null ? void 0 : tool3.type) === "dynamic"
+                      });
                       break;
                     }
                     case "tool-input-end": {
@@ -4952,7 +5054,8 @@ var DefaultStreamTextResult = class {
                 type: "tool-input-start",
                 toolCallId: part.id,
                 toolName: part.toolName,
-                providerExecuted: part.providerExecuted
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
               });
               break;
             }
@@ -4970,8 +5073,9 @@ var DefaultStreamTextResult = class {
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
                 input: part.input,
-                providerExecuted: part.providerExecuted,
-                providerMetadata: part.providerMetadata
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.providerMetadata != null ? { providerMetadata: part.providerMetadata } : {},
+                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
               });
               break;
             }
@@ -4980,7 +5084,8 @@ var DefaultStreamTextResult = class {
                 type: "tool-output-available",
                 toolCallId: part.toolCallId,
                 output: part.output,
-                providerExecuted: part.providerExecuted
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
               });
               break;
             }
@@ -4989,7 +5094,8 @@ var DefaultStreamTextResult = class {
                 type: "tool-output-error",
                 toolCallId: part.toolCallId,
                 errorText: onError(part.error),
-                providerExecuted: part.providerExecuted
+                ...part.providerExecuted != null ? { providerExecuted: part.providerExecuted } : {},
+                ...part.dynamic != null ? { dynamic: part.dynamic } : {}
               });
               break;
             }
@@ -7687,8 +7793,11 @@ var DefaultProviderRegistry = class {
 };
 
 // src/tool/mcp/mcp-client.ts
-import { jsonSchema } from "@ai-sdk/provider-utils";
-import { tool } from "@ai-sdk/provider-utils";
+import {
+  dynamicTool,
+  jsonSchema,
+  tool
+} from "@ai-sdk/provider-utils";
 
 // src/tool/mcp/mcp-sse-transport.ts
 import { EventSourceParserStream } from "@ai-sdk/provider-utils";
@@ -7698,9 +7807,10 @@ import { z as z9 } from "zod/v4";
 
 // src/tool/mcp/types.ts
 import { z as z8 } from "zod/v4";
-var LATEST_PROTOCOL_VERSION = "2025-03-26";
+var LATEST_PROTOCOL_VERSION = "2025-06-18";
 var SUPPORTED_PROTOCOL_VERSIONS = [
   LATEST_PROTOCOL_VERSION,
+  "2025-03-26",
   "2024-11-05"
 ];
 var ClientOrServerImplementationSchema = z8.object({
@@ -8187,22 +8297,23 @@ var MCPClient = class {
           continue;
         }
         const self = this;
-        const toolWithExecute = tool({
+        const execute = async (args, options) => {
+          var _a17;
+          (_a17 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a17.throwIfAborted();
+          return self.callTool({ name: name16, args, options });
+        };
+        const toolWithExecute = schemas === "automatic" ? dynamicTool({
           description,
-          inputSchema: schemas === "automatic" ? jsonSchema({
+          inputSchema: jsonSchema({
             ...inputSchema,
             properties: (_a16 = inputSchema.properties) != null ? _a16 : {},
             additionalProperties: false
-          }) : schemas[name16].inputSchema,
-          execute: async (args, options) => {
-            var _a17;
-            (_a17 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a17.throwIfAborted();
-            return self.callTool({
-              name: name16,
-              args,
-              options
-            });
-          }
+          }),
+          execute
+        }) : tool({
+          description,
+          inputSchema: schemas[name16].inputSchema,
+          execute
         });
         tools[name16] = toolWithExecute;
       }
@@ -8248,11 +8359,6 @@ var MCPClient = class {
   }
 };
 
-// src/tool/index.ts
-import {
-  tool as tool2
-} from "@ai-sdk/provider-utils";
-
 // src/error/no-transcript-generated-error.ts
 import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
 var NoTranscriptGeneratedError = class extends AISDKError21 {
@@ -8994,6 +9100,22 @@ function convertToModelMessages(messages, options) {
                   text: part.text,
                   providerOptions: part.providerMetadata
                 });
+              } else if (part.type === "dynamic-tool") {
+                const toolName = part.toolName;
+                if (part.state === "input-streaming") {
+                  throw new MessageConversionError({
+                    originalMessage: message,
+                    message: `incomplete tool input is not supported: ${part.toolCallId}`
+                  });
+                } else {
+                  content.push({
+                    type: "tool-call",
+                    toolCallId: part.toolCallId,
+                    toolName,
+                    input: part.input,
+                    ...part.callProviderMetadata != null ? { providerOptions: part.callProviderMetadata } : {}
+                  });
+                }
               } else if (isToolUIPart(part)) {
                 const toolName = getToolName(part);
                 if (part.state === "input-streaming") {
@@ -9032,7 +9154,9 @@ function convertToModelMessages(messages, options) {
               role: "assistant",
               content
             });
-            const toolParts = block.filter(isToolUIPart).filter((part) => part.providerExecuted !== true);
+            const toolParts = block.filter(
+              (part) => isToolUIPart(part) && part.providerExecuted !== true || part.type === "dynamic-tool"
+            );
             if (toolParts.length > 0) {
               modelMessages.push({
                 role: "tool",
@@ -9041,7 +9165,7 @@ function convertToModelMessages(messages, options) {
                   switch (toolPart.state) {
                     case "output-error":
                     case "output-available": {
-                      const toolName = getToolName(toolPart);
+                      const toolName = toolPart.type === "dynamic-tool" ? toolPart.toolName : getToolName(toolPart);
                       return {
                         type: "tool-result",
                         toolCallId: toolPart.toolCallId,
@@ -9068,7 +9192,7 @@ function convertToModelMessages(messages, options) {
           var processBlock = processBlock2;
           let block = [];
           for (const part of message.parts) {
-            if (part.type === "text" || part.type === "reasoning" || part.type === "file" || isToolUIPart(part)) {
+            if (part.type === "text" || part.type === "reasoning" || part.type === "file" || part.type === "dynamic-tool" || isToolUIPart(part)) {
               block.push(part);
             } else if (part.type === "step-start") {
               processBlock2();
@@ -9338,6 +9462,7 @@ export {
   createUIMessageStreamResponse,
   customProvider,
   defaultSettingsMiddleware,
+  dynamicTool2 as dynamicTool,
   embed,
   embedMany,
   createMCPClient as experimental_createMCPClient,