ai 7.0.26 → 7.0.28

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # ai
 
+## 7.0.28
+
+### Patch Changes
+
+- 0bc8d4f: Fix chat `onFinish` handling when overlapping requests clear the active response before a resume stream finishes.
+
+## 7.0.27
+
+### Patch Changes
+
+- ac01b79: Allow validating assistant UI messages with empty parts so persisted errored responses remain loadable.
+- 2696562: `experimental_streamTranscribe` result promises now resolve without consuming `fullStream`: accessing any result promise consumes the stream internally. Previously `await result.text` alone deadlocked on transform backpressure. Because live transcription streams can be unbounded, `fullStream` is explicitly single-consumer (no replay buffering): access it once, before any result promise, when both stream parts and final results are needed.
+- Updated dependencies [31c7be8]
+- Updated dependencies [4d096f6]
+  - @ai-sdk/provider-utils@5.0.10
+  - @ai-sdk/gateway@4.0.20
+
 ## 7.0.26
 
 ### Patch Changes

package/dist/index.d.ts

@@ -8840,6 +8840,11 @@ interface StreamTranscriptionResult {
     readonly providerMetadata: PromiseLike<Record<string, JSONObject>>;
     /**
      * Full stream of transcription parts.
+     *
+     * This is a single-consumer live stream and can only be accessed once.
+     * Access it before any result promise when both stream parts and final
+     * results are needed; accessing a result promise first consumes the stream
+     * internally and makes `fullStream` unavailable.
      */
     readonly fullStream: AsyncIterableStream<TranscriptionStreamPart>;
 }

package/dist/index.js

@@ -1089,7 +1089,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.26" : "0.0.0-test";
+var VERSION = true ? "7.0.28" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -10891,7 +10891,19 @@ var uiMessagesSchema = lazySchema2(
               })
             })
           ])
-        ).nonempty("Message must contain at least one part")
+        )
+      }).superRefine((message, context) => {
+        if (message.role !== "assistant" && message.parts.length === 0) {
+          context.addIssue({
+            origin: "array",
+            code: "too_small",
+            minimum: 1,
+            inclusive: true,
+            input: message.parts,
+            path: ["parts"],
+            message: "Message must contain at least one part"
+          });
+        }
       })
     ).nonempty("Messages array must not be empty")
   )
@@ -16089,35 +16101,60 @@ function streamTranscribe({
     transform.writable.abort(reason).catch(() => {
     });
   });
+  let streamOwner = "unclaimed";
+  function consumeStream2() {
+    if (streamOwner === "full-stream" || streamOwner === "result-promises") {
+      return;
+    }
+    streamOwner = "result-promises";
+    const reader = transform.readable.getReader();
+    void (async () => {
+      while (!(await reader.read()).done) {
+      }
+    })().catch(() => {
+    });
+  }
+  function getFullStream() {
+    if (streamOwner !== "unclaimed") {
+      throw new Error(
+        streamOwner === "full-stream" ? "fullStream can only be accessed once." : "fullStream cannot be accessed after a result promise."
+      );
+    }
+    streamOwner = "full-stream";
+    return asAsyncIterableStream(transform.readable);
+  }
   return {
     get text() {
+      consumeStream2();
       return textPromise.promise;
     },
     get segments() {
+      consumeStream2();
       return segmentsPromise.promise;
     },
     get language() {
+      consumeStream2();
       return languagePromise.promise;
     },
     get durationInSeconds() {
+      consumeStream2();
       return durationInSecondsPromise.promise;
     },
     get warnings() {
+      consumeStream2();
       return warningsPromise.promise;
     },
     get responses() {
+      consumeStream2();
       return responsesPromise.promise;
     },
     get providerMetadata() {
+      consumeStream2();
       return providerMetadataPromise.promise;
     },
-    // `transform.readable` is fresh and exclusively owned here, so attach the
-    // async iterator in place rather than piping through another transform.
-    // The extra transform (as `createAsyncIterableStream` would add) chains two
-    // transforms fed by the active model pipe below and surfaces a spurious
-    // unhandled `undefined` rejection when the consumer cancels early on
-    // Node.js 26.
-    fullStream: asAsyncIterableStream(transform.readable)
+    get fullStream() {
+      return getFullStream();
+    }
   };
 }
 
