@ai-sdk/xai 4.0.25 → 4.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/xai",
-  "version": "4.0.25",
+  "version": "4.0.27",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -29,9 +29,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/openai-compatible": "3.0.20",
-    "@ai-sdk/provider": "4.0.4",
-    "@ai-sdk/provider-utils": "5.0.18"
+    "@ai-sdk/openai-compatible": "3.0.22",
+    "@ai-sdk/provider": "4.0.5",
+    "@ai-sdk/provider-utils": "5.0.20"
   },
   "devDependencies": {
     "@types/node": "22.19.19",

package/src/xai-video-model.ts

@@ -2,14 +2,16 @@ import {
   AISDKError,
   APICallError,
   type Experimental_VideoModelV4,
+  type Experimental_VideoModelV4CallOptions as VideoModelV4CallOptions,
   type Experimental_VideoModelV4File,
+  type Experimental_VideoModelV4OperationStartResult as VideoModelV4OperationStartResult,
+  type Experimental_VideoModelV4OperationStatusResult as VideoModelV4OperationStatusResult,
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
   convertUint8ArrayToBase64,
   createJsonResponseHandler,
-  delay,
   extractResponseHeaders,
   getFromApi,
   getTopLevelMediaType,
@@ -27,6 +29,8 @@ import {
 } from './xai-video-model-options';
 import type { XaiVideoModelId } from './xai-video-settings';
 
+type VideoModelV4 = Experimental_VideoModelV4;
+
 interface XaiVideoModelConfig {
   provider: string;
   baseURL: string | undefined;
@@ -43,26 +47,24 @@ const RESOLUTION_MAP: Record<string, string> = {
   '640x480': '480p',
 };
 
-type XaiVideoDoGenerateOptions = Parameters<
-  Experimental_VideoModelV4['doGenerate']
->[0];
+type XaiVideoCallOptions = VideoModelV4CallOptions;
 
 function getFirstFrameImage(
-  options: XaiVideoDoGenerateOptions,
+  options: XaiVideoCallOptions,
 ): Experimental_VideoModelV4File | undefined {
   return options.frameImages?.find(frame => frame.frameType === 'first_frame')
     ?.image;
 }
 
 function getLastFrameImage(
-  options: XaiVideoDoGenerateOptions,
+  options: XaiVideoCallOptions,
 ): Experimental_VideoModelV4File | undefined {
   return options.frameImages?.find(frame => frame.frameType === 'last_frame')
     ?.image;
 }
 
 function resolveStartImage(
-  options: XaiVideoDoGenerateOptions,
+  options: XaiVideoCallOptions,
 ): Experimental_VideoModelV4File | undefined {
   return getFirstFrameImage(options) ?? options.image;
 }
@@ -87,7 +89,7 @@ function fileToXaiImageUrl(file: Experimental_VideoModelV4File): string {
 // Video references are not supported for reference-to-video and are skipped
 // with a warning.
 function resolveReferenceImages(
-  options: XaiVideoDoGenerateOptions,
+  options: XaiVideoCallOptions,
   xaiOptions: XaiParsedVideoModelOptions | undefined,
   warnings: SharedV4Warning[],
 ): Array<{ url: string }> | undefined {
@@ -123,7 +125,7 @@ function resolveReferenceImages(
 }
 
 function resolveVideoMode(
-  options: XaiVideoDoGenerateOptions,
+  options: XaiVideoCallOptions,
   xaiOptions: XaiParsedVideoModelOptions | undefined,
 ): XaiParsedVideoModelOptions['mode'] | undefined {
   if (xaiOptions?.mode != null) {
@@ -164,10 +166,15 @@ export class XaiVideoModel implements Experimental_VideoModelV4 {
     private config: XaiVideoModelConfig,
   ) {}
 
-  async doGenerate(
-    options: Parameters<Experimental_VideoModelV4['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<Experimental_VideoModelV4['doGenerate']>>> {
-    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+  private async buildRequestBody(options: VideoModelV4CallOptions): Promise<{
+    body: Record<string, unknown>;
+    warnings: SharedV4Warning[];
+    xaiOptions: XaiParsedVideoModelOptions | undefined;
+    isEdit: boolean;
+    isExtension: boolean;
+    hasReferenceImages: boolean;
+    effectiveMode: XaiParsedVideoModelOptions['mode'] | undefined;
+  }> {
     const warnings: SharedV4Warning[] = [];
 
     const xaiOptions = (await parseProviderOptions({
@@ -385,6 +392,24 @@ export class XaiVideoModel implements Experimental_VideoModelV4 {
       }
     }
 
+    return {
+      body,
+      warnings,
+      xaiOptions,
+      isEdit,
+      isExtension,
+      hasReferenceImages,
+      effectiveMode,
+    };
+  }
+
+  async doStart(
+    options: Parameters<NonNullable<VideoModelV4['doStart']>>[0],
+  ): Promise<VideoModelV4OperationStartResult> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { body, warnings, isEdit, isExtension } =
+      await this.buildRequestBody(options);
+
     const baseURL = this.config.baseURL ?? 'https://api.x.ai/v1';
 
     // Determine endpoint based on mode
@@ -397,8 +422,7 @@ export class XaiVideoModel implements Experimental_VideoModelV4 {
       endpoint = `${baseURL}/videos/generations`;
     }
 
-    // Step 1: Create video generation/edit/extension request
-    const { value: createResponse } = await postJsonToApi({
+    const { value: createResponse, responseHeaders } = await postJsonToApi({
       url: endpoint,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
@@ -414,107 +438,129 @@ export class XaiVideoModel implements Experimental_VideoModelV4 {
     if (!requestId) {
       throw new AISDKError({
         name: 'XAI_VIDEO_GENERATION_ERROR',
-        message: `No request_id returned from xAI API. Response: ${JSON.stringify(createResponse)}`,
+        message: `No request_id returned from xAI API.`,
       });
     }
 
-    // Step 2: Poll for completion
-    const pollIntervalMs = xaiOptions?.pollIntervalMs ?? 5000;
-    const pollTimeoutMs = xaiOptions?.pollTimeoutMs ?? 600000;
-    const startTime = Date.now();
-    let responseHeaders: Record<string, string> | undefined;
-
-    while (true) {
-      await delay(pollIntervalMs, { abortSignal: options.abortSignal });
-
-      if (Date.now() - startTime > pollTimeoutMs) {
-        throw new AISDKError({
-          name: 'XAI_VIDEO_GENERATION_TIMEOUT',
-          message: `Video generation timed out after ${pollTimeoutMs}ms`,
-        });
-      }
+    return {
+      operation: { requestId },
+      warnings,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
+  }
 
-      const { value: statusResponse, responseHeaders: pollHeaders } =
-        await getFromApi({
-          url: `${baseURL}/videos/${requestId}`,
-          validateUrl: false,
-          headers: combineHeaders(this.config.headers(), options.headers),
-          successfulResponseHandler: xaiVideoStatusResponseHandler,
-          failedResponseHandler: xaiFailedResponseHandler,
-          abortSignal: options.abortSignal,
-          fetch: this.config.fetch,
-        });
+  async doStatus(
+    options: Parameters<NonNullable<VideoModelV4['doStatus']>>[0],
+  ): Promise<VideoModelV4OperationStatusResult> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { requestId } = options.operation as { requestId: string };
+    const baseURL = this.config.baseURL ?? 'https://api.x.ai/v1';
 
-      responseHeaders = pollHeaders;
-
-      if (
-        statusResponse.status === 'done' ||
-        (statusResponse.status == null && statusResponse.video?.url)
-      ) {
-        if (statusResponse.video?.respect_moderation === false) {
-          throw new AISDKError({
-            name: 'XAI_VIDEO_MODERATION_ERROR',
-            message:
-              'Video generation was blocked due to a content policy violation.',
-          });
-        }
+    const { value: statusResponse, responseHeaders } = await getFromApi({
+      url: `${baseURL}/videos/${requestId}`,
+      validateUrl: false,
+      headers: combineHeaders(this.config.headers(), options.headers),
+      successfulResponseHandler: xaiVideoStatusResponseHandler,
+      failedResponseHandler: xaiFailedResponseHandler,
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
 
-        if (!statusResponse.video?.url) {
-          throw new AISDKError({
-            name: 'XAI_VIDEO_GENERATION_ERROR',
-            message:
-              'Video generation completed but no video URL was returned.',
-          });
-        }
+    if (statusResponse.status === 'expired') {
+      return {
+        status: 'error' as const,
+        error: 'Video generation request expired.',
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+      };
+    }
 
-        return {
-          videos: [
-            {
-              type: 'url' as const,
-              url: statusResponse.video.url,
-              mediaType: 'video/mp4',
-            },
-          ],
-          warnings,
-          response: {
-            timestamp: currentDate,
-            modelId: this.modelId,
-            headers: responseHeaders,
-          },
-          providerMetadata: {
-            xai: {
-              requestId,
-              videoUrl: statusResponse.video.url,
-              ...(statusResponse.video.duration != null
-                ? { duration: statusResponse.video.duration }
-                : {}),
-              ...(statusResponse.usage?.cost_in_usd_ticks != null
-                ? { costInUsdTicks: statusResponse.usage.cost_in_usd_ticks }
-                : {}),
-              ...(statusResponse.progress != null
-                ? { progress: statusResponse.progress }
-                : {}),
-            },
-          },
-        };
-      }
+    if (statusResponse.status === 'failed') {
+      const errorDetails =
+        statusResponse.error?.message ?? statusResponse.error?.code;
+
+      return {
+        status: 'error' as const,
+        error:
+          errorDetails != null
+            ? `Video generation failed: ${errorDetails}`
+            : 'Video generation failed.',
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+      };
+    }
 
-      if (statusResponse.status === 'expired') {
+    if (
+      statusResponse.status === 'done' ||
+      (statusResponse.status == null && statusResponse.video?.url)
+    ) {
+      if (statusResponse.video?.respect_moderation === false) {
         throw new AISDKError({
-          name: 'XAI_VIDEO_GENERATION_EXPIRED',
-          message: 'Video generation request expired.',
+          name: 'XAI_VIDEO_MODERATION_ERROR',
+          message:
+            'Video generation was blocked due to a content policy violation.',
         });
       }
 
-      if (statusResponse.status === 'failed') {
+      if (!statusResponse.video?.url) {
         throw new AISDKError({
-          name: 'XAI_VIDEO_GENERATION_FAILED',
-          message: 'Video generation failed.',
+          name: 'XAI_VIDEO_GENERATION_ERROR',
+          message: 'Video generation completed but no video URL was returned.',
         });
       }
 
-      // 'pending' → continue polling
+      return {
+        status: 'completed',
+        videos: [
+          {
+            type: 'url',
+            url: statusResponse.video.url,
+            mediaType: 'video/mp4',
+          },
+        ],
+        warnings: [],
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+        providerMetadata: {
+          xai: {
+            requestId,
+            videoUrl: statusResponse.video.url,
+            ...(statusResponse.video.duration != null
+              ? { duration: statusResponse.video.duration }
+              : {}),
+            ...(statusResponse.usage?.cost_in_usd_ticks != null
+              ? { costInUsdTicks: statusResponse.usage.cost_in_usd_ticks }
+              : {}),
+            ...(statusResponse.progress != null
+              ? { progress: statusResponse.progress }
+              : {}),
+          },
+        },
+      };
     }
+
+    // pending status
+    return {
+      status: 'pending',
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+    };
   }
 }