ai 5.0.0-alpha.13 → 5.0.0-alpha.15

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;
   }
@@ -464,25 +462,25 @@ var uiMessageStreamPartSchema = z.union([
     errorText: z.string()
   }),
   z.strictObject({
-    type: z.literal("tool-call-streaming-start"),
+    type: z.literal("tool-input-start"),
     toolCallId: z.string(),
     toolName: z.string()
   }),
   z.strictObject({
-    type: z.literal("tool-call-delta"),
+    type: z.literal("tool-input-delta"),
     toolCallId: z.string(),
-    argsTextDelta: z.string()
+    inputTextDelta: z.string()
   }),
   z.strictObject({
-    type: z.literal("tool-call"),
+    type: z.literal("tool-input-available"),
     toolCallId: z.string(),
     toolName: z.string(),
-    args: z.unknown()
+    input: z.unknown()
   }),
   z.strictObject({
-    type: z.literal("tool-result"),
+    type: z.literal("tool-output-available"),
     toolCallId: z.string(),
-    result: z.unknown(),
+    output: z.unknown(),
     providerMetadata: z.any().optional()
   }),
   z.strictObject({
@@ -758,103 +756,127 @@ async function convertFileListToFileUIParts(files) {
 }
 
 // src/ui/default-chat-transport.ts
-import {
-  parseJsonEventStream as parseJsonEventStream2
-} from "@ai-sdk/provider-utils";
+import { parseJsonEventStream as parseJsonEventStream2 } from "@ai-sdk/provider-utils";
+
+// src/ui/http-chat-transport.ts
 var getOriginalFetch2 = () => fetch;
-async function fetchUIMessageStream({
-  api,
-  body,
-  credentials,
-  headers,
-  abortSignal,
-  fetch: fetch2 = getOriginalFetch2(),
-  requestType = "generate"
-}) {
-  var _a17;
-  const response = requestType === "resume" ? await fetch2(`${api}?id=${body.id}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: abortSignal,
-    credentials
-  }) : await fetch2(api, {
-    method: "POST",
-    body: JSON.stringify(body),
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: abortSignal,
-    credentials
-  });
-  if (!response.ok) {
-    throw new Error(
-      (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
-    );
-  }
-  if (!response.body) {
-    throw new Error("The response body is empty.");
-  }
-  return parseJsonEventStream2({
-    stream: response.body,
-    schema: uiMessageStreamPartSchema
-  }).pipeThrough(
-    new TransformStream({
-      async transform(part, controller) {
-        if (!part.success) {
-          throw part.error;
-        }
-        controller.enqueue(part.value);
-      }
-    })
-  );
-}
-var DefaultChatTransport = class {
+var HttpChatTransport = class {
   constructor({
     api = "/api/chat",
     credentials,
     headers,
     body,
-    fetch: fetch2,
-    prepareRequest
-  } = {}) {
+    fetch: fetch2 = getOriginalFetch2(),
+    prepareSendMessagesRequest,
+    prepareReconnectToStreamRequest
+  }) {
     this.api = api;
     this.credentials = credentials;
     this.headers = headers;
     this.body = body;
     this.fetch = fetch2;
-    this.prepareRequest = prepareRequest;
+    this.prepareSendMessagesRequest = prepareSendMessagesRequest;
+    this.prepareReconnectToStreamRequest = prepareReconnectToStreamRequest;
   }
-  submitMessages({
-    chatId,
-    messages,
+  async sendMessages({
     abortSignal,
-    metadata,
-    headers,
-    body,
-    requestType
+    ...options
   }) {
-    var _a17, _b;
-    const preparedRequest = (_a17 = this.prepareRequest) == null ? void 0 : _a17.call(this, {
-      id: chatId,
-      messages,
-      body: { ...this.body, ...body },
-      headers: { ...this.headers, ...headers },
+    var _a17, _b, _c, _d;
+    const preparedRequest = (_a17 = this.prepareSendMessagesRequest) == null ? void 0 : _a17.call(this, {
+      api: this.api,
+      id: options.chatId,
+      messages: options.messages,
+      body: { ...this.body, ...options.body },
+      headers: { ...this.headers, ...options.headers },
       credentials: this.credentials,
-      requestMetadata: metadata
+      requestMetadata: options.metadata,
+      trigger: options.trigger,
+      messageId: options.messageId
+    });
+    const api = (_b = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b : this.api;
+    const headers = (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...options.headers };
+    const body = (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : {
+      ...this.body,
+      ...options.body,
+      id: options.chatId,
+      messages: options.messages,
+      trigger: options.trigger,
+      messageId: options.messageId
+    };
+    const credentials = (_c = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _c : this.credentials;
+    const response = await fetch(api, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      body: JSON.stringify(body),
+      credentials,
+      signal: abortSignal
     });
-    return fetchUIMessageStream({
+    if (!response.ok) {
+      throw new Error(
+        (_d = await response.text()) != null ? _d : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    return this.processResponseStream(response.body);
+  }
+  async reconnectToStream(options) {
+    var _a17, _b, _c, _d;
+    const preparedRequest = (_a17 = this.prepareReconnectToStreamRequest) == null ? void 0 : _a17.call(this, {
       api: this.api,
-      body: (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : { ...this.body, ...body, id: chatId, messages },
-      headers: (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...headers },
-      credentials: (_b = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _b : this.credentials,
-      abortSignal,
-      fetch: this.fetch,
-      requestType
+      id: options.chatId,
+      body: { ...this.body, ...options.body },
+      headers: { ...this.headers, ...options.headers },
+      credentials: this.credentials,
+      requestMetadata: options.metadata
+    });
+    const api = (_b = preparedRequest == null ? void 0 : preparedRequest.api) != null ? _b : `${this.api}/${options.chatId}/stream`;
+    const headers = (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...options.headers };
+    const credentials = (_c = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _c : this.credentials;
+    const response = await fetch(api, {
+      method: "GET",
+      headers,
+      credentials
     });
+    if (response.status === 204) {
+      return null;
+    }
+    if (!response.ok) {
+      throw new Error(
+        (_d = await response.text()) != null ? _d : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    return this.processResponseStream(response.body);
+  }
+};
+
+// src/ui/default-chat-transport.ts
+var DefaultChatTransport = class extends HttpChatTransport {
+  constructor(options = {}) {
+    super(options);
+  }
+  processResponseStream(stream) {
+    return parseJsonEventStream2({
+      stream,
+      schema: uiMessageStreamPartSchema
+    }).pipeThrough(
+      new TransformStream({
+        async transform(part, controller) {
+          if (!part.success) {
+            throw part.error;
+          }
+          controller.enqueue(part.value);
+        }
+      })
+    );
   }
 };
 
@@ -1275,15 +1297,15 @@ function processUIMessageStream({
             );
             if (part2 != null) {
               part2.state = options.state;
-              part2.args = options.args;
-              part2.result = options.result;
+              part2.input = options.input;
+              part2.output = options.output;
             } else {
               state.message.parts.push({
                 type: `tool-${options.toolName}`,
                 toolCallId: options.toolCallId,
                 state: options.state,
-                args: options.args,
-                result: options.result
+                input: options.input,
+                output: options.output
               });
             }
           }
@@ -1366,7 +1388,7 @@ function processUIMessageStream({
               write();
               break;
             }
-            case "tool-call-streaming-start": {
+            case "tool-input-start": {
               const toolInvocations = state.message.parts.filter(isToolUIPart);
               state.partialToolCalls[part.toolCallId] = {
                 text: "",
@@ -1376,33 +1398,33 @@ function processUIMessageStream({
               updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                state: "partial-call",
-                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({
                 toolCallId: part.toolCallId,
                 toolName: partialToolCall.toolName,
-                state: "partial-call",
-                args: partialArgs
+                state: "input-streaming",
+                input: partialArgs
               });
               write();
               break;
             }
-            case "tool-call": {
+            case "tool-input-available": {
               updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                state: "call",
-                args: part.args
+                state: "input-available",
+                input: part.input
               });
               write();
               if (onToolCall) {
@@ -1413,16 +1435,16 @@ function processUIMessageStream({
                   updateToolInvocationPart({
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
-                    state: "result",
-                    args: part.args,
-                    result
+                    state: "output-available",
+                    input: part.input,
+                    output: result
                   });
                   write();
                 }
               }
               break;
             }
-            case "tool-result": {
+            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");
@@ -1441,9 +1463,9 @@ function processUIMessageStream({
               updateToolInvocationPart({
                 toolCallId: part.toolCallId,
                 toolName,
-                state: "result",
-                args: toolInvocations[toolInvocationIndex].args,
-                result: part.result
+                state: "output-available",
+                input: toolInvocations[toolInvocationIndex].input,
+                output: part.output
               });
               write();
               break;
@@ -1539,7 +1561,7 @@ function isAssistantMessageWithCompletedToolCalls(message) {
     return part.type === "step-start" ? index : lastIndex;
   }, -1);
   const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter(isToolUIPart);
-  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => part.state === "result");
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => part.state === "output-available");
 }
 
 // src/ui/chat.ts
@@ -1558,22 +1580,14 @@ var AbstractChat = class {
   }) {
     this.activeResponse = void 0;
     this.jobExecutor = new SerialJobExecutor();
-    this.removeAssistantResponse = () => {
-      const lastMessage = this.state.messages[this.state.messages.length - 1];
-      if (lastMessage == null) {
-        throw new Error("Cannot remove assistant response from empty chat");
-      }
-      if (lastMessage.role !== "assistant") {
-        throw new Error("Last message is not an assistant message");
-      }
-      this.state.popMessage();
-    };
     /**
-     * Append a user message to the chat list. This triggers the API call to fetch
+     * Appends or replaces a user message to the chat list. This triggers the API call to fetch
      * the assistant's response.
+     *
+     * If a messageId is provided, the message will be replaced.
      */
     this.sendMessage = async (message, options = {}) => {
-      var _a17, _b;
+      var _a17, _b, _c;
       let uiMessage;
       if ("text" in message || "files" in message) {
         const fileParts = Array.isArray(message.files) ? message.files : await convertFileListToFileUIParts(message.files);
@@ -1586,40 +1600,75 @@ var AbstractChat = class {
       } else {
         uiMessage = message;
       }
-      this.state.pushMessage({
-        ...uiMessage,
-        id: (_a17 = uiMessage.id) != null ? _a17 : this.generateId(),
-        role: (_b = uiMessage.role) != null ? _b : "user"
+      if (message.messageId != null) {
+        const messageIndex = this.state.messages.findIndex(
+          (m) => m.id === message.messageId
+        );
+        if (messageIndex === -1) {
+          throw new Error(`message with id ${message.messageId} not found`);
+        }
+        if (this.state.messages[messageIndex].role !== "user") {
+          throw new Error(
+            `message with id ${message.messageId} is not a user message`
+          );
+        }
+        this.state.messages = this.state.messages.slice(0, messageIndex + 1);
+        this.state.replaceMessage(messageIndex, {
+          ...uiMessage,
+          id: message.messageId,
+          role: (_a17 = uiMessage.role) != null ? _a17 : "user"
+        });
+      } else {
+        this.state.pushMessage({
+          ...uiMessage,
+          id: (_b = uiMessage.id) != null ? _b : this.generateId(),
+          role: (_c = uiMessage.role) != null ? _c : "user"
+        });
+      }
+      await this.makeRequest({
+        trigger: "submit-user-message",
+        messageId: message.messageId,
+        ...options
       });
-      await this.triggerRequest({ requestType: "generate", ...options });
     };
     /**
-     * Regenerate the last assistant message.
+     * Regenerate the assistant message with the provided message id.
+     * If no message id is provided, the last assistant message will be regenerated.
      */
-    this.reload = async (options = {}) => {
-      if (this.lastMessage === void 0) {
-        return;
-      }
-      if (this.lastMessage.role === "assistant") {
-        this.state.popMessage();
+    this.regenerate = async ({
+      messageId,
+      ...options
+    } = {}) => {
+      const messageIndex = messageId == null ? this.state.messages.length - 1 : this.state.messages.findIndex((message) => message.id === messageId);
+      if (messageIndex === -1) {
+        throw new Error(`message ${messageId} not found`);
       }
-      await this.triggerRequest({ requestType: "generate", ...options });
+      this.state.messages = this.state.messages.slice(
+        0,
+        // if the message is a user message, we need to include it in the request:
+        this.messages[messageIndex].role === "assistant" ? messageIndex : messageIndex + 1
+      );
+      await this.makeRequest({
+        trigger: "regenerate-assistant-message",
+        messageId,
+        ...options
+      });
     };
     /**
-     * Resume an ongoing chat generation stream. This does not resume an aborted generation.
+     * Attempt to resume an ongoing streaming response.
      */
-    this.experimental_resume = async (options = {}) => {
-      await this.triggerRequest({ requestType: "resume", ...options });
+    this.resumeStream = async (options = {}) => {
+      await this.makeRequest({ trigger: "resume-stream", ...options });
     };
     this.addToolResult = async ({
       toolCallId,
-      result
+      output
     }) => {
       this.jobExecutor.run(async () => {
-        updateToolResult({
+        updateToolOutput({
           messages: this.state.messages,
           toolCallId,
-          toolResult: result
+          output
         });
         this.messages = this.state.messages;
         if (this.status === "submitted" || this.status === "streaming") {
@@ -1627,8 +1676,8 @@ var AbstractChat = class {
         }
         const lastMessage = this.lastMessage;
         if (isAssistantMessageWithCompletedToolCalls(lastMessage)) {
-          this.triggerRequest({
-            requestType: "generate"
+          this.makeRequest({
+            trigger: "submit-tool-result"
           });
         }
       });
@@ -1687,11 +1736,12 @@ var AbstractChat = class {
   set messages(messages) {
     this.state.messages = messages;
   }
-  async triggerRequest({
-    requestType,
+  async makeRequest({
+    trigger,
     metadata,
     headers,
-    body
+    body,
+    messageId
   }) {
     var _a17, _b;
     this.setStatus({ status: "submitted", error: void 0 });
@@ -1707,15 +1757,30 @@ var AbstractChat = class {
         abortController: new AbortController()
       };
       this.activeResponse = activeResponse;
-      const stream = await this.transport.submitMessages({
-        chatId: this.id,
-        messages: this.state.messages,
-        abortSignal: activeResponse.abortController.signal,
-        metadata,
-        headers,
-        body,
-        requestType
-      });
+      let stream;
+      if (trigger === "resume-stream") {
+        const reconnect = await this.transport.reconnectToStream({
+          chatId: this.id,
+          metadata,
+          headers,
+          body
+        });
+        if (reconnect == null) {
+          return;
+        }
+        stream = reconnect;
+      } else {
+        stream = await this.transport.sendMessages({
+          chatId: this.id,
+          messages: this.state.messages,
+          abortSignal: activeResponse.abortController.signal,
+          metadata,
+          headers,
+          body,
+          trigger,
+          messageId
+        });
+      }
       const runUpdateMessageJob = (job) => (
         // serialize the job execution to avoid race conditions:
         this.jobExecutor.run(
@@ -1770,19 +1835,20 @@ var AbstractChat = class {
       maxSteps: this.maxSteps,
       messages: this.state.messages
     })) {
-      await this.triggerRequest({
-        requestType,
+      await this.makeRequest({
         metadata,
         headers,
-        body
+        body,
+        // secondary requests are triggered by automatic tool execution
+        trigger: "submit-tool-result"
       });
     }
   }
 };
-function updateToolResult({
+function updateToolOutput({
   messages,
   toolCallId,
-  toolResult: result
+  output
 }) {
   const lastMessage = messages[messages.length - 1];
   const toolPart = lastMessage.parts.find(
@@ -1791,8 +1857,8 @@ function updateToolResult({
   if (toolPart == null) {
     return;
   }
-  toolPart.state = "result";
-  toolPart.result = result;
+  toolPart.state = "output-available";
+  toolPart.output = output;
 }
 
 // src/ui/convert-to-model-messages.ts
@@ -1849,17 +1915,17 @@ function convertToModelMessages(messages, options) {
                 });
               } else if (isToolUIPart(part)) {
                 const toolName = getToolName(part);
-                if (part.state === "partial-call") {
+                if (part.state === "input-streaming") {
                   throw new MessageConversionError({
                     originalMessage: message,
-                    message: `Partial tool call is not supported: ${part.toolCallId}`
+                    message: `incomplete tool input is not supported: ${part.toolCallId}`
                   });
                 } else {
                   content.push({
                     type: "tool-call",
                     toolCallId: part.toolCallId,
                     toolName,
-                    args: part.args
+                    input: part.input
                   });
                 }
               } else {
@@ -1876,26 +1942,26 @@ function convertToModelMessages(messages, options) {
               modelMessages.push({
                 role: "tool",
                 content: toolParts.map((toolPart) => {
-                  if (toolPart.state !== "result") {
+                  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, result } = toolPart;
+                  const { toolCallId, output } = toolPart;
                   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)
+                    output: tool2.experimental_toToolResultContent(output),
+                    experimental_content: tool2.experimental_toToolResultContent(output)
                   } : {
                     type: "tool-result",
                     toolCallId,
                     toolName,
-                    result
+                    output
                   };
                 })
               });
@@ -1951,89 +2017,13 @@ function transformTextToUiMessageStream({
 }
 
 // src/ui/text-stream-chat-transport.ts
-var getOriginalFetch3 = () => fetch;
-async function fetchTextStream({
-  api,
-  body,
-  credentials,
-  headers,
-  abortSignal,
-  fetch: fetch2 = getOriginalFetch3(),
-  requestType = "generate"
-}) {
-  var _a17;
-  const response = requestType === "resume" ? await fetch2(`${api}?chatId=${body.chatId}`, {
-    method: "GET",
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: abortSignal,
-    credentials
-  }) : await fetch2(api, {
-    method: "POST",
-    body: JSON.stringify(body),
-    headers: {
-      "Content-Type": "application/json",
-      ...headers
-    },
-    signal: abortSignal,
-    credentials
-  });
-  if (!response.ok) {
-    throw new Error(
-      (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
-    );
-  }
-  if (!response.body) {
-    throw new Error("The response body is empty.");
-  }
-  return transformTextToUiMessageStream({
-    stream: response.body.pipeThrough(new TextDecoderStream())
-  });
-}
-var TextStreamChatTransport = class {
-  constructor({
-    api,
-    credentials,
-    headers,
-    body,
-    fetch: fetch2,
-    prepareRequest
-  }) {
-    this.api = api;
-    this.credentials = credentials;
-    this.headers = headers;
-    this.body = body;
-    this.fetch = fetch2;
-    this.prepareRequest = prepareRequest;
+var TextStreamChatTransport = class extends HttpChatTransport {
+  constructor(options = {}) {
+    super(options);
   }
-  submitMessages({
-    chatId,
-    messages,
-    abortSignal,
-    metadata,
-    headers,
-    body,
-    requestType
-  }) {
-    var _a17, _b;
-    const preparedRequest = (_a17 = this.prepareRequest) == null ? void 0 : _a17.call(this, {
-      id: chatId,
-      messages,
-      body: { ...this.body, ...body },
-      headers: { ...this.headers, ...headers },
-      credentials: this.credentials,
-      requestMetadata: metadata
-    });
-    return fetchTextStream({
-      api: this.api,
-      body: (preparedRequest == null ? void 0 : preparedRequest.body) !== void 0 ? preparedRequest.body : { ...this.body, ...body },
-      headers: (preparedRequest == null ? void 0 : preparedRequest.headers) !== void 0 ? preparedRequest.headers : { ...this.headers, ...headers },
-      credentials: (_b = preparedRequest == null ? void 0 : preparedRequest.credentials) != null ? _b : this.credentials,
-      abortSignal,
-      fetch: this.fetch,
-      requestType
+  processResponseStream(stream) {
+    return transformTextToUiMessageStream({
+      stream: stream.pipeThrough(new TextDecoderStream())
     });
   }
 };
@@ -2200,7 +2190,7 @@ var JsonToSseTransformStream = class extends TransformStream {
 };
 
 // src/ui-message-stream/ui-message-stream-headers.ts
-var uiMessageStreamHeaders = {
+var UI_MESSAGE_STREAM_HEADERS = {
   "content-type": "text/event-stream",
   "cache-control": "no-cache",
   connection: "keep-alive",
@@ -2214,16 +2204,20 @@ function createUIMessageStreamResponse({
   status,
   statusText,
   headers,
-  stream
+  stream,
+  consumeSseStream
 }) {
-  return new Response(
-    stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream()),
-    {
-      status,
-      statusText,
-      headers: prepareHeaders(headers, uiMessageStreamHeaders)
-    }
-  );
+  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
+  if (consumeSseStream) {
+    const [stream1, stream2] = sseStream.tee();
+    sseStream = stream1;
+    consumeSseStream({ stream: stream2 });
+  }
+  return new Response(sseStream.pipeThrough(new TextEncoderStream()), {
+    status,
+    statusText,
+    headers: prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS)
+  });
 }
 
 // src/ui-message-stream/pipe-ui-message-stream-to-response.ts
@@ -2232,16 +2226,23 @@ function pipeUIMessageStreamToResponse({
   status,
   statusText,
   headers,
-  stream
+  stream,
+  consumeSseStream
 }) {
+  let sseStream = stream.pipeThrough(new JsonToSseTransformStream());
+  if (consumeSseStream) {
+    const [stream1, stream2] = sseStream.tee();
+    sseStream = stream1;
+    consumeSseStream({ stream: stream2 });
+  }
   writeToServerResponse({
     response,
     status,
     statusText,
     headers: Object.fromEntries(
-      prepareHeaders(headers, uiMessageStreamHeaders).entries()
+      prepareHeaders(headers, UI_MESSAGE_STREAM_HEADERS).entries()
     ),
-    stream: stream.pipeThrough(new JsonToSseTransformStream()).pipeThrough(new TextEncoderStream())
+    stream: sseStream.pipeThrough(new TextEncoderStream())
   });
 }
 
@@ -3443,7 +3444,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
                 type: "tool-call",
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
-                args: part.args,
+                input: part.input,
                 providerOptions
               };
             }
@@ -3459,7 +3460,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
@@ -3661,14 +3662,11 @@ function prepareCallSettings({
 
 // core/prompt/resolve-language-model.ts
 import { gateway } from "@ai-sdk/gateway";
-var GLOBAL_DEFAULT_PROVIDER = Symbol(
-  "vercel.ai.global.defaultProvider"
-);
 function resolveLanguageModel(model) {
   if (typeof model !== "string") {
     return model;
   }
-  const globalProvider = globalThis[GLOBAL_DEFAULT_PROVIDER];
+  const globalProvider = globalThis.AI_SDK_DEFAULT_PROVIDER;
   return (globalProvider != null ? globalProvider : gateway).languageModel(model);
 }
 
@@ -3746,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()
@@ -5359,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-client":
+          return {
+            type: "provider-defined-client",
+            name: name17,
+            id: tool2.id,
+            args: tool2.args
           };
-        case "provider-defined":
+        case "provider-defined-server":
           return {
-            type: "provider-defined",
+            type: "provider-defined-server",
             name: name17,
             id: tool2.id,
             args: tool2.args
@@ -5447,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;
@@ -5455,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,
@@ -5487,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
     });
   }
@@ -5500,7 +5505,7 @@ async function doParseToolCall({
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName,
-    args: parseResult == null ? void 0 : parseResult.value
+    input: parseResult.value
   };
 }
 
@@ -5603,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) {
@@ -5917,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
@@ -5941,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
@@ -5972,7 +5977,7 @@ async function executeTools({
             throw new ToolExecutionError({
               toolCallId,
               toolName,
-              toolArgs: args,
+              toolInput: input,
               cause: error
             });
           }
@@ -5982,8 +5987,8 @@ async function executeTools({
         type: "tool-result",
         toolCallId,
         toolName,
-        args,
-        result
+        input,
+        output: result
       };
     })
   );
@@ -6073,7 +6078,7 @@ function asToolCalls(content) {
     toolCallType: toolCall.toolCallType,
     toolCallId: toolCall.toolCallId,
     toolName: toolCall.toolName,
-    args: toolCall.args
+    input: toolCall.input
   }));
 }
 
@@ -6301,7 +6306,7 @@ function runToolsTransformation({
             type: "tool-call-delta",
             toolCallId: chunk.toolCallId,
             toolName: chunk.toolName,
-            argsTextDelta: chunk.argsTextDelta
+            inputTextDelta: chunk.inputTextDelta
           });
           break;
         }
@@ -6316,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
@@ -6338,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();
@@ -6362,8 +6367,8 @@ function runToolsTransformation({
                         selectTelemetryAttributes({
                           telemetry,
                           attributes: {
-                            "ai.toolCall.result": {
-                              output: () => JSON.stringify(result)
+                            "ai.toolCall.output": {
+                              output: () => JSON.stringify(output)
                             }
                           }
                         })
@@ -6377,7 +6382,7 @@ function runToolsTransformation({
                       error: new ToolExecutionError({
                         toolCallId: toolCall.toolCallId,
                         toolName: toolCall.toolName,
-                        toolArgs: toolCall.args,
+                        toolInput: toolCall.input,
                         cause: error
                       })
                     });
@@ -7029,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
@@ -7041,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
@@ -7358,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
               });
@@ -7366,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;
             }
@@ -7901,7 +7906,7 @@ function tool(tool2) {
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-import { createEventSourceParserStream } from "@ai-sdk/provider-utils";
+import { EventSourceParserStream } from "@ai-sdk/provider-utils";
 
 // core/tool/mcp/json-rpc-message.ts
 import { z as z10 } from "zod";
@@ -8072,7 +8077,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(createEventSourceParserStream());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -8396,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();
@@ -8529,14 +8533,13 @@ export {
   DefaultChatTransport,
   DownloadError,
   EmptyResponseBodyError,
-  GLOBAL_DEFAULT_PROVIDER,
   InvalidArgumentError,
   InvalidDataContentError,
   InvalidMessageRoleError,
   InvalidPromptError,
   InvalidResponseDataError,
   InvalidStreamPartError,
-  InvalidToolArgumentsError,
+  InvalidToolInputError,
   JSONParseError,
   JsonToSseTransformStream,
   LoadAPIKeyError,
@@ -8556,6 +8559,7 @@ export {
   ToolCallRepairError,
   ToolExecutionError,
   TypeValidationError,
+  UI_MESSAGE_STREAM_HEADERS,
   UnsupportedFunctionalityError,
   asSchema5 as asSchema,
   assistantModelMessageSchema,