ai 5.0.0-alpha.12 → 5.0.0-alpha.14

package/dist/index.mjs

@@ -74,24 +74,22 @@ var InvalidStreamPartError = class extends AISDKError2 {
 };
 _a2 = symbol2;
 
-// src/error/invalid-tool-arguments-error.ts
+// src/error/invalid-tool-input-error.ts
 import { AISDKError as AISDKError3, getErrorMessage } from "@ai-sdk/provider";
-var name3 = "AI_InvalidToolArgumentsError";
+var name3 = "AI_InvalidToolInputError";
 var marker3 = `vercel.ai.error.${name3}`;
 var symbol3 = Symbol.for(marker3);
 var _a3;
-var InvalidToolArgumentsError = class extends AISDKError3 {
+var InvalidToolInputError = class extends AISDKError3 {
   constructor({
-    toolArgs,
+    toolInput,
     toolName,
     cause,
-    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage(
-      cause
-    )}`
+    message = `Invalid input for tool ${toolName}: ${getErrorMessage(cause)}`
   }) {
     super({ name: name3, message, cause });
     this[_a3] = true;
-    this.toolArgs = toolArgs;
+    this.toolInput = toolInput;
     this.toolName = toolName;
   }
   static isInstance(error) {
@@ -242,7 +240,7 @@ var symbol10 = Symbol.for(marker10);
 var _a10;
 var ToolExecutionError = class extends AISDKError10 {
   constructor({
-    toolArgs,
+    toolInput,
     toolName,
     toolCallId,
     cause,
@@ -250,7 +248,7 @@ var ToolExecutionError = class extends AISDKError10 {
   }) {
     super({ name: name10, message, cause });
     this[_a10] = true;
-    this.toolArgs = toolArgs;
+    this.toolInput = toolInput;
     this.toolName = toolName;
     this.toolCallId = toolCallId;
   }
@@ -455,42 +453,45 @@ import { parseJsonEventStream } from "@ai-sdk/provider-utils";
 // src/ui-message-stream/ui-message-stream-parts.ts
 import { z } from "zod";
 var uiMessageStreamPartSchema = z.union([
-  z.object({
+  z.strictObject({
     type: z.literal("text"),
     text: z.string()
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("error"),
     errorText: z.string()
   }),
-  z.object({
-    type: z.literal("tool-call-streaming-start"),
+  z.strictObject({
+    type: z.literal("tool-input-start"),
     toolCallId: z.string(),
     toolName: z.string()
   }),
-  z.object({
-    type: z.literal("tool-call-delta"),
+  z.strictObject({
+    type: z.literal("tool-input-delta"),
     toolCallId: z.string(),
-    argsTextDelta: z.string()
+    inputTextDelta: z.string()
   }),
-  z.object({
-    type: z.literal("tool-call"),
+  z.strictObject({
+    type: z.literal("tool-input-available"),
     toolCallId: z.string(),
     toolName: z.string(),
-    args: z.unknown()
+    input: z.unknown()
   }),
-  z.object({
-    type: z.literal("tool-result"),
+  z.strictObject({
+    type: z.literal("tool-output-available"),
     toolCallId: z.string(),
-    result: z.unknown(),
+    output: z.unknown(),
     providerMetadata: z.any().optional()
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("reasoning"),
     text: z.string(),
     providerMetadata: z.record(z.any()).optional()
   }),
-  z.object({
+  z.strictObject({
+    type: z.literal("reasoning-part-finish")
+  }),
+  z.strictObject({
     type: z.literal("source-url"),
     sourceId: z.string(),
     url: z.string(),
@@ -498,7 +499,7 @@ var uiMessageStreamPartSchema = z.union([
     providerMetadata: z.any().optional()
     // Use z.any() for generic metadata
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("source-document"),
     sourceId: z.string(),
     mediaType: z.string(),
@@ -507,39 +508,34 @@ var uiMessageStreamPartSchema = z.union([
     providerMetadata: z.any().optional()
     // Use z.any() for generic metadata
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("file"),
     url: z.string(),
     mediaType: z.string()
   }),
-  z.object({
+  z.strictObject({
     type: z.string().startsWith("data-"),
     id: z.string().optional(),
     data: z.unknown()
   }),
-  z.object({
-    type: z.literal("metadata"),
-    value: z.object({ metadata: z.unknown() })
-  }),
-  z.object({
-    type: z.literal("start-step"),
-    metadata: z.unknown().optional()
+  z.strictObject({
+    type: z.literal("start-step")
   }),
-  z.object({
-    type: z.literal("finish-step"),
-    metadata: z.unknown().optional()
+  z.strictObject({
+    type: z.literal("finish-step")
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("start"),
     messageId: z.string().optional(),
-    metadata: z.unknown().optional()
+    messageMetadata: z.unknown().optional()
   }),
-  z.object({
+  z.strictObject({
     type: z.literal("finish"),
-    metadata: z.unknown().optional()
+    messageMetadata: z.unknown().optional()
   }),
-  z.object({
-    type: z.literal("reasoning-part-finish")
+  z.strictObject({
+    type: z.literal("message-metadata"),
+    messageMetadata: z.unknown()
   })
 ]);
 function isDataUIMessageStreamPart(part) {
@@ -1235,27 +1231,26 @@ async function parsePartialJson(jsonText) {
   return { value: void 0, state: "failed-parse" };
 }
 
-// src/ui/get-tool-invocations.ts
-function getToolInvocations(message) {
-  return message.parts.filter(
-    (part) => part.type === "tool-invocation"
-  ).map((part) => part.toolInvocation);
+// src/ui/ui-messages.ts
+function isToolUIPart(part) {
+  return part.type.startsWith("tool-");
+}
+function getToolName(part) {
+  return part.type.split("-")[1];
 }
 
 // src/ui/process-ui-message-stream.ts
 function createStreamingUIMessageState({
   lastMessage,
-  newMessageId = ""
-} = {}) {
-  const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-  const message = isContinuation ? lastMessage : {
-    id: newMessageId,
-    metadata: {},
-    role: "assistant",
-    parts: []
-  };
+  messageId
+}) {
   return {
-    message,
+    message: (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage : {
+      id: messageId,
+      metadata: void 0,
+      role: "assistant",
+      parts: []
+    },
     activeTextPart: void 0,
     activeReasoningPart: void 0,
     partialToolCalls: {}
@@ -1272,16 +1267,21 @@ function processUIMessageStream({
     new TransformStream({
       async transform(part, controller) {
         await runUpdateMessageJob(async ({ state, write }) => {
-          function updateToolInvocationPart(toolCallId, invocation) {
+          function updateToolInvocationPart(options) {
             const part2 = state.message.parts.find(
-              (part3) => isToolInvocationUIPart(part3) && part3.toolInvocation.toolCallId === toolCallId
+              (part3) => isToolUIPart(part3) && part3.toolCallId === options.toolCallId
             );
             if (part2 != null) {
-              part2.toolInvocation = invocation;
+              part2.state = options.state;
+              part2.input = options.input;
+              part2.output = options.output;
             } else {
               state.message.parts.push({
-                type: "tool-invocation",
-                toolInvocation: invocation
+                type: `tool-${options.toolName}`,
+                toolCallId: options.toolCallId,
+                state: options.state,
+                input: options.input,
+                output: options.output
               });
             }
           }
@@ -1364,43 +1364,43 @@ function processUIMessageStream({
               write();
               break;
             }
-            case "tool-call-streaming-start": {
-              const toolInvocations = getToolInvocations(state.message);
+            case "tool-input-start": {
+              const toolInvocations = state.message.parts.filter(isToolUIPart);
               state.partialToolCalls[part.toolCallId] = {
                 text: "",
                 toolName: part.toolName,
                 index: toolInvocations.length
               };
-              updateToolInvocationPart(part.toolCallId, {
-                state: "partial-call",
+              updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: void 0
+                state: "input-streaming",
+                input: void 0
               });
               write();
               break;
             }
-            case "tool-call-delta": {
+            case "tool-input-delta": {
               const partialToolCall = state.partialToolCalls[part.toolCallId];
-              partialToolCall.text += part.argsTextDelta;
+              partialToolCall.text += part.inputTextDelta;
               const { value: partialArgs } = await parsePartialJson(
                 partialToolCall.text
               );
-              updateToolInvocationPart(part.toolCallId, {
-                state: "partial-call",
+              updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName: partialToolCall.toolName,
-                args: partialArgs
+                state: "input-streaming",
+                input: partialArgs
               });
               write();
               break;
             }
-            case "tool-call": {
-              updateToolInvocationPart(part.toolCallId, {
-                state: "call",
+            case "tool-input-available": {
+              updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: part.args
+                state: "input-available",
+                input: part.input
               });
               write();
               if (onToolCall) {
@@ -1408,20 +1408,20 @@ function processUIMessageStream({
                   toolCall: part
                 });
                 if (result != null) {
-                  updateToolInvocationPart(part.toolCallId, {
-                    state: "result",
+                  updateToolInvocationPart({
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
-                    args: part.args,
-                    result
+                    state: "output-available",
+                    input: part.input,
+                    output: result
                   });
                   write();
                 }
               }
               break;
             }
-            case "tool-result": {
-              const toolInvocations = getToolInvocations(state.message);
+            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");
               }
@@ -1433,49 +1433,48 @@ function processUIMessageStream({
                   "tool_result must be preceded by a tool_call with the same toolCallId"
                 );
               }
-              updateToolInvocationPart(part.toolCallId, {
-                ...toolInvocations[toolInvocationIndex],
-                state: "result",
-                result: part.result
+              const toolName = getToolName(
+                toolInvocations[toolInvocationIndex]
+              );
+              updateToolInvocationPart({
+                toolCallId: part.toolCallId,
+                toolName,
+                state: "output-available",
+                input: toolInvocations[toolInvocationIndex].input,
+                output: part.output
               });
               write();
               break;
             }
             case "start-step": {
               state.message.parts.push({ type: "step-start" });
-              await updateMessageMetadata(part.metadata);
-              write();
               break;
             }
             case "finish-step": {
               state.activeTextPart = void 0;
               state.activeReasoningPart = void 0;
-              await updateMessageMetadata(part.metadata);
-              if (part.metadata != null) {
-                write();
-              }
               break;
             }
             case "start": {
               if (part.messageId != null) {
                 state.message.id = part.messageId;
               }
-              await updateMessageMetadata(part.metadata);
-              if (part.messageId != null || part.metadata != null) {
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageId != null || part.messageMetadata != null) {
                 write();
               }
               break;
             }
             case "finish": {
-              await updateMessageMetadata(part.metadata);
-              if (part.metadata != null) {
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageMetadata != null) {
                 write();
               }
               break;
             }
-            case "metadata": {
-              await updateMessageMetadata(part.metadata);
-              if (part.metadata != null) {
+            case "message-metadata": {
+              await updateMessageMetadata(part.messageMetadata);
+              if (part.messageMetadata != null) {
                 write();
               }
               break;
@@ -1503,9 +1502,6 @@ function processUIMessageStream({
     })
   );
 }
-function isToolInvocationUIPart(part) {
-  return part.type === "tool-invocation";
-}
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
@@ -1540,8 +1536,8 @@ function isAssistantMessageWithCompletedToolCalls(message) {
   const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
     return part.type === "step-start" ? index : lastIndex;
   }, -1);
-  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
-  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter(isToolUIPart);
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => part.state === "output-available");
 }
 
 // src/ui/chat.ts
@@ -1615,13 +1611,13 @@ var AbstractChat = class {
     };
     this.addToolResult = async ({
       toolCallId,
-      result
+      output
     }) => {
       this.jobExecutor.run(async () => {
-        updateToolCallResult({
+        updateToolOutput({
           messages: this.state.messages,
           toolCallId,
-          toolResult: result
+          output
         });
         this.messages = this.state.messages;
         if (this.status === "submitted" || this.status === "streaming") {
@@ -1644,7 +1640,6 @@ var AbstractChat = class {
         return;
       if ((_a17 = this.activeResponse) == null ? void 0 : _a17.abortController) {
         this.activeResponse.abortController.abort();
-        this.activeResponse.abortController = void 0;
       }
     };
     this.id = id;
@@ -1705,7 +1700,7 @@ var AbstractChat = class {
       const activeResponse = {
         state: createStreamingUIMessageState({
           lastMessage: this.state.snapshot(lastMessage),
-          newMessageId: this.generateId()
+          messageId: this.generateId()
         }),
         abortController: new AbortController()
       };
@@ -1782,23 +1777,20 @@ var AbstractChat = class {
     }
   }
 };
-function updateToolCallResult({
+function updateToolOutput({
   messages,
   toolCallId,
-  toolResult: result
+  output
 }) {
   const lastMessage = messages[messages.length - 1];
-  const invocationPart = lastMessage.parts.find(
-    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+  const toolPart = lastMessage.parts.find(
+    (part) => isToolUIPart(part) && part.toolCallId === toolCallId
   );
-  if (invocationPart == null) {
+  if (toolPart == null) {
     return;
   }
-  invocationPart.toolInvocation = {
-    ...invocationPart.toolInvocation,
-    state: "result",
-    result
-  };
+  toolPart.state = "output-available";
+  toolPart.output = output;
 }
 
 // src/ui/convert-to-model-messages.ts
@@ -1839,75 +1831,71 @@ function convertToModelMessages(messages, options) {
             }
             const content = [];
             for (const part of block) {
-              switch (part.type) {
-                case "text": {
-                  content.push(part);
-                  break;
-                }
-                case "file": {
-                  content.push({
-                    type: "file",
-                    mediaType: part.mediaType,
-                    data: part.url
-                  });
-                  break;
-                }
-                case "reasoning": {
-                  content.push({
-                    type: "reasoning",
-                    text: part.text,
-                    providerOptions: part.providerMetadata
+              if (part.type === "text") {
+                content.push(part);
+              } else if (part.type === "file") {
+                content.push({
+                  type: "file",
+                  mediaType: part.mediaType,
+                  data: part.url
+                });
+              } else if (part.type === "reasoning") {
+                content.push({
+                  type: "reasoning",
+                  text: part.text,
+                  providerOptions: part.providerMetadata
+                });
+              } else if (isToolUIPart(part)) {
+                const toolName = getToolName(part);
+                if (part.state === "input-streaming") {
+                  throw new MessageConversionError({
+                    originalMessage: message,
+                    message: `incomplete tool input is not supported: ${part.toolCallId}`
                   });
-                  break;
-                }
-                case "tool-invocation":
+                } else {
                   content.push({
                     type: "tool-call",
-                    toolCallId: part.toolInvocation.toolCallId,
-                    toolName: part.toolInvocation.toolName,
-                    args: part.toolInvocation.args
+                    toolCallId: part.toolCallId,
+                    toolName,
+                    input: part.input
                   });
-                  break;
-                default: {
-                  const _exhaustiveCheck = part;
-                  throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
                 }
+              } else {
+                const _exhaustiveCheck = part;
+                throw new Error(`Unsupported part: ${_exhaustiveCheck}`);
               }
             }
             modelMessages.push({
               role: "assistant",
               content
             });
-            const stepInvocations = block.filter(
-              (part) => part.type === "tool-invocation"
-            ).map((part) => part.toolInvocation);
-            if (stepInvocations.length > 0) {
+            const toolParts = block.filter(isToolUIPart);
+            if (toolParts.length > 0) {
               modelMessages.push({
                 role: "tool",
-                content: stepInvocations.map(
-                  (toolInvocation) => {
-                    if (!("result" in toolInvocation)) {
-                      throw new MessageConversionError({
-                        originalMessage: message,
-                        message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
-                      });
-                    }
-                    const { toolCallId, toolName, result } = toolInvocation;
-                    const tool2 = tools[toolName];
-                    return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result: tool2.experimental_toToolResultContent(result),
-                      experimental_content: tool2.experimental_toToolResultContent(result)
-                    } : {
-                      type: "tool-result",
-                      toolCallId,
-                      toolName,
-                      result
-                    };
+                content: toolParts.map((toolPart) => {
+                  if (toolPart.state !== "output-available") {
+                    throw new MessageConversionError({
+                      originalMessage: message,
+                      message: "ToolInvocation must have a result: " + JSON.stringify(toolPart)
+                    });
                   }
-                )
+                  const toolName = getToolName(toolPart);
+                  const { toolCallId, output } = toolPart;
+                  const tool2 = tools[toolName];
+                  return (tool2 == null ? void 0 : tool2.experimental_toToolResultContent) != null ? {
+                    type: "tool-result",
+                    toolCallId,
+                    toolName,
+                    output: tool2.experimental_toToolResultContent(output),
+                    experimental_content: tool2.experimental_toToolResultContent(output)
+                  } : {
+                    type: "tool-result",
+                    toolCallId,
+                    toolName,
+                    output
+                  };
+                })
               });
             }
             block = [];
@@ -1915,18 +1903,10 @@ function convertToModelMessages(messages, options) {
           var processBlock = processBlock2;
           let block = [];
           for (const part of message.parts) {
-            switch (part.type) {
-              case "text":
-              case "reasoning":
-              case "file":
-              case "tool-invocation": {
-                block.push(part);
-                break;
-              }
-              case "step-start": {
-                processBlock2();
-                break;
-              }
+            if (part.type === "text" || part.type === "reasoning" || part.type === "file" || isToolUIPart(part)) {
+              block.push(part);
+            } else if (part.type === "step-start") {
+              processBlock2();
             }
           }
           processBlock2();
@@ -2056,9 +2036,14 @@ var TextStreamChatTransport = class {
   }
 };
 
+// src/ui-message-stream/create-ui-message-stream.ts
+import {
+  generateId as generateIdFunc2
+} from "@ai-sdk/provider-utils";
+
 // src/ui-message-stream/handle-ui-message-stream-finish.ts
 function handleUIMessageStreamFinish({
-  newMessageId,
+  messageId,
   originalMessages = [],
   onFinish,
   stream
@@ -2066,19 +2051,30 @@ function handleUIMessageStreamFinish({
   if (onFinish == null) {
     return stream;
   }
-  const lastMessage = originalMessages[originalMessages.length - 1];
-  const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-  const messageId = isContinuation ? lastMessage.id : newMessageId;
+  const lastMessage = originalMessages == null ? void 0 : originalMessages[originalMessages.length - 1];
   const state = createStreamingUIMessageState({
-    lastMessage: structuredClone(lastMessage),
-    newMessageId: messageId
+    lastMessage: lastMessage ? structuredClone(lastMessage) : void 0,
+    messageId
+    // will be overridden by the stream
   });
   const runUpdateMessageJob = async (job) => {
     await job({ state, write: () => {
     } });
   };
   return processUIMessageStream({
-    stream,
+    stream: stream.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          if (chunk.type === "start") {
+            const startChunk = chunk;
+            if (startChunk.messageId == null) {
+              startChunk.messageId = messageId;
+            }
+          }
+          controller.enqueue(chunk);
+        }
+      })
+    ),
     runUpdateMessageJob
   }).pipeThrough(
     new TransformStream({
@@ -2086,12 +2082,12 @@ function handleUIMessageStreamFinish({
         controller.enqueue(chunk);
       },
       flush() {
-        const isContinuation2 = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
+        const isContinuation = state.message.id === (lastMessage == null ? void 0 : lastMessage.id);
         onFinish({
-          isContinuation: isContinuation2,
+          isContinuation,
           responseMessage: state.message,
           messages: [
-            ...isContinuation2 ? originalMessages.slice(0, -1) : originalMessages,
+            ...isContinuation ? originalMessages.slice(0, -1) : originalMessages,
             state.message
           ]
         });
@@ -2106,7 +2102,8 @@ function createUIMessageStream({
   onError = () => "An error occurred.",
   // mask error messages for safety by default
   originalMessages,
-  onFinish
+  onFinish,
+  generateId: generateId3 = generateIdFunc2
 }) {
   let controller;
   const ongoingStreamPromises = [];
@@ -2178,7 +2175,7 @@ function createUIMessageStream({
   });
   return handleUIMessageStreamFinish({
     stream,
-    newMessageId: "",
+    messageId: generateId3(),
     originalMessages,
     onFinish
   });
@@ -3444,7 +3441,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
                 type: "tool-call",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: part.args,
+                input: part.input,
                 providerOptions
               };
             }
@@ -3460,7 +3457,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
           type: "tool-result",
           toolCallId: part.toolCallId,
           toolName: part.toolName,
-          result: part.result,
+          output: part.output,
           content: part.experimental_content,
           isError: part.isError,
           providerOptions: part.providerOptions
@@ -3747,14 +3744,14 @@ var toolCallPartSchema = z6.object({
   type: z6.literal("tool-call"),
   toolCallId: z6.string(),
   toolName: z6.string(),
-  args: z6.unknown(),
+  input: z6.unknown(),
   providerOptions: providerMetadataSchema.optional()
 });
 var toolResultPartSchema = z6.object({
   type: z6.literal("tool-result"),
   toolCallId: z6.string(),
   toolName: z6.string(),
-  result: z6.unknown(),
+  output: z6.unknown(),
   content: toolResultContentSchema.optional(),
   isError: z6.boolean().optional(),
   providerOptions: providerMetadataSchema.optional()
@@ -5360,11 +5357,18 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: asSchema2(tool2.parameters).jsonSchema
+            inputSchema: asSchema2(tool2.inputSchema).jsonSchema
           };
-        case "provider-defined":
+        case "provider-defined-client":
           return {
-            type: "provider-defined",
+            type: "provider-defined-client",
+            name: name17,
+            id: tool2.id,
+            args: tool2.args
+          };
+        case "provider-defined-server":
+          return {
+            type: "provider-defined-server",
             name: name17,
             id: tool2.id,
             args: tool2.args
@@ -5448,7 +5452,7 @@ async function parseToolCall({
   try {
     return await doParseToolCall({ toolCall, tools });
   } catch (error) {
-    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolArgumentsError.isInstance(error))) {
+    if (repairToolCall == null || !(NoSuchToolError.isInstance(error) || InvalidToolInputError.isInstance(error))) {
       throw error;
     }
     let repairedToolCall = null;
@@ -5456,9 +5460,9 @@ async function parseToolCall({
       repairedToolCall = await repairToolCall({
         toolCall,
         tools,
-        parameterSchema: ({ toolName }) => {
-          const { parameters } = tools[toolName];
-          return asSchema3(parameters).jsonSchema;
+        inputSchema: ({ toolName }) => {
+          const { inputSchema } = tools[toolName];
+          return asSchema3(inputSchema).jsonSchema;
         },
         system,
         messages,
@@ -5488,12 +5492,12 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = asSchema3(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? await safeValidateTypes3({ value: {}, schema }) : await safeParseJSON3({ text: toolCall.args, schema });
+  const schema = asSchema3(tool2.inputSchema);
+  const parseResult = toolCall.input.trim() === "" ? await safeValidateTypes3({ value: {}, schema }) : await safeParseJSON3({ text: toolCall.input, schema });
   if (parseResult.success === false) {
-    throw new InvalidToolArgumentsError({
+    throw new InvalidToolInputError({
       toolName,
-      toolArgs: toolCall.args,
+      toolInput: toolCall.input,
       cause: parseResult.error
     });
   }
@@ -5501,7 +5505,7 @@ async function doParseToolCall({
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName,
-    args: parseResult == null ? void 0 : parseResult.value
+    input: parseResult.value
   };
 }
 
@@ -5604,15 +5608,15 @@ function toResponseMessages({
       type: "tool-result",
       toolCallId: toolResult.toolCallId,
       toolName: toolResult.toolName,
-      result: tool2.experimental_toToolResultContent(toolResult.result),
+      output: tool2.experimental_toToolResultContent(toolResult.output),
       experimental_content: tool2.experimental_toToolResultContent(
-        toolResult.result
+        toolResult.output
       )
     } : {
       type: "tool-result",
       toolCallId: toolResult.toolCallId,
       toolName: toolResult.toolName,
-      result: toolResult.result
+      output: toolResult.output
     };
   });
   if (toolResultContent.length > 0) {
@@ -5918,11 +5922,11 @@ async function executeTools({
   abortSignal
 }) {
   const toolResults = await Promise.all(
-    toolCalls.map(async ({ toolCallId, toolName, args }) => {
+    toolCalls.map(async ({ toolCallId, toolName, input }) => {
       const tool2 = tools[toolName];
-      if ((tool2 == null ? void 0 : tool2.onArgsAvailable) != null) {
-        await tool2.onArgsAvailable({
-          args,
+      if ((tool2 == null ? void 0 : tool2.onInputAvailable) != null) {
+        await tool2.onInputAvailable({
+          input,
           toolCallId,
           messages,
           abortSignal
@@ -5942,15 +5946,15 @@ async function executeTools({
             }),
             "ai.toolCall.name": toolName,
             "ai.toolCall.id": toolCallId,
-            "ai.toolCall.args": {
-              output: () => JSON.stringify(args)
+            "ai.toolCall.input": {
+              output: () => JSON.stringify(input)
             }
           }
         }),
         tracer,
         fn: async (span) => {
           try {
-            const result2 = await tool2.execute(args, {
+            const result2 = await tool2.execute(input, {
               toolCallId,
               messages,
               abortSignal
@@ -5973,7 +5977,7 @@ async function executeTools({
             throw new ToolExecutionError({
               toolCallId,
               toolName,
-              toolArgs: args,
+              toolInput: input,
               cause: error
             });
           }
@@ -5983,8 +5987,8 @@ async function executeTools({
         type: "tool-result",
         toolCallId,
         toolName,
-        args,
-        result
+        input,
+        output: result
       };
     })
   );
@@ -6074,7 +6078,7 @@ function asToolCalls(content) {
     toolCallType: toolCall.toolCallType,
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
-    args: toolCall.args
+    input: toolCall.input
   }));
 }
 
@@ -6302,7 +6306,7 @@ function runToolsTransformation({
             type: "tool-call-delta",
             toolCallId: chunk.toolCallId,
             toolName: chunk.toolName,
-            argsTextDelta: chunk.argsTextDelta
+            inputTextDelta: chunk.inputTextDelta
           });
           break;
         }
@@ -6317,9 +6321,9 @@ function runToolsTransformation({
             });
             controller.enqueue(toolCall);
             const tool2 = tools[toolCall.toolName];
-            if (tool2.onArgsAvailable != null) {
-              await tool2.onArgsAvailable({
-                args: toolCall.args,
+            if (tool2.onInputAvailable != null) {
+              await tool2.onInputAvailable({
+                input: toolCall.input,
                 toolCallId: toolCall.toolCallId,
                 messages,
                 abortSignal
@@ -6339,22 +6343,22 @@ function runToolsTransformation({
                     }),
                     "ai.toolCall.name": toolCall.toolName,
                     "ai.toolCall.id": toolCall.toolCallId,
-                    "ai.toolCall.args": {
-                      output: () => JSON.stringify(toolCall.args)
+                    "ai.toolCall.input": {
+                      output: () => JSON.stringify(toolCall.input)
                     }
                   }
                 }),
                 tracer,
-                fn: async (span) => tool2.execute(toolCall.args, {
+                fn: async (span) => tool2.execute(toolCall.input, {
                   toolCallId: toolCall.toolCallId,
                   messages,
                   abortSignal
                 }).then(
-                  (result) => {
+                  (output) => {
                     toolResultsStreamController.enqueue({
                       ...toolCall,
                       type: "tool-result",
-                      result
+                      output
                     });
                     outstandingToolResults.delete(toolExecutionId);
                     attemptClose();
@@ -6363,8 +6367,8 @@ function runToolsTransformation({
                         selectTelemetryAttributes({
                           telemetry,
                           attributes: {
-                            "ai.toolCall.result": {
-                              output: () => JSON.stringify(result)
+                            "ai.toolCall.output": {
+                              output: () => JSON.stringify(output)
                             }
                           }
                         })
@@ -6378,7 +6382,7 @@ function runToolsTransformation({
                       error: new ToolExecutionError({
                         toolCallId: toolCall.toolCallId,
                         toolName: toolCall.toolName,
-                        toolArgs: toolCall.args,
+                        toolInput: toolCall.input,
                         cause: error
                       })
                     });
@@ -6434,6 +6438,18 @@ function runToolsTransformation({
   });
 }
 
+// src/ui-message-stream/get-response-ui-message-id.ts
+function getResponseUIMessageId({
+  originalMessages,
+  responseMessageId
+}) {
+  if (originalMessages == null) {
+    return void 0;
+  }
+  const lastMessage = originalMessages[originalMessages.length - 1];
+  return (lastMessage == null ? void 0 : lastMessage.role) === "assistant" ? lastMessage.id : typeof responseMessageId === "function" ? responseMessageId() : responseMessageId;
+}
+
 // core/generate-text/stream-text.ts
 var originalGenerateId4 = createIdGenerator4({
   prefix: "aitxt",
@@ -6598,7 +6614,7 @@ var DefaultStreamTextResult = class {
       async transform(chunk, controller) {
         controller.enqueue(chunk);
         const { part } = chunk;
-        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") {
+        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta" || part.type === "raw") {
           await (onChunk == null ? void 0 : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
@@ -7018,8 +7034,8 @@ var DefaultStreamTextResult = class {
                     }
                     case "tool-call-streaming-start": {
                       const tool2 = tools == null ? void 0 : tools[chunk.toolName];
-                      if ((tool2 == null ? void 0 : tool2.onArgsStreamingStart) != null) {
-                        await tool2.onArgsStreamingStart({
+                      if ((tool2 == null ? void 0 : tool2.onInputStart) != null) {
+                        await tool2.onInputStart({
                           toolCallId: chunk.toolCallId,
                           messages: stepInputMessages,
                           abortSignal
@@ -7030,9 +7046,9 @@ var DefaultStreamTextResult = class {
                     }
                     case "tool-call-delta": {
                       const tool2 = tools == null ? void 0 : tools[chunk.toolName];
-                      if ((tool2 == null ? void 0 : tool2.onArgsStreamingDelta) != null) {
-                        await tool2.onArgsStreamingDelta({
-                          argsTextDelta: chunk.argsTextDelta,
+                      if ((tool2 == null ? void 0 : tool2.onInputDelta) != null) {
+                        await tool2.onInputDelta({
+                          inputTextDelta: chunk.inputTextDelta,
                           toolCallId: chunk.toolCallId,
                           messages: stepInputMessages,
                           abortSignal
@@ -7047,7 +7063,9 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "raw": {
-                      controller.enqueue(chunk);
+                      if (includeRawChunks2) {
+                        controller.enqueue(chunk);
+                      }
                       break;
                     }
                     default: {
@@ -7270,23 +7288,24 @@ var DefaultStreamTextResult = class {
     );
   }
   toUIMessageStream({
-    newMessageId,
-    originalMessages = [],
+    originalMessages,
     onFinish,
     messageMetadata,
-    sendReasoning = false,
+    sendReasoning = true,
     sendSources = false,
     sendStart = true,
     sendFinish = true,
     onError = () => "An error occurred."
     // mask error messages for safety by default
   } = {}) {
-    const lastMessage = originalMessages[originalMessages.length - 1];
-    const isContinuation = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
-    const messageId = isContinuation ? lastMessage.id : newMessageId;
+    const responseMessageId = getResponseUIMessageId({
+      originalMessages,
+      responseMessageId: this.generateId
+    });
     const baseStream = this.fullStream.pipeThrough(
       new TransformStream({
         transform: async (part, controller) => {
+          const messageMetadataValue = messageMetadata == null ? void 0 : messageMetadata({ part });
           const partType = part.type;
           switch (partType) {
             case "text": {
@@ -7344,7 +7363,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call-streaming-start": {
               controller.enqueue({
-                type: "tool-call-streaming-start",
+                type: "tool-input-start",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName
               });
@@ -7352,26 +7371,26 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call-delta": {
               controller.enqueue({
-                type: "tool-call-delta",
+                type: "tool-input-delta",
                 toolCallId: part.toolCallId,
-                argsTextDelta: part.argsTextDelta
+                inputTextDelta: part.inputTextDelta
               });
               break;
             }
             case "tool-call": {
               controller.enqueue({
-                type: "tool-call",
+                type: "tool-input-available",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: part.args
+                input: part.input
               });
               break;
             }
             case "tool-result": {
               controller.enqueue({
-                type: "tool-result",
+                type: "tool-output-available",
                 toolCallId: part.toolCallId,
-                result: part.result
+                output: part.output
               });
               break;
             }
@@ -7383,38 +7402,28 @@ var DefaultStreamTextResult = class {
               break;
             }
             case "start-step": {
-              const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
-              controller.enqueue({
-                type: "start-step",
-                metadata
-              });
+              controller.enqueue({ type: "start-step" });
               break;
             }
             case "finish-step": {
-              const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
-              controller.enqueue({
-                type: "finish-step",
-                metadata
-              });
+              controller.enqueue({ type: "finish-step" });
               break;
             }
             case "start": {
               if (sendStart) {
-                const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "start",
-                  messageId,
-                  metadata
+                  messageId: responseMessageId,
+                  messageMetadata: messageMetadataValue
                 });
               }
               break;
             }
             case "finish": {
               if (sendFinish) {
-                const metadata = messageMetadata == null ? void 0 : messageMetadata({ part });
                 controller.enqueue({
                   type: "finish",
-                  metadata
+                  messageMetadata: messageMetadataValue
                 });
               }
               break;
@@ -7427,18 +7436,23 @@ var DefaultStreamTextResult = class {
               throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
             }
           }
+          if (messageMetadataValue != null && partType !== "start" && partType !== "finish") {
+            controller.enqueue({
+              type: "message-metadata",
+              messageMetadata: messageMetadataValue
+            });
+          }
         }
       })
     );
     return handleUIMessageStreamFinish({
       stream: baseStream,
-      newMessageId: messageId != null ? messageId : this.generateId(),
+      messageId: responseMessageId != null ? responseMessageId : this.generateId(),
       originalMessages,
       onFinish
     });
   }
   pipeUIMessageStreamToResponse(response, {
-    newMessageId,
     originalMessages,
     onFinish,
     messageMetadata,
@@ -7452,7 +7466,6 @@ var DefaultStreamTextResult = class {
     pipeUIMessageStreamToResponse({
       response,
       stream: this.toUIMessageStream({
-        newMessageId,
         originalMessages,
         onFinish,
         messageMetadata,
@@ -7473,7 +7486,6 @@ var DefaultStreamTextResult = class {
     });
   }
   toUIMessageStreamResponse({
-    newMessageId,
     originalMessages,
     onFinish,
     messageMetadata,
@@ -7486,7 +7498,6 @@ var DefaultStreamTextResult = class {
   } = {}) {
     return createUIMessageStreamResponse({
       stream: this.toUIMessageStream({
-        newMessageId,
         originalMessages,
         onFinish,
         messageMetadata,
@@ -8390,15 +8401,14 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? jsonSchema({
-          ...inputSchema,
-          properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
-          additionalProperties: false
-        }) : schemas[name17].parameters;
         const self = this;
         const toolWithExecute = tool({
           description,
-          parameters,
+          inputSchema: schemas === "automatic" ? jsonSchema({
+            ...inputSchema,
+            properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
+            additionalProperties: false
+          }) : schemas[name17].inputSchema,
           execute: async (args, options) => {
             var _a18;
             (_a18 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a18.throwIfAborted();
@@ -8530,7 +8540,7 @@ export {
   InvalidPromptError,
   InvalidResponseDataError,
   InvalidStreamPartError,
-  InvalidToolArgumentsError,
+  InvalidToolInputError,
   JSONParseError,
   JsonToSseTransformStream,
   LoadAPIKeyError,
@@ -8583,9 +8593,10 @@ export {
   generateObject,
   generateText,
   getTextFromDataUrl,
-  getToolInvocations,
+  getToolName,
   hasToolCall,
   isDeepEqualData,
+  isToolUIPart,
   jsonSchema2 as jsonSchema,
   modelMessageSchema,
   parsePartialJson,