ai 4.0.20 → 4.0.21

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # ai
 
+## 4.0.21
+
+### Patch Changes
+
+- a8669a2: fix (ai/core): prefer auto-detected image mimetype
+- 6fb3e91: fix (ai/core): include type in generateText toolResults result property.
+
 ## 4.0.20
 
 ### Patch Changes

package/dist/index.js

@@ -1229,6 +1229,7 @@ async function downloadAssets(messages, downloadImplementation, modelSupportsIma
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
+  var _a13;
   if (part.type === "text") {
     return {
       type: "text",
@@ -1279,9 +1280,9 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
     normalizedData = convertDataContentToUint8Array(content);
   }
   switch (type) {
-    case "image":
-      if (mimeType == null && normalizedData instanceof Uint8Array) {
-        mimeType = detectImageMimeType(normalizedData);
+    case "image": {
+      if (normalizedData instanceof Uint8Array) {
+        mimeType = (_a13 = detectImageMimeType(normalizedData)) != null ? _a13 : mimeType;
       }
       return {
         type: "image",
@@ -1289,7 +1290,8 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
         mimeType,
         providerMetadata: part.experimental_providerMetadata
       };
-    case "file":
+    }
+    case "file": {
       if (mimeType == null) {
         throw new Error(`Mime type is missing for file part`);
       }
@@ -1299,6 +1301,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
         mimeType,
         providerMetadata: part.experimental_providerMetadata
       };
+    }
   }
 }
 
@@ -1845,12 +1848,10 @@ var import_provider_utils5 = require("@ai-sdk/provider-utils");
 var import_ui_utils2 = require("@ai-sdk/ui-utils");
 
 // core/util/async-iterable-stream.ts
-function createAsyncIterableStream(source, transformer) {
-  const transformedStream = source.pipeThrough(
-    new TransformStream(transformer)
-  );
-  transformedStream[Symbol.asyncIterator] = () => {
-    const reader = transformedStream.getReader();
+function createAsyncIterableStream(source) {
+  const stream = source.pipeThrough(new TransformStream());
+  stream[Symbol.asyncIterator] = () => {
+    const reader = stream.getReader();
     return {
       async next() {
         const { done, value } = await reader.read();
@@ -1858,7 +1859,7 @@ function createAsyncIterableStream(source, transformer) {
       }
     };
   };
-  return transformedStream;
+  return stream;
 }
 
 // core/generate-object/output-strategy.ts
@@ -1988,29 +1989,35 @@ var arrayOutputStrategy = (schema) => {
     },
     createElementStream(originalStream) {
       let publishedElements = 0;
-      return createAsyncIterableStream(originalStream, {
-        transform(chunk, controller) {
-          switch (chunk.type) {
-            case "object": {
-              const array = chunk.object;
-              for (; publishedElements < array.length; publishedElements++) {
-                controller.enqueue(array[publishedElements]);
+      return createAsyncIterableStream(
+        originalStream.pipeThrough(
+          new TransformStream({
+            transform(chunk, controller) {
+              switch (chunk.type) {
+                case "object": {
+                  const array = chunk.object;
+                  for (; publishedElements < array.length; publishedElements++) {
+                    controller.enqueue(array[publishedElements]);
+                  }
+                  break;
+                }
+                case "text-delta":
+                case "finish":
+                  break;
+                case "error":
+                  controller.error(chunk.error);
+                  break;
+                default: {
+                  const _exhaustiveCheck = chunk;
+                  throw new Error(
+                    `Unsupported chunk type: ${_exhaustiveCheck}`
+                  );
+                }
               }
-              break;
             }
-            case "text-delta":
-            case "finish":
-              break;
-            case "error":
-              controller.error(chunk.error);
-              break;
-            default: {
-              const _exhaustiveCheck = chunk;
-              throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
-            }
-          }
-        }
-      });
+          })
+        )
+      );
     }
   };
 };
@@ -3206,25 +3213,29 @@ var DefaultStreamObjectResult = class {
     return this.responsePromise.value;
   }
   get partialObjectStream() {
-    return createAsyncIterableStream(this.stitchableStream.stream, {
-      transform(chunk, controller) {
-        switch (chunk.type) {
-          case "object":
-            controller.enqueue(chunk.object);
-            break;
-          case "text-delta":
-          case "finish":
-            break;
-          case "error":
-            controller.error(chunk.error);
-            break;
-          default: {
-            const _exhaustiveCheck = chunk;
-            throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+    return createAsyncIterableStream(
+      this.stitchableStream.stream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "object":
+                controller.enqueue(chunk.object);
+                break;
+              case "text-delta":
+              case "finish":
+                break;
+              case "error":
+                controller.error(chunk.error);
+                break;
+              default: {
+                const _exhaustiveCheck = chunk;
+                throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+              }
+            }
           }
-        }
-      }
-    });
+        })
+      )
+    );
   }
   get elementStream() {
     return this.outputStrategy.createElementStream(
@@ -3232,32 +3243,32 @@ var DefaultStreamObjectResult = class {
     );
   }
   get textStream() {
-    return createAsyncIterableStream(this.stitchableStream.stream, {
-      transform(chunk, controller) {
-        switch (chunk.type) {
-          case "text-delta":
-            controller.enqueue(chunk.textDelta);
-            break;
-          case "object":
-          case "finish":
-            break;
-          case "error":
-            controller.error(chunk.error);
-            break;
-          default: {
-            const _exhaustiveCheck = chunk;
-            throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+    return createAsyncIterableStream(
+      this.stitchableStream.stream.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            switch (chunk.type) {
+              case "text-delta":
+                controller.enqueue(chunk.textDelta);
+                break;
+              case "object":
+              case "finish":
+                break;
+              case "error":
+                controller.error(chunk.error);
+                break;
+              default: {
+                const _exhaustiveCheck = chunk;
+                throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
+              }
+            }
           }
-        }
-      }
-    });
+        })
+      )
+    );
   }
   get fullStream() {
-    return createAsyncIterableStream(this.stitchableStream.stream, {
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      }
-    });
+    return createAsyncIterableStream(this.stitchableStream.stream);
   }
   pipeTextStreamToResponse(response, init) {
     writeToServerResponse({
@@ -3930,6 +3941,7 @@ async function executeTools({
         }
       });
       return {
+        type: "tool-result",
         toolCallId,
         toolName,
         args,
@@ -5007,22 +5019,22 @@ var DefaultStreamTextResult = class {
     return stream1;
   }
   get textStream() {
-    return createAsyncIterableStream(this.teeStream(), {
-      transform(chunk, controller) {
-        if (chunk.type === "text-delta") {
-          controller.enqueue(chunk.textDelta);
-        } else if (chunk.type === "error") {
-          controller.error(chunk.error);
-        }
-      }
-    });
+    return createAsyncIterableStream(
+      this.teeStream().pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            if (chunk.type === "text-delta") {
+              controller.enqueue(chunk.textDelta);
+            } else if (chunk.type === "error") {
+              controller.error(chunk.error);
+            }
+          }
+        })
+      )
+    );
   }
   get fullStream() {
-    return createAsyncIterableStream(this.teeStream(), {
-      transform(chunk, controller) {
-        controller.enqueue(chunk);
-      }
-    });
+    return createAsyncIterableStream(this.teeStream());
   }
   toDataStreamInternal({
     getErrorMessage: getErrorMessage5 = () => "An error occurred.",