ai 7.0.26 → 7.0.28

package/dist/internal/index.js

@@ -85,7 +85,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 ({

package/docs/02-getting-started/09-coding-agents.mdx

@@ -84,7 +84,7 @@ const result = await generateText({
 Start the DevTools viewer in a separate terminal:
 
 ```bash
-npx @ai-sdk/devtools
+npx @ai-sdk/devtools@latest
 ```
 
 Open [http://localhost:4983](http://localhost:4983) to inspect your AI SDK interactions in real time.

package/docs/03-ai-sdk-core/36-transcription.mdx

@@ -71,6 +71,12 @@ for await (const part of result.fullStream) {
 console.log(await result.text);
 ```
 
+`fullStream` is a single-consumer live stream and can only be accessed once.
+When you need both stream parts and final results, access `fullStream` first and
+await the result promises while or after consuming it. Accessing a result
+promise first consumes the stream internally, so `fullStream` is no longer
+available. This avoids retaining an unbounded replay buffer for live audio.
+
 To access the final transcript metadata:
 
 ```ts

package/docs/03-ai-sdk-core/65-devtools.mdx

@@ -74,7 +74,7 @@ const result = streamText({
 Start the DevTools viewer:
 
 ```bash
-npx @ai-sdk/devtools
+npx @ai-sdk/devtools@latest
 ```
 
 Open [http://localhost:4983](http://localhost:4983) to view your AI SDK interactions.
@@ -87,9 +87,13 @@ For example, if your API is in `apps/api`, run:
 
 ```bash
 cd apps/api
-npx @ai-sdk/devtools
+npx @ai-sdk/devtools@latest
 ```
 
+The explicit `@latest` tag ensures that `npx` installs an executable copy
+instead of selecting a transitive dependency whose binary is not linked into
+the workspace.
+
 ## Captured data
 
 DevTools captures the following information from your AI SDK calls:

package/docs/07-reference/01-ai-sdk-core/11-stream-transcribe.mdx

@@ -99,7 +99,7 @@ console.log(await result.text);
       name: 'fullStream',
       type: 'AsyncIterableStream<TranscriptionStreamPart>',
       description:
-        'A stream of transcription parts: `transcript-delta`, `transcript-partial`, `transcript-final`, `raw`, and `error`.',
+        'A single-consumer live stream of transcription parts: `transcript-delta`, `transcript-partial`, `transcript-final`, `raw`, and `error`. Access it once, 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.',
     },
     {
       name: 'text',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.26",
+  "version": "7.0.28",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.19",
+    "@ai-sdk/gateway": "4.0.20",
     "@ai-sdk/provider": "4.0.3",
-    "@ai-sdk/provider-utils": "5.0.9"
+    "@ai-sdk/provider-utils": "5.0.10"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/transcribe/stream-transcribe-result.ts

@@ -81,6 +81,11 @@ export interface StreamTranscriptionResult {
 
   /**
    * 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/src/transcribe/stream-transcribe.ts

@@ -285,34 +285,73 @@ export function streamTranscribe({
     });
   });
 
+  // Transcription streams can be unbounded (live microphone + raw chunks), so
+  // unlike streamText we cannot retain an unread tee branch for replay. The
+  // output stream has one owner: either fullStream, or the first result promise
+  // getter which claims and drains it internally.
+  let streamOwner: 'unclaimed' | 'full-stream' | 'result-promises' =
+    'unclaimed';
+
+  function consumeStream() {
+    if (streamOwner === 'full-stream' || streamOwner === 'result-promises') {
+      return;
+    }
+    streamOwner = 'result-promises';
+    const reader = transform.readable.getReader();
+    void (async () => {
+      while (!(await reader.read()).done) {
+        // drain; results surface via the promises
+      }
+    })().catch(() => {
+      // stream errors reject the promises via the pipe handler above
+    });
+  }
+
+  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';
+    // Direct ownership preserves backpressure and cancellation: cancelling
+    // this stream reaches Transformer.cancel and aborts the model pipe.
+    return asAsyncIterableStream(transform.readable);
+  }
+
   return {
     get text() {
+      consumeStream();
       return textPromise.promise;
     },
     get segments() {
+      consumeStream();
       return segmentsPromise.promise;
     },
     get language() {
+      consumeStream();
       return languagePromise.promise;
     },
     get durationInSeconds() {
+      consumeStream();
       return durationInSecondsPromise.promise;
     },
     get warnings() {
+      consumeStream();
       return warningsPromise.promise;
     },
     get responses() {
+      consumeStream();
       return responsesPromise.promise;
     },
     get providerMetadata() {
+      consumeStream();
       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();
+    },
   };
 }

package/src/ui/chat.ts

@@ -650,9 +650,10 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
     let isAbort = false;
     let isDisconnect = false;
     let isError = false;
+    let activeResponse: ActiveResponse<UI_MESSAGE> | undefined;
 
     try {
-      const activeResponse = {
+      const response = {
         state: createStreamingUIMessageState({
           lastMessage: this.state.snapshot(lastMessage),
           messageId: this.generateId(),
@@ -660,11 +661,13 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         abortController: new AbortController(),
       } as ActiveResponse<UI_MESSAGE>;
 
-      activeResponse.abortController.signal.addEventListener('abort', () => {
+      activeResponse = response;
+
+      response.abortController.signal.addEventListener('abort', () => {
         isAbort = true;
       });
 
-      this.activeResponse = activeResponse;
+      this.activeResponse = response;
 
       let stream: ReadableStream<UIMessageChunk>;
 
@@ -674,7 +677,7 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         stream = await this.transport.sendMessages({
           chatId: this.id,
           messages: this.state.messages,
-          abortSignal: activeResponse.abortController.signal,
+          abortSignal: response.abortController.signal,
           metadata,
           headers,
           body,
@@ -692,21 +695,21 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
         // serialize the job execution to avoid race conditions:
         this.jobExecutor.run(() =>
           job({
-            state: activeResponse.state,
+            state: response.state,
             write: () => {
               // streaming is set on first write (before it should be "submitted")
               this.setStatus({ status: 'streaming' });
 
               const replaceLastMessage =
-                activeResponse.state.message.id === this.lastMessage?.id;
+                response.state.message.id === this.lastMessage?.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);
               }
             },
           }),
@@ -756,19 +759,23 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
       this.setStatus({ status: 'error', error: err as Error });
     } finally {
       try {
-        this.onFinish?.({
-          message: this.activeResponse!.state.message,
-          messages: this.state.messages,
-          isAbort,
-          isDisconnect,
-          isError,
-          finishReason: this.activeResponse?.state.finishReason,
-        });
+        if (activeResponse) {
+          this.onFinish?.({
+            message: activeResponse.state.message,
+            messages: this.state.messages,
+            isAbort,
+            isDisconnect,
+            isError,
+            finishReason: activeResponse.state.finishReason,
+          });
+        }
       } catch (err) {
         console.error(err);
       }
 
-      this.activeResponse = undefined;
+      if (this.activeResponse === activeResponse) {
+        this.activeResponse = undefined;
+      }
     }
 
     // automatically send the message if the sendAutomaticallyWhen function returns true

package/src/ui/validate-ui-messages.ts

@@ -30,12 +30,12 @@ const uiMessagesSchema = lazySchema(() =>
   zodSchema(
     z
       .array(
-        z.object({
-          id: z.string(),
-          role: z.enum(['system', 'user', 'assistant']),
-          metadata: z.unknown().optional(),
-          parts: z
-            .array(
+        z
+          .object({
+            id: z.string(),
+            role: z.enum(['system', 'user', 'assistant']),
+            metadata: z.unknown().optional(),
+            parts: z.array(
               z.union([
                 z.object({
                   type: z.literal('text'),
@@ -343,9 +343,21 @@ const uiMessagesSchema = lazySchema(() =>
                   }),
                 }),
               ]),
-            )
-            .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'),
   ),