ai 6.0.302 → 6.0.304

package/dist/index.mjs

@@ -1225,7 +1225,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.302" : "0.0.0-test";
+var VERSION = true ? "6.0.304" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -1428,32 +1428,6 @@ async function convertToLanguageModelPrompt({
     download2 != null ? download2 : createDefaultDownloadFunction(void 0, abortSignal),
     supportedUrls
   );
-  const approvalIdToToolCallId = /* @__PURE__ */ new Map();
-  for (const message of prompt.messages) {
-    if (message.role === "assistant" && Array.isArray(message.content)) {
-      for (const part of message.content) {
-        if (part.type === "tool-approval-request" && "approvalId" in part && "toolCallId" in part) {
-          approvalIdToToolCallId.set(
-            part.approvalId,
-            part.toolCallId
-          );
-        }
-      }
-    }
-  }
-  const approvedToolCallIds = /* @__PURE__ */ new Set();
-  for (const message of prompt.messages) {
-    if (message.role === "tool") {
-      for (const part of message.content) {
-        if (part.type === "tool-approval-response") {
-          const toolCallId = approvalIdToToolCallId.get(part.approvalId);
-          if (toolCallId) {
-            approvedToolCallIds.add(toolCallId);
-          }
-        }
-      }
-    }
-  }
   const messages = [
     ...prompt.system != null ? typeof prompt.system === "string" ? [{ role: "system", content: prompt.system }] : asArray(prompt.system).map((message) => ({
       role: "system",
@@ -1506,9 +1480,6 @@ async function convertToLanguageModelPrompt({
       }
       case "user":
       case "system":
-        for (const id of approvedToolCallIds) {
-          toolCallIds.delete(id);
-        }
         if (toolCallIds.size > 0) {
           throw new MissingToolResultsError({
             toolCallIds: Array.from(toolCallIds)
@@ -1517,9 +1488,6 @@ async function convertToLanguageModelPrompt({
         break;
     }
   }
-  for (const id of approvedToolCallIds) {
-    toolCallIds.delete(id);
-  }
   if (toolCallIds.size > 0) {
     throw new MissingToolResultsError({ toolCallIds: Array.from(toolCallIds) });
   }
@@ -6051,13 +6019,16 @@ function processUIMessageStream({
   runUpdateMessageJob,
   onError,
   onToolCall,
-  onData
+  onData,
+  resetStateOnMessageIdChange = false,
+  resetStateOnFirstMessageStart = false
 }) {
+  let isFirstMessageStart = true;
   return stream.pipeThrough(
     new TransformStream({
       async transform(chunk, controller) {
         await runUpdateMessageJob(async ({ state, write }) => {
-          var _a23, _b, _c, _d, _e, _f, _g, _h;
+          var _a23, _b, _c, _d, _e, _f, _g, _h, _i;
           function getCurrentStepParts() {
             const parts = state.message.parts;
             let currentStepStartIndex = parts.length - 1;
@@ -6564,11 +6535,23 @@ function processUIMessageStream({
               break;
             }
             case "start": {
+              const shouldReset = resetStateOnFirstMessageStart && isFirstMessageStart || resetStateOnMessageIdChange && chunk.messageId != null && chunk.messageId !== state.message.id;
+              isFirstMessageStart = false;
+              if (shouldReset) {
+                Object.assign(
+                  state,
+                  createStreamingUIMessageState({
+                    lastMessage: void 0,
+                    messageId: (_i = chunk.messageId) != null ? _i : state.message.id
+                  }),
+                  { finishReason: void 0 }
+                );
+              }
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;
               }
               await updateMessageMetadata(chunk.messageMetadata);
-              if (chunk.messageId != null || chunk.messageMetadata != null) {
+              if (shouldReset || chunk.messageId != null || chunk.messageMetadata != null) {
                 write({ updateStatus: false });
               }
               break;
@@ -9622,6 +9605,7 @@ function readUIMessageStream({
   consumeStream({
     stream: processUIMessageStream({
       stream,
+      resetStateOnMessageIdChange: true,
       runUpdateMessageJob(job) {
         return job({
           state,
@@ -11960,17 +11944,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 resolve3 of this.idleWaiters.splice(0)) {
+        resolve3();
+      }
     }
-    this.isProcessing = false;
   }
   async run(job) {
     return new Promise((resolve3, reject) => {
@@ -11985,6 +11976,14 @@ var SerialJobExecutor = class {
       void this.processQueue();
     });
   }
+  async waitForIdle() {
+    if (!this.isProcessing && this.queue.length === 0) {
+      return;
+    }
+    await new Promise((resolve3) => {
+      this.idleWaiters.push(resolve3);
+    });
+  }
 };
 
 // src/util/simulate-readable-stream.ts
@@ -14608,8 +14607,12 @@ var HttpChatTransport = class {
 
 // src/ui/default-chat-transport.ts
 var DefaultChatTransport = class extends HttpChatTransport {
-  constructor(options = {}) {
+  constructor({
+    resumeStreamIsReplay = true,
+    ...options
+  } = {}) {
     super(options);
+    this.resumeStreamIsReplay = resumeStreamIsReplay;
   }
   processResponseStream(stream) {
     return parseJsonEventStream2({
@@ -14647,6 +14650,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.
@@ -14752,6 +14757,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.
      */
@@ -14790,17 +14816,18 @@ var AbstractChat = class {
         this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(updatePart);
       }
       if (this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
-        this.shouldSendAutomatically().then((shouldSend) => {
-          var _a23;
-          if (shouldSend) {
+        const shouldSend = await this.shouldSendAutomatically();
+        if (shouldSend) {
+          void this.runAutomaticRequest(() => {
+            var _a23;
             const messageId = messageIndex === -1 ? (_a23 = this.lastMessage) == null ? void 0 : _a23.id : messages[messageIndex].id;
-            this.makeRequestForToolApproval({
+            return this.makeRequestForToolApproval({
               messageId,
               messageIndex,
               ...options
             });
-          }
-        });
+          }, shouldSend);
+        }
       }
     });
     this.addToolOutput = async ({
@@ -14811,37 +14838,58 @@ var AbstractChat = class {
       options
     }) => this.jobExecutor.run(async () => {
       const messages = this.state.messages;
-      const lastMessage = messages[messages.length - 1];
       const updatePart = (part) => isToolUIPart(part) && part.toolCallId === toolCallId ? { ...part, state, output, errorText } : part;
-      this.state.replaceMessage(messages.length - 1, {
-        ...lastMessage,
-        parts: lastMessage.parts.map(updatePart)
-      });
+      const messageIndex = messages.findIndex(
+        (message) => message.parts.some(
+          (part) => isToolUIPart(part) && part.toolCallId === toolCallId
+        )
+      );
+      if (messageIndex !== -1) {
+        const message = messages[messageIndex];
+        this.state.replaceMessage(messageIndex, {
+          ...message,
+          parts: message.parts.map(updatePart)
+        });
+      }
       if (this.activeResponse) {
         this.activeResponse.state.message.parts = this.activeResponse.state.message.parts.map(updatePart);
       }
-      if (this.status !== "streaming" && this.status !== "submitted" && this.sendAutomaticallyWhen) {
-        this.shouldSendAutomatically().then((shouldSend) => {
-          var _a23;
-          if (shouldSend) {
-            this.makeRequest({
+      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: (_a23 = this.lastMessage) == null ? void 0 : _a23.id,
+              messageId: messages[messageIndex].id,
               ...options
-            });
-          }
-        });
+            }),
+            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 _a23, _b;
-      (_a23 = this.activeResumeRequest) == null ? void 0 : _a23.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;
@@ -14902,6 +14950,17 @@ var AbstractChat = class {
     }
     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 makeRequestForToolApproval({
     messageId,
     messageIndex,
@@ -14921,19 +14980,31 @@ var AbstractChat = class {
       this.pendingApprovalMessageId = (_b = (_a23 = this.state.messages[messageIndex]) == null ? void 0 : _a23.id) != null ? _b : messageId;
     }
   }
-  async makeRequest({
+  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 _a23, _b, _c;
+    var _a23, _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) {
       (_a23 = this.activeResumeRequest) == null ? void 0 : _a23.abortController.abort();
       this.activeResumeRequest = activeResumeRequest;
@@ -14995,6 +15066,7 @@ var AbstractChat = class {
     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" && (responseMessage == null ? void 0 : responseMessage.role) === "assistant" && responseMessage.parts.some(
       (part) => isToolUIPart(part) && part.state === "input-streaming"
     ) ? this.state.snapshot(responseMessage) : void 0;
@@ -15009,7 +15081,8 @@ var AbstractChat = class {
           lastMessage: trigger === "resume-stream" ? resumableResponseMessage : trigger === "regenerate-message" ? void 0 : this.state.snapshot(responseMessage),
           messageId: this.generateId()
         }),
-        abortController
+        abortController,
+        completionPromise
       };
       activeResponse = response;
       response.abortController.signal.addEventListener("abort", () => {
@@ -15040,23 +15113,32 @@ var AbstractChat = class {
           return job({
             state: response.state,
             write: ({ updateStatus = true } = {}) => {
-              var _a24;
               if (response.abortController.signal.aborted) {
                 return;
               }
               if (updateStatus) {
                 this.setStatus({ status: "streaming" });
               }
-              if (usesEarlierAssistantMessage) {
+              const existingMessageIndex = this.state.messages.findLastIndex(
+                (message) => message.id === response.state.message.id
+              );
+              if (existingMessageIndex !== -1) {
                 this.state.replaceMessage(
-                  responseMessageIndex,
+                  existingMessageIndex,
                   response.state.message
                 );
-              } else if (response.state.message.id === ((_a24 = this.lastMessage) == null ? void 0 : _a24.id)) {
-                this.state.replaceMessage(
-                  this.state.messages.length - 1,
-                  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);
               }
@@ -15067,6 +15149,8 @@ var AbstractChat = class {
       await consumeStream({
         stream: processUIMessageStream({
           stream,
+          resetStateOnMessageIdChange: trigger === "resume-stream",
+          resetStateOnFirstMessageStart: trigger === "resume-stream" && this.transport.resumeStreamIsReplay,
           onToolCall: this.onToolCall,
           onData: this.onData,
           messageMetadataSchema: this.messageMetadataSchema,
@@ -15142,14 +15226,19 @@ var AbstractChat = class {
         clearActiveResumeRequest();
       }
     }
-    if (!isError && await this.shouldSendAutomatically()) {
-      await this.makeRequest({
-        trigger: "submit-message",
-        messageId: (_c = this.lastMessage) == null ? void 0 : _c.id,
-        metadata,
-        headers,
-        body
-      });
+    if (!isAbort && !isError) {
+      await this.runAutomaticRequest(
+        () => {
+          var _a24;
+          return this.makeRequest({
+            trigger: "submit-message",
+            messageId: (_a24 = this.lastMessage) == null ? void 0 : _a24.id,
+            metadata,
+            headers,
+            body
+          });
+        }
+      );
     }
   }
 };