ai 7.0.25 → 7.0.27

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # ai
 
+## 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
+
+- 27d294d: feat(ai): group orphaned tool calls after tool approvals under parent span
+
 ## 7.0.25
 
 ### 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.25" : "0.0.0-test";
+var VERSION = true ? "7.0.27" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -9057,6 +9057,9 @@ var DefaultStreamTextResult = class {
         var _a23;
         return (_a23 = streamTextTracingChannelContext == null ? void 0 : streamTextTracingChannelContext.run(execute)) != null ? _a23 : execute();
       };
+      const runInTracingChannelSpanInStreamText = telemetryDispatcher.runInTracingChannelSpan == null ? void 0 : (options) => runInStreamTextTracingChannelContext(
+        () => telemetryDispatcher.runInTracingChannelSpan(options)
+      );
       await notify({
         event: startEvent,
         callbacks: [onStart, telemetryDispatcher.onStart]
@@ -9127,7 +9130,7 @@ var DefaultStreamTextResult = class {
                   telemetryDispatcher.onToolExecutionEnd
                 ),
                 executeToolInTelemetryContext: telemetryDispatcher.executeTool,
-                runInTracingChannelSpan: telemetryDispatcher.runInTracingChannelSpan,
+                runInTracingChannelSpan: runInTracingChannelSpanInStreamText,
                 onPreliminaryToolResult: (result2) => {
                   toolExecutionStepStreamController == null ? void 0 : toolExecutionStepStreamController.enqueue(result2);
                 }
@@ -10888,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")
   )
@@ -16086,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();
+    }
   };
 }