ai 6.0.199 → 6.0.201

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # ai
 
+## 6.0.201
+
+### Patch Changes
+
+- 0c8c0ed: fix(ai): return schema-transformed elements in array output mode
+
+  Previously final array output validation checked each element against the schema but returned the raw model output. Array output now returns the validated values so Zod transforms, coercions, defaults, and pipes are applied consistently with object output.
+
+## 6.0.200
+
+### Patch Changes
+
+- 14098e7: fix(ai): reject `streamText` result promises with `NoOutputGeneratedError` when the model stream ends without producing any output. Previously such streams resolved with an empty step. Incomplete streams with partial output still resolve with the partial result.
+- 2cabe9c: Harden UI message stream processing against prototype pollution from chunk IDs.
+
 ## 6.0.199
 
 ### Patch Changes

package/dist/index.js

@@ -1254,7 +1254,7 @@ function detectMediaType({
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.199" : "0.0.0-test";
+var VERSION = true ? "6.0.201" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -5405,6 +5405,11 @@ function isDataUIMessageChunk(chunk) {
   return chunk.type.startsWith("data-");
 }
 
+// src/util/create-id-map.ts
+function createIdMap() {
+  return /* @__PURE__ */ Object.create(null);
+}
+
 // src/ui/ui-messages.ts
 function isDataUIPart(part) {
   return part.type.startsWith("data-");
@@ -5448,9 +5453,9 @@ function createStreamingUIMessageState({
       role: "assistant",
       parts: []
     },
-    activeTextParts: {},
-    activeReasoningParts: {},
-    partialToolCalls: {}
+    activeTextParts: createIdMap(),
+    activeReasoningParts: createIdMap(),
+    partialToolCalls: createIdMap()
   };
 }
 function processUIMessageStream({
@@ -5924,8 +5929,8 @@ function processUIMessageStream({
               break;
             }
             case "finish-step": {
-              state.activeTextParts = {};
-              state.activeReasoningParts = {};
+              state.activeTextParts = createIdMap();
+              state.activeReasoningParts = createIdMap();
               break;
             }
             case "start": {
@@ -6564,6 +6569,28 @@ var originalGenerateId2 = (0, import_provider_utils18.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
+var isOutputChunkType = {
+  file: true,
+  source: true,
+  "text-start": true,
+  "text-end": true,
+  "text-delta": true,
+  "reasoning-start": true,
+  "reasoning-end": true,
+  "reasoning-delta": true,
+  "tool-input-start": true,
+  "tool-input-end": true,
+  "tool-input-delta": true,
+  "tool-approval-request": true,
+  "tool-call": true,
+  "tool-result": true,
+  "tool-error": true,
+  "stream-start": false,
+  "response-metadata": false,
+  finish: false,
+  error: false,
+  raw: false
+};
 function streamText({
   model,
   tools,
@@ -6782,6 +6809,7 @@ var DefaultStreamTextResult = class {
     let recordedRequest = {};
     let recordedWarnings = [];
     const recordedSteps = [];
+    let recordedNoOutputError;
     const pendingDeferredToolCalls = /* @__PURE__ */ new Map();
     let rootSpan;
     let activeTextContent = {};
@@ -6795,7 +6823,11 @@ var DefaultStreamTextResult = class {
           await (onChunk == null ? void 0 : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
-          await onError({ error: wrapGatewayError(part.error) });
+          const error = wrapGatewayError(part.error);
+          if (NoOutputGeneratedError.isInstance(error)) {
+            recordedNoOutputError = error;
+          }
+          await onError({ error });
         }
         if (part.type === "text-start") {
           activeTextContent[part.id] = {
@@ -6946,8 +6978,8 @@ var DefaultStreamTextResult = class {
       async flush(controller) {
         var _a21, _b, _c, _d, _e, _f, _g;
         try {
-          if (recordedSteps.length === 0) {
-            const error = (abortSignal == null ? void 0 : abortSignal.aborted) ? abortSignal.reason : new NoOutputGeneratedError({
+          if (recordedSteps.length === 0 || recordedNoOutputError != null) {
+            const error = (abortSignal == null ? void 0 : abortSignal.aborted) ? abortSignal.reason : recordedNoOutputError != null ? recordedNoOutputError : new NoOutputGeneratedError({
               message: "No output generated. Check the stream for errors."
             });
             self._finishReason.reject(error);
@@ -7446,6 +7478,8 @@ var DefaultStreamTextResult = class {
             const activeToolCallToolNames = {};
             let stepFinishReason = "other";
             let stepRawFinishReason = void 0;
+            let hasReceivedTerminalChunk = false;
+            let hasReceivedOutputChunk = false;
             let stepUsage = createNullLanguageModelUsage();
             let stepProviderMetadata;
             let stepFirstChunk = true;
@@ -7481,6 +7515,9 @@ var DefaultStreamTextResult = class {
                       });
                     }
                     const chunkType = chunk.type;
+                    if (isOutputChunkType[chunkType]) {
+                      hasReceivedOutputChunk = true;
+                    }
                     switch (chunkType) {
                       case "tool-approval-request":
                       case "text-start":
@@ -7540,6 +7577,7 @@ var DefaultStreamTextResult = class {
                         break;
                       }
                       case "finish": {
+                        hasReceivedTerminalChunk = true;
                         stepUsage = chunk.usage;
                         stepFinishReason = chunk.finishReason;
                         stepRawFinishReason = chunk.rawFinishReason;
@@ -7599,6 +7637,7 @@ var DefaultStreamTextResult = class {
                         break;
                       }
                       case "error": {
+                        hasReceivedTerminalChunk = true;
                         controller.enqueue(chunk);
                         stepFinishReason = "error";
                         break;
@@ -7620,6 +7659,19 @@ var DefaultStreamTextResult = class {
                   // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
                   async flush(controller) {
                     var _a22, _b2, _c2, _d2, _e2, _f2, _g2;
+                    if (!hasReceivedTerminalChunk && !hasReceivedOutputChunk) {
+                      controller.enqueue({
+                        type: "error",
+                        error: new NoOutputGeneratedError({
+                          message: "No output generated. The model stream ended without a finish chunk."
+                        })
+                      });
+                      doStreamSpan.end();
+                      clearStepTimeout();
+                      clearChunkTimeout();
+                      self.closeStream();
+                      return;
+                    }
                     const stepToolCallsJson = stepToolCalls.length > 0 ? JSON.stringify(stepToolCalls) : void 0;
                     try {
                       doStreamSpan.setAttributes(
@@ -7897,14 +7949,29 @@ var DefaultStreamTextResult = class {
       )
     );
   }
+  rejectResultPromises(error) {
+    if (this._finishReason.isPending())
+      this._finishReason.reject(error);
+    if (this._rawFinishReason.isPending())
+      this._rawFinishReason.reject(error);
+    if (this._totalUsage.isPending())
+      this._totalUsage.reject(error);
+    if (this._steps.isPending())
+      this._steps.reject(error);
+  }
   async consumeStream(options) {
     var _a21;
     try {
       await consumeStream({
         stream: this.fullStream,
-        onError: options == null ? void 0 : options.onError
+        onError: (error) => {
+          var _a22;
+          this.rejectResultPromises(error);
+          (_a22 = options == null ? void 0 : options.onError) == null ? void 0 : _a22.call(options, error);
+        }
       });
     } catch (error) {
+      this.rejectResultPromises(error);
       (_a21 = options == null ? void 0 : options.onError) == null ? void 0 : _a21.call(options, error);
     }
   }
@@ -9960,13 +10027,15 @@ var arrayOutputStrategy = (schema) => {
         };
       }
       const inputArray = value.elements;
+      const resultArray = [];
       for (const element of inputArray) {
         const result = await (0, import_provider_utils26.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
+        resultArray.push(result.value);
       }
-      return { success: true, value: inputArray };
+      return { success: true, value: resultArray };
     },
     createElementStream(originalStream) {
       let publishedElements = 0;