@ai-sdk/amazon-bedrock 3.0.73 → 3.0.74

package/dist/index.mjs

@@ -8,7 +8,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.73" : "0.0.0-test";
+var VERSION = true ? "3.0.74" : "0.0.0-test";
 
 // src/bedrock-provider.ts
 import { anthropicTools as anthropicTools2 } from "@ai-sdk/anthropic/internal";
@@ -104,70 +104,84 @@ import {
   extractResponseHeaders,
   safeValidateTypes
 } from "@ai-sdk/provider-utils";
+
+// src/bedrock-event-stream-decoder.ts
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { toUtf8, fromUtf8 } from "@smithy/util-utf8";
+function createBedrockEventStreamDecoder(body, processEvent) {
+  const codec = new EventStreamCodec(toUtf8, fromUtf8);
+  let buffer = new Uint8Array(0);
+  const textDecoder = new TextDecoder();
+  return body.pipeThrough(
+    new TransformStream({
+      async transform(chunk, controller) {
+        var _a, _b;
+        const newBuffer = new Uint8Array(buffer.length + chunk.length);
+        newBuffer.set(buffer);
+        newBuffer.set(chunk, buffer.length);
+        buffer = newBuffer;
+        while (buffer.length >= 4) {
+          const totalLength = new DataView(
+            buffer.buffer,
+            buffer.byteOffset,
+            buffer.byteLength
+          ).getUint32(0, false);
+          if (buffer.length < totalLength) {
+            break;
+          }
+          try {
+            const subView = buffer.subarray(0, totalLength);
+            const decoded = codec.decode(subView);
+            buffer = buffer.slice(totalLength);
+            const messageType = (_a = decoded.headers[":message-type"]) == null ? void 0 : _a.value;
+            const eventType = (_b = decoded.headers[":event-type"]) == null ? void 0 : _b.value;
+            const data = textDecoder.decode(decoded.body);
+            await processEvent({ messageType, eventType, data }, controller);
+          } catch (e) {
+            break;
+          }
+        }
+      }
+    })
+  );
+}
+
+// src/bedrock-event-stream-response-handler.ts
 var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
   const responseHeaders = extractResponseHeaders(response);
   if (response.body == null) {
     throw new EmptyResponseBodyError({});
   }
-  const codec = new EventStreamCodec(toUtf8, fromUtf8);
-  let buffer = new Uint8Array(0);
-  const textDecoder = new TextDecoder();
   return {
     responseHeaders,
-    value: response.body.pipeThrough(
-      new TransformStream({
-        async transform(chunk, controller) {
-          var _a, _b;
-          const newBuffer = new Uint8Array(buffer.length + chunk.length);
-          newBuffer.set(buffer);
-          newBuffer.set(chunk, buffer.length);
-          buffer = newBuffer;
-          while (buffer.length >= 4) {
-            const totalLength = new DataView(
-              buffer.buffer,
-              buffer.byteOffset,
-              buffer.byteLength
-            ).getUint32(0, false);
-            if (buffer.length < totalLength) {
-              break;
-            }
-            try {
-              const subView = buffer.subarray(0, totalLength);
-              const decoded = codec.decode(subView);
-              buffer = buffer.slice(totalLength);
-              if (((_a = decoded.headers[":message-type"]) == null ? void 0 : _a.value) === "event") {
-                const data = textDecoder.decode(decoded.body);
-                const parsedDataResult = await safeParseJSON({ text: data });
-                if (!parsedDataResult.success) {
-                  controller.enqueue(parsedDataResult);
-                  break;
-                }
-                delete parsedDataResult.value.p;
-                let wrappedData = {
-                  [(_b = decoded.headers[":event-type"]) == null ? void 0 : _b.value]: parsedDataResult.value
-                };
-                const validatedWrappedData = await safeValidateTypes({
-                  value: wrappedData,
-                  schema: chunkSchema
-                });
-                if (!validatedWrappedData.success) {
-                  controller.enqueue(validatedWrappedData);
-                } else {
-                  controller.enqueue({
-                    success: true,
-                    value: validatedWrappedData.value,
-                    rawValue: wrappedData
-                  });
-                }
-              }
-            } catch (e) {
-              break;
-            }
+    value: createBedrockEventStreamDecoder(
+      response.body,
+      async (event, controller) => {
+        if (event.messageType === "event") {
+          const parsedDataResult = await safeParseJSON({ text: event.data });
+          if (!parsedDataResult.success) {
+            controller.enqueue(parsedDataResult);
+            return;
+          }
+          delete parsedDataResult.value.p;
+          const wrappedData = {
+            [event.eventType]: parsedDataResult.value
+          };
+          const validatedWrappedData = await safeValidateTypes({
+            value: wrappedData,
+            schema: chunkSchema
+          });
+          if (!validatedWrappedData.success) {
+            controller.enqueue(validatedWrappedData);
+          } else {
+            controller.enqueue({
+              success: true,
+              value: validatedWrappedData.value,
+              rawValue: wrappedData
+            });
           }
         }
-      })
+      }
     )
   };
 };