ai 4.0.19 → 4.0.21

package/dist/index.mjs

@@ -32,15 +32,19 @@ function createDataStream({
       controller = controllerArg;
     }
   });
+  function safeEnqueue(data) {
+    try {
+      controller.enqueue(data);
+    } catch (error) {
+    }
+  }
   try {
     const result = execute({
       writeData(data) {
-        controller.enqueue(formatDataStreamPart("data", [data]));
+        safeEnqueue(formatDataStreamPart("data", [data]));
       },
       writeMessageAnnotation(annotation) {
-        controller.enqueue(
-          formatDataStreamPart("message_annotations", [annotation])
-        );
+        safeEnqueue(formatDataStreamPart("message_annotations", [annotation]));
       },
       merge(streamArg) {
         ongoingStreamPromises.push(
@@ -50,10 +54,10 @@ function createDataStream({
               const { done, value } = await reader.read();
               if (done)
                 break;
-              controller.enqueue(value);
+              safeEnqueue(value);
             }
           })().catch((error) => {
-            controller.enqueue(formatDataStreamPart("error", onError(error)));
+            safeEnqueue(formatDataStreamPart("error", onError(error)));
           })
         );
       },
@@ -62,12 +66,12 @@ function createDataStream({
     if (result) {
       ongoingStreamPromises.push(
         result.catch((error) => {
-          controller.enqueue(formatDataStreamPart("error", onError(error)));
+          safeEnqueue(formatDataStreamPart("error", onError(error)));
         })
       );
     }
   } catch (error) {
-    controller.enqueue(formatDataStreamPart("error", onError(error)));
+    safeEnqueue(formatDataStreamPart("error", onError(error)));
   }
   const waitForStreams = new Promise(async (resolve) => {
     while (ongoingStreamPromises.length > 0) {
@@ -76,7 +80,10 @@ function createDataStream({
     resolve();
   });
   waitForStreams.finally(() => {
-    controller.close();
+    try {
+      controller.close();
+    } catch (error) {
+    }
   });
   return stream;
 }
@@ -1162,6 +1169,7 @@ async function downloadAssets(messages, downloadImplementation, modelSupportsIma
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
+  var _a13;
   if (part.type === "text") {
     return {
       type: "text",
@@ -1212,9 +1220,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",
@@ -1222,7 +1230,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`);
       }
@@ -1232,6 +1241,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
         mimeType,
         providerMetadata: part.experimental_providerMetadata
       };
+    }
   }
 }
 
@@ -1783,12 +1793,10 @@ import { safeValidateTypes as safeValidateTypes2 } from "@ai-sdk/provider-utils"
 import { asSchema } from "@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();
@@ -1796,7 +1804,7 @@ function createAsyncIterableStream(source, transformer) {
       }
     };
   };
-  return transformedStream;
+  return stream;
 }
 
 // core/generate-object/output-strategy.ts
@@ -1926,29 +1934,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}`);
             }
-          }
-        }
-      });
+          })
+        )
+      );
     }
   };
 };
@@ -3147,25 +3161,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(
@@ -3173,32 +3191,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({
@@ -3883,6 +3901,7 @@ async function executeTools({
         }
       });
       return {
+        type: "tool-result",
         toolCallId,
         toolName,
         args,
@@ -4127,25 +4146,6 @@ function runToolsTransformation({
           break;
         }
         case "tool-call": {
-          const toolName = chunk.toolName;
-          if (tools == null) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error: new NoSuchToolError({ toolName: chunk.toolName })
-            });
-            break;
-          }
-          const tool2 = tools[toolName];
-          if (tool2 == null) {
-            toolResultsStreamController.enqueue({
-              type: "error",
-              error: new NoSuchToolError({
-                toolName: chunk.toolName,
-                availableTools: Object.keys(tools)
-              })
-            });
-            break;
-          }
           try {
             const toolCall = await parseToolCall({
               toolCall: chunk,
@@ -4155,6 +4155,7 @@ function runToolsTransformation({
               messages
             });
             controller.enqueue(toolCall);
+            const tool2 = tools[toolCall.toolName];
             if (tool2.execute != null) {
               const toolExecutionId = generateId();
               outstandingToolResults.add(toolExecutionId);
@@ -4978,22 +4979,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.",