@@ -16695,7 +16732,7 @@ var AbstractChat = class {
     body,
     messageId
   }) {
-    var _a22, _b, _c;
+    var _a22, _b;
     let resumeStream;
     if (trigger === "resume-stream") {
       try {
@@ -16722,18 +16759,20 @@ var AbstractChat = class {
     let isAbort = false;
     let isDisconnect = false;
     let isError = false;
+    let activeResponse;
     try {
-      const activeResponse = {
+      const response = {
         state: createStreamingUIMessageState({
           lastMessage: this.state.snapshot(lastMessage),
           messageId: this.generateId()
         }),
         abortController: new AbortController()
       };
-      activeResponse.abortController.signal.addEventListener("abort", () => {
+      activeResponse = response;
+      response.abortController.signal.addEventListener("abort", () => {
         isAbort = true;
       });
-      this.activeResponse = activeResponse;
+      this.activeResponse = response;
       let stream;
       if (trigger === "resume-stream") {
         stream = resumeStream;
@@ -16741,7 +16780,7 @@ var AbstractChat = class {
         stream = await this.transport.sendMessages({
           chatId: this.id,
           messages: this.state.messages,
-          abortSignal: activeResponse.abortController.signal,
+          abortSignal: response.abortController.signal,
           metadata,
           headers,
           body,
@@ -16753,18 +16792,18 @@ var AbstractChat = class {
         // serialize the job execution to avoid race conditions:
         this.jobExecutor.run(
           () => job({
-            state: activeResponse.state,
+            state: response.state,
             write: () => {
               var _a23;
               this.setStatus({ status: "streaming" });
-              const replaceLastMessage = activeResponse.state.message.id === ((_a23 = this.lastMessage) == null ? void 0 : _a23.id);
+              const replaceLastMessage = response.state.message.id === ((_a23 = this.lastMessage) == null ? void 0 : _a23.id);
               if (replaceLastMessage) {
                 this.state.replaceMessage(
                   this.state.messages.length - 1,
-                  activeResponse.state.message
+                  response.state.message
                 );
               } else {
-                this.state.pushMessage(activeResponse.state.message);
+                this.state.pushMessage(response.state.message);
               }
             }
           })
@@ -16803,23 +16842,27 @@ var AbstractChat = class {
       this.setStatus({ status: "error", error: err });
     } finally {
       try {
-        (_b = this.onFinish) == null ? void 0 : _b.call(this, {
-          message: this.activeResponse.state.message,
-          messages: this.state.messages,
-          isAbort,
-          isDisconnect,
-          isError,
-          finishReason: (_a22 = this.activeResponse) == null ? void 0 : _a22.state.finishReason
-        });
+        if (activeResponse) {
+          (_a22 = this.onFinish) == null ? void 0 : _a22.call(this, {
+            message: activeResponse.state.message,
+            messages: this.state.messages,
+            isAbort,
+            isDisconnect,
+            isError,
+            finishReason: activeResponse.state.finishReason
+          });
+        }
       } catch (err) {
         console.error(err);
       }
-      this.activeResponse = void 0;
+      if (this.activeResponse === activeResponse) {
+        this.activeResponse = void 0;
+      }
     }
     if (!isError && await this.shouldSendAutomatically()) {
       await this.makeRequest({
         trigger: "submit-message",
-        messageId: (_c = this.lastMessage) == null ? void 0 : _c.id,
+        messageId: (_b = this.lastMessage) == null ? void 0 : _b.id,
         metadata,
         headers,
         body