ai 5.0.272 → 5.0.274

package/dist/index.mjs

@@ -727,7 +727,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "5.0.272" : "0.0.0-test";
+var VERSION = true ? "5.0.274" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -3748,7 +3748,8 @@ function processUIMessageStream({
   runUpdateMessageJob,
   onError,
   onToolCall,
-  onData
+  onData,
+  resetStateOnMessageIdChange = false
 }) {
   return stream.pipeThrough(
     new TransformStream({
@@ -4165,6 +4166,16 @@ function processUIMessageStream({
               break;
             }
             case "start": {
+              if (resetStateOnMessageIdChange && chunk.messageId != null && chunk.messageId !== state.message.id) {
+                Object.assign(
+                  state,
+                  createStreamingUIMessageState({
+                    lastMessage: void 0,
+                    messageId: chunk.messageId
+                  }),
+                  { finishReason: void 0 }
+                );
+              }
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
               }
@@ -6322,6 +6333,20 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// src/util/get-own.ts
+function getOwn(obj, key) {
+  return obj != null && Object.hasOwn(obj, key) ? obj[key] : void 0;
+}
+
+// src/ui/unavailable-tool.ts
+function markToolPartAsUnavailable(part) {
+  part.dynamic = false;
+  return part;
+}
+function isToolPartFromUnavailableTool(part) {
+  return part.type === "dynamic-tool" && part.dynamic === false;
+}
+
 // src/ui/convert-to-model-messages.ts
 function convertToModelMessages(messages, options) {
   const modelMessages = [];
@@ -6333,6 +6358,25 @@ function convertToModelMessages(messages, options) {
       )
     }));
   }
+  function createModelOutput({
+    toolPart,
+    toolName,
+    output,
+    errorMode
+  }) {
+    const tool2 = getOwn(options == null ? void 0 : options.tools, toolName);
+    if (errorMode === "none" && tool2 == null && isToolPartFromUnavailableTool(toolPart)) {
+      return {
+        type: "text",
+        value: "Tool output omitted because the tool is no longer available."
+      };
+    }
+    return createToolModelOutput({
+      output,
+      tool: tool2,
+      errorMode
+    });
+  }
   for (const message of messages) {
     switch (message.role) {
       case "system": {
@@ -6386,7 +6430,7 @@ function convertToModelMessages(messages, options) {
       case "assistant": {
         if (message.parts != null) {
           let processBlock2 = function() {
-            var _a16, _b, _c;
+            var _a16, _b;
             if (block.length === 0) {
               return;
             }
@@ -6438,9 +6482,10 @@ function convertToModelMessages(messages, options) {
                       type: "tool-result",
                       toolCallId: part.toolCallId,
                       toolName,
-                      output: createToolModelOutput({
+                      output: createModelOutput({
+                        toolPart: part,
+                        toolName,
                         output: part.state === "output-error" ? part.errorText : part.output,
-                        tool: (_b = options == null ? void 0 : options.tools) == null ? void 0 : _b[toolName],
                         errorMode: part.state === "output-error" ? "json" : "none"
                       }),
                       ...part.callProviderMetadata != null ? { providerOptions: part.callProviderMetadata } : {}
@@ -6448,7 +6493,7 @@ function convertToModelMessages(messages, options) {
                   }
                 }
               } else if (isDataUIPart(part)) {
-                const dataPart = (_c = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _c.call(
+                const dataPart = (_b = options == null ? void 0 : options.convertDataPart) == null ? void 0 : _b.call(
                   options,
                   part
                 );
@@ -6471,7 +6516,6 @@ function convertToModelMessages(messages, options) {
               modelMessages.push({
                 role: "tool",
                 content: toolParts.map((toolPart) => {
-                  var _a17;
                   switch (toolPart.state) {
                     case "output-error":
                     case "output-available": {
@@ -6480,9 +6524,10 @@ function convertToModelMessages(messages, options) {
                         type: "tool-result",
                         toolCallId: toolPart.toolCallId,
                         toolName,
-                        output: createToolModelOutput({
+                        output: createModelOutput({
+                          toolPart,
+                          toolName,
                           output: toolPart.state === "output-error" ? toolPart.errorText : toolPart.output,
-                          tool: (_a17 = options == null ? void 0 : options.tools) == null ? void 0 : _a17[toolName],
                           errorMode: toolPart.state === "output-error" ? "text" : "none"
                         }),
                         ...toolPart.callProviderMetadata != null ? { providerOptions: toolPart.callProviderMetadata } : {}
@@ -6677,11 +6722,6 @@ var DefaultEmbedResult = class {
   }
 };
 
-// src/util/get-own.ts
-function getOwn(obj, key) {
-  return obj != null && Object.hasOwn(obj, key) ? obj[key] : void 0;
-}
-
 // src/util/set-own.ts
 function setOwn(object2, key, value) {
   Object.defineProperty(object2, key, {
@@ -7961,17 +8001,24 @@ var SerialJobExecutor = class {
   constructor() {
     this.queue = [];
     this.isProcessing = false;
+    this.idleWaiters = [];
   }
   async processQueue() {
     if (this.isProcessing) {
       return;
     }
     this.isProcessing = true;
-    while (this.queue.length > 0) {
-      await this.queue[0]();
-      this.queue.shift();
+    try {
+      while (this.queue.length > 0) {
+        await this.queue[0]();
+        this.queue.shift();
+      }
+    } finally {
+      this.isProcessing = false;
+      for (const resolve2 of this.idleWaiters.splice(0)) {
+        resolve2();
+      }
     }
-    this.isProcessing = false;
   }
   async run(job) {
     return new Promise((resolve2, reject) => {
@@ -7986,6 +8033,14 @@ var SerialJobExecutor = class {
       void this.processQueue();
     });
   }
+  async waitForIdle() {
+    if (!this.isProcessing && this.queue.length === 0) {
+      return;
+    }
+    await new Promise((resolve2) => {
+      this.idleWaiters.push(resolve2);
+    });
+  }
 };
 
 // src/util/simulate-readable-stream.ts
@@ -9753,7 +9808,9 @@ import {
 } from "@ai-sdk/provider-utils";
 function appendPathToUrl(url, path) {
   const queryOrFragmentStart = url.search(/[?#]/);
-  return queryOrFragmentStart === -1 ? `${url}${path}` : `${url.slice(0, queryOrFragmentStart)}${path}${url.slice(queryOrFragmentStart)}`;
+  const urlPath = queryOrFragmentStart === -1 ? url : url.slice(0, queryOrFragmentStart);
+  const suffix = queryOrFragmentStart === -1 ? "" : url.slice(queryOrFragmentStart);
+  return `${urlPath.endsWith("/") && path.startsWith("/") ? urlPath.slice(0, -1) : urlPath}${path}${suffix}`;
 }
 var HttpChatTransport = class {
   constructor({
@@ -9924,6 +9981,8 @@ var AbstractChat = class {
     this.activeResumeRequest = void 0;
     this.resumableStreamState = void 0;
     this.jobExecutor = new SerialJobExecutor();
+    this.activeStopCount = 0;
+    this.stopGeneration = 0;
     /**
      * Appends or replaces a user message to the chat list. This triggers the API call to fetch
      * the assistant's response.
@@ -10014,6 +10073,27 @@ var AbstractChat = class {
     this.resumeStream = async (options = {}) => {
       await this.makeRequest({ trigger: "resume-stream", ...options });
     };
+    /**
+     * Resume the stream if the latest response ended with a resumable network
+     * disconnect. If a response is still active, wait for it to settle first so
+     * disconnects reported shortly after the caller's trigger are handled.
+     *
+     * @internal
+     */
+    this["~resumeStreamIfDisconnected"] = async ({
+      shouldResume = () => true
+    } = {}) => {
+      const activeResponse = this.activeResponse;
+      if (this.resumableStreamState == null && activeResponse != null) {
+        await activeResponse.completionPromise;
+        if (this.resumableStreamState !== activeResponse.state) {
+          return;
+        }
+      }
+      if (this.resumableStreamState != null && shouldResume()) {
+        await this.resumeStream();
+      }
+    };
     /**
      * Clear the error state and set the status to ready if the chat is in an error state.
      */
@@ -10030,15 +10110,21 @@ var AbstractChat = class {
       output,
       errorText
     }) => this.jobExecutor.run(async () => {
-      var _a16, _b;
       const messages = this.state.messages;
-      const lastMessage = messages[messages.length - 1];
-      this.state.replaceMessage(messages.length - 1, {
-        ...lastMessage,
-        parts: lastMessage.parts.map(
-          (part) => isToolOrDynamicToolUIPart(part) && part.toolCallId === toolCallId ? { ...part, state, output, errorText } : part
+      const messageIndex = messages.findIndex(
+        (message) => message.parts.some(
+          (part) => isToolOrDynamicToolUIPart(part) && part.toolCallId === toolCallId
         )
-      });
+      );
+      if (messageIndex !== -1) {
+        const message = messages[messageIndex];
+        this.state.replaceMessage(messageIndex, {
+          ...message,
+          parts: message.parts.map(
+            (part) => isToolOrDynamicToolUIPart(part) && part.toolCallId === toolCallId ? { ...part, state, output, errorText } : part
+          )
+        });
+      }
       if (this.activeResponse) {
         this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(
           (part) => isToolOrDynamicToolUIPart(part) && part.toolCallId === toolCallId ? {
@@ -10049,22 +10135,41 @@ var AbstractChat = class {
           } : part
         );
       }
-      if (this.status !== "streaming" && this.status !== "submitted" && ((_a16 = this.sendAutomaticallyWhen) == null ? void 0 : _a16.call(this, { messages: this.state.messages }))) {
-        this.makeRequest({
-          trigger: "submit-message",
-          messageId: (_b = this.lastMessage) == null ? void 0 : _b.id
-        });
+      if (messageIndex !== -1 && this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
+        const shouldSend = await this.shouldSendAutomatically();
+        if (shouldSend) {
+          void this.runAutomaticRequest(
+            () => this.makeRequest({
+              trigger: "submit-message",
+              messageId: messages[messageIndex].id
+            }),
+            shouldSend
+          );
+        }
       }
     });
     /** @deprecated Use addToolOutput */
     this.addToolResult = this.addToolOutput;
     /**
-     * Abort the current request immediately, keep the generated tokens if any.
+     * Abort the current request, keep the generated tokens if any, and wait for
+     * the request pipeline to finish.
      */
     this.stop = async () => {
-      var _a16, _b;
-      (_a16 = this.activeResumeRequest) == null ? void 0 : _a16.abortController.abort();
-      (_b = this.activeResponse) == null ? void 0 : _b.abortController.abort();
+      this.activeStopCount++;
+      this.stopGeneration++;
+      try {
+        const activeResumeRequest = this.activeResumeRequest;
+        const activeResponse = this.activeResponse;
+        activeResumeRequest == null ? void 0 : activeResumeRequest.abortController.abort();
+        activeResponse == null ? void 0 : activeResponse.abortController.abort();
+        await Promise.all([
+          activeResumeRequest == null ? void 0 : activeResumeRequest.completionPromise,
+          activeResponse == null ? void 0 : activeResponse.completionPromise
+        ]);
+        await this.jobExecutor.waitForIdle();
+      } finally {
+        this.activeStopCount--;
+      }
     };
     this.id = id;
     this.transport = transport;
@@ -10110,19 +10215,53 @@ var AbstractChat = class {
   set messages(messages) {
     this.state.messages = messages;
   }
-  async makeRequest({
+  async shouldSendAutomatically() {
+    if (!this.sendAutomaticallyWhen)
+      return false;
+    const result = this.sendAutomaticallyWhen({
+      messages: this.state.messages
+    });
+    if (result && typeof result === "object" && "then" in result) {
+      return await result;
+    }
+    return result;
+  }
+  async runAutomaticRequest(request, shouldSend) {
+    const stopGeneration = this.stopGeneration;
+    const startedWhileStopping = this.activeStopCount > 0;
+    if (!(shouldSend != null ? shouldSend : await this.shouldSendAutomatically())) {
+      return;
+    }
+    if (startedWhileStopping || stopGeneration !== this.stopGeneration || this.activeStopCount > 0) {
+      return;
+    }
+    await request();
+  }
+  async makeRequest(options) {
+    const completion = createResolvablePromise();
+    try {
+      await this.makeRequestImpl({
+        ...options,
+        completionPromise: completion.promise
+      });
+    } finally {
+      completion.resolve();
+    }
+  }
+  async makeRequestImpl({
     trigger,
     metadata,
     headers,
     body,
-    messageId
+    messageId,
+    completionPromise
   }) {
-    var _a16, _b, _c, _d;
+    var _a16, _b;
     if (trigger !== "resume-stream") {
       this.resumableStreamState = void 0;
     }
     const abortController = new AbortController();
-    const activeResumeRequest = trigger === "resume-stream" ? { abortController } : void 0;
+    const activeResumeRequest = trigger === "resume-stream" ? { abortController, completionPromise } : void 0;
     if (activeResumeRequest) {
       (_a16 = this.activeResumeRequest) == null ? void 0 : _a16.abortController.abort();
       this.activeResumeRequest = activeResumeRequest;
@@ -10135,9 +10274,13 @@ var AbstractChat = class {
     };
     this.setStatus({ status: "submitted", error: void 0 });
     const lastMessage = this.lastMessage;
+    const responseMessageIndex = trigger === "submit-message" && messageId != null ? this.state.messages.findIndex((message) => message.id === messageId) : this.state.messages.length - 1;
+    const responseMessage = responseMessageIndex === -1 ? lastMessage : this.state.messages[responseMessageIndex];
+    const originalResponseMessageId = responseMessage == null ? void 0 : responseMessage.id;
     const resumableResponseMessage = trigger === "resume-stream" && (lastMessage == null ? void 0 : lastMessage.role) === "assistant" && lastMessage.parts.some(
       (part) => isToolOrDynamicToolUIPart(part) && part.state === "input-streaming"
     ) ? this.state.snapshot(lastMessage) : void 0;
+    const usesEarlierAssistantMessage = responseMessageIndex !== -1 && responseMessageIndex < this.state.messages.length - 1 && (responseMessage == null ? void 0 : responseMessage.role) === "assistant";
     let isAbort = false;
     let isDisconnect = false;
     let isError = false;
@@ -10145,10 +10288,11 @@ var AbstractChat = class {
     try {
       const response = {
         state: trigger === "resume-stream" && this.resumableStreamState != null ? this.resumableStreamState : createStreamingUIMessageState({
-          lastMessage: trigger === "resume-stream" ? resumableResponseMessage : this.state.snapshot(lastMessage),
+          lastMessage: trigger === "resume-stream" ? resumableResponseMessage : this.state.snapshot(responseMessage),
           messageId: this.generateId()
         }),
-        abortController
+        abortController,
+        completionPromise
       };
       activeResponse = response;
       response.abortController.signal.addEventListener("abort", () => {
@@ -10202,19 +10346,32 @@ var AbstractChat = class {
           return job({
             state: response.state,
             write: ({ updateStatus = true } = {}) => {
-              var _a17;
               if (response.abortController.signal.aborted) {
                 return;
               }
               if (updateStatus) {
                 this.setStatus({ status: "streaming" });
               }
-              const replaceLastMessage = response.state.message.id === ((_a17 = this.lastMessage) == null ? void 0 : _a17.id);
-              if (replaceLastMessage) {
+              const existingMessageIndex = this.state.messages.findLastIndex(
+                (message) => message.id === response.state.message.id
+              );
+              if (existingMessageIndex !== -1) {
                 this.state.replaceMessage(
-                  this.state.messages.length - 1,
+                  existingMessageIndex,
                   response.state.message
                 );
+              } else if (usesEarlierAssistantMessage) {
+                const originalMessageIndex = this.state.messages.findLastIndex(
+                  (message) => message.id === originalResponseMessageId
+                );
+                if (originalMessageIndex !== -1) {
+                  this.state.replaceMessage(
+                    originalMessageIndex,
+                    response.state.message
+                  );
+                } else {
+                  this.state.pushMessage(response.state.message);
+                }
               } else {
                 this.state.pushMessage(response.state.message);
               }
@@ -10300,14 +10457,19 @@ var AbstractChat = class {
         clearActiveResumeRequest();
       }
     }
-    if (((_c = this.sendAutomaticallyWhen) == null ? void 0 : _c.call(this, { messages: this.state.messages })) && !isError) {
-      await this.makeRequest({
-        trigger: "submit-message",
-        messageId: (_d = this.lastMessage) == null ? void 0 : _d.id,
-        metadata,
-        headers,
-        body
-      });
+    if (!isAbort && !isError) {
+      await this.runAutomaticRequest(
+        () => {
+          var _a17;
+          return this.makeRequest({
+            trigger: "submit-message",
+            messageId: (_a17 = this.lastMessage) == null ? void 0 : _a17.id,
+            metadata,
+            headers,
+            body
+          });
+        }
+      );
     }
   }
 };
@@ -10393,20 +10555,20 @@ function asDynamicToolPart(toolPart) {
     ...toolPart.callProviderMetadata === void 0 ? {} : { callProviderMetadata: toolPart.callProviderMetadata }
   };
   if (toolPart.state === "output-available") {
-    return {
+    return markToolPartAsUnavailable({
       ...common,
       state: "output-available",
       input: toolPart.input,
       output: toolPart.output,
       ...toolPart.preliminary === void 0 ? {} : { preliminary: toolPart.preliminary }
-    };
+    });
   }
-  return {
+  return markToolPartAsUnavailable({
     ...common,
     state: "output-error",
     input: toolPart.input,
     errorText: toolPart.errorText
-  };
+  });
 }
 var uiMessagesSchema = lazyValidator2(
   () => zodSchema2(
@@ -10462,6 +10624,7 @@ var uiMessagesSchema = lazyValidator2(
             }),
             z8.object({
               type: z8.literal("dynamic-tool"),
+              dynamic: z8.literal(false).optional(),
               toolName: z8.string(),
               toolCallId: z8.string(),
               state: z8.literal("input-streaming"),
@@ -10473,6 +10636,7 @@ var uiMessagesSchema = lazyValidator2(
             }),
             z8.object({
               type: z8.literal("dynamic-tool"),
+              dynamic: z8.literal(false).optional(),
               toolName: z8.string(),
               toolCallId: z8.string(),
               state: z8.literal("input-available"),
@@ -10484,6 +10648,7 @@ var uiMessagesSchema = lazyValidator2(
             }),
             z8.object({
               type: z8.literal("dynamic-tool"),
+              dynamic: z8.literal(false).optional(),
               toolName: z8.string(),
               toolCallId: z8.string(),
               state: z8.literal("output-available"),
@@ -10496,6 +10661,7 @@ var uiMessagesSchema = lazyValidator2(
             }),
             z8.object({
               type: z8.literal("dynamic-tool"),
+              dynamic: z8.literal(false).optional(),
               toolName: z8.string(),
               toolCallId: z8.string(),
               state: z8.literal("output-error"),
@@ -10695,7 +10861,7 @@ async function safeValidateUIMessages({
           }
           const toolPart = part;
           const toolName = toolPart.type.slice(5);
-          const tool2 = tools[toolName];
+          const tool2 = getOwn(tools, toolName);
           if (!tool2 && (toolPart.state === "output-available" || toolPart.state === "output-error")) {
             message.parts[partIdx] = asDynamicToolPart(toolPart);
             continue;
@@ -10936,6 +11102,7 @@ function readUIMessageStream({
   consumeStream({
     stream: processUIMessageStream({
       stream,
+      resetStateOnMessageIdChange: true,
       runUpdateMessageJob(job) {
         return job({
           state,