@ai-sdk/gateway 3.0.52 → 3.0.54

package/src/gateway-video-model.ts

@@ -6,11 +6,12 @@ import type {
   SharedV3ProviderMetadata,
   SharedV3Warning,
 } from '@ai-sdk/provider';
+import { APICallError } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertUint8ArrayToBase64,
-  createJsonResponseHandler,
   createJsonErrorResponseHandler,
+  parseJsonEventStream,
   postJsonToApi,
   resolve,
   type Resolvable,
@@ -61,17 +62,14 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
   }> {
     const resolvedHeaders = await resolve(this.config.headers());
     try {
-      const {
-        responseHeaders,
-        value: responseBody,
-        rawValue,
-      } = await postJsonToApi({
+      const { responseHeaders, value: responseBody } = await postJsonToApi({
         url: this.getUrl(),
         headers: combineHeaders(
           resolvedHeaders,
           headers ?? {},
           this.getModelConfigHeaders(),
           await resolve(this.config.o11yHeaders),
+          { accept: 'text/event-stream' },
         ),
         body: {
           prompt,
@@ -84,9 +82,82 @@ export class GatewayVideoModel implements Experimental_VideoModelV3 {
           ...(providerOptions && { providerOptions }),
           ...(image && { image: maybeEncodeVideoFile(image) }),
         },
-        successfulResponseHandler: createJsonResponseHandler(
-          gatewayVideoResponseSchema,
-        ),
+        successfulResponseHandler: async ({
+          response,
+          url,
+          requestBodyValues,
+        }: {
+          url: string;
+          requestBodyValues: unknown;
+          response: Response;
+        }) => {
+          if (response.body == null) {
+            throw new APICallError({
+              message: 'SSE response body is empty',
+              url,
+              requestBodyValues,
+              statusCode: response.status,
+            });
+          }
+
+          const eventStream = parseJsonEventStream({
+            stream: response.body,
+            schema: gatewayVideoEventSchema,
+          });
+
+          const reader = eventStream.getReader();
+          const { done, value: parseResult } = await reader.read();
+          reader.releaseLock();
+
+          if (done || !parseResult) {
+            throw new APICallError({
+              message: 'SSE stream ended without a data event',
+              url,
+              requestBodyValues,
+              statusCode: response.status,
+            });
+          }
+
+          if (!parseResult.success) {
+            throw new APICallError({
+              message: 'Failed to parse video SSE event',
+              cause: parseResult.error,
+              url,
+              requestBodyValues,
+              statusCode: response.status,
+            });
+          }
+
+          const event = parseResult.value;
+
+          if (event.type === 'error') {
+            throw new APICallError({
+              message: event.message,
+              statusCode: event.statusCode,
+              url,
+              requestBodyValues,
+              responseHeaders: Object.fromEntries([...response.headers]),
+              responseBody: JSON.stringify(event),
+              data: {
+                error: {
+                  message: event.message,
+                  type: event.errorType,
+                  param: event.param,
+                },
+              },
+            });
+          }
+
+          // event.type === 'result'
+          return {
+            value: {
+              videos: event.videos,
+              warnings: event.warnings,
+              providerMetadata: event.providerMetadata,
+            },
+            responseHeaders: Object.fromEntries([...response.headers]),
+          };
+        },
         failedResponseHandler: createJsonErrorResponseHandler({
           errorSchema: z.any(),
           errorToMessage: data => data,
@@ -169,10 +240,20 @@ const gatewayVideoWarningSchema = z.discriminatedUnion('type', [
   }),
 ]);
 
-const gatewayVideoResponseSchema = z.object({
-  videos: z.array(gatewayVideoDataSchema),
-  warnings: z.array(gatewayVideoWarningSchema).optional(),
-  providerMetadata: z
-    .record(z.string(), providerMetadataEntrySchema)
-    .optional(),
-});
+const gatewayVideoEventSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('result'),
+    videos: z.array(gatewayVideoDataSchema),
+    warnings: z.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z
+      .record(z.string(), providerMetadataEntrySchema)
+      .optional(),
+  }),
+  z.object({
+    type: z.literal('error'),
+    message: z.string(),
+    errorType: z.string(),
+    statusCode: z.number(),
+    param: z.unknown().nullable(),
+  }),
+]);