@tanstack/ai-grok 0.14.11 → 0.16.0

package/src/adapters/video.ts

@@ -3,8 +3,11 @@ import { BaseVideoAdapter, snapToDurationOption } from '@tanstack/ai/adapters'
 import { toRunErrorPayload } from '@tanstack/ai/adapter-internals'
 import { getGrokApiKeyFromEnv, withGrokDefaults } from '../utils/client'
 import {
+  GROK_VIDEO_MAX_REFERENCE_AUDIOS,
+  GROK_VIDEO_MAX_REFERENCE_IMAGES,
   getGrokVideoDurationOptions,
-  isImageToVideoOnlyModel,
+  isGrokVideoReferenceModel,
+  isGrokVideoSourceModel,
   parseGrokVideoSize,
   validateVideoSize,
 } from '../video/video-provider-options'
@@ -15,6 +18,7 @@ import type {
   TokenUsage,
   VideoGenerationOptions,
   VideoJobResult,
+  VideoPart,
   VideoStatusResult,
   VideoUrlResult,
 } from '@tanstack/ai'
@@ -24,7 +28,7 @@ import type {
   GrokVideoModelInputModalitiesByName,
   GrokVideoModelProviderOptionsByName,
   GrokVideoModelSizeByName,
-  GrokVideoProviderOptions,
+  GrokVideoRuntimeOptions,
 } from '../video/video-provider-options'
 import type { GrokClientConfig } from '../utils/client'
 
@@ -41,7 +45,7 @@ export interface GrokVideoConfig extends GrokClientConfig {}
  */
 const USD_TICKS_PER_DOLLAR = 10_000_000_000
 
-/** Response of POST /v1/videos/generations. */
+/** Response of the POST /v1/videos/{generations,edits,extensions} endpoints. */
 interface GrokVideoCreateResponse {
   request_id?: string
 }
@@ -62,11 +66,13 @@ interface GrokVideoStatusResponse {
 }
 
 /**
- * Convert a TanStack ImagePart to the URL string accepted by xAI's Imagine
- * video endpoint: public URLs pass through (fetched by xAI's servers), data
- * sources become base64 data URIs.
+ * Convert a TanStack image / video part to the URL string accepted by xAI's
+ * Imagine video endpoints: public URLs pass through (fetched by xAI's
+ * servers), data sources become base64 data URIs.
  */
-function imagePartToUrl(part: ImagePart<MediaInputMetadata>): string {
+function mediaPartToUrl(
+  part: ImagePart<MediaInputMetadata> | VideoPart<MediaInputMetadata>,
+): string {
   if (part.source.type === 'url') return part.source.value
   return `data:${part.source.mimeType};base64,${part.source.value}`
 }
@@ -81,7 +87,10 @@ function buildGrokVideoUsage(
     promptTokens: 0,
     completionTokens: 0,
     totalTokens: 0,
-    ...(seconds !== undefined && { unitsBilled: seconds }),
+    ...(seconds !== undefined && {
+      billed: { quantity: seconds, unit: 'seconds' },
+      unitsBilled: seconds,
+    }),
     ...(ticks !== undefined && { cost: ticks / USD_TICKS_PER_DOLLAR }),
   }
 }
@@ -93,10 +102,10 @@ function buildGrokVideoUsage(
  * async jobs/polling architecture: create a generation request, poll it,
  * then read the completed video URL.
  *
- * `grok-imagine-video` (v1.0) supports text-to-video and image-to-video.
- * `grok-imagine-video-1.5` is image-to-video only — every request needs an
- * image prompt part as the starting frame, and the adapter rejects a
- * text-only prompt with a clear error rather than a raw API 400.
+ * Both models support text-to-video and image-to-video;
+ * `grok-imagine-video-1.5` is xAI's documented default and adds native
+ * 1080p generation plus reference-to-video inputs. Source-video edit
+ * and extend are `grok-imagine-video` only.
  *
  * The Imagine video endpoints are not part of the OpenAI SDK surface (and
  * xAI rejects the SDK's multipart paths), so requests are plain JSON calls
@@ -109,13 +118,21 @@ function buildGrokVideoUsage(
  * - Aspect-ratio sizing via the "aspectRatio_resolution" size template
  *   (e.g. '16:9_720p'), consistent with the grok-imagine image models
  * - Image-to-video via an `image` prompt part (starting frame URL or data URI)
- * - Usage reporting: billed seconds (`unitsBilled`) and exact cost
+ * - Reference-to-video via image prompt parts with
+ *   `metadata.role: 'reference'` or `'character'` (→ `reference_images`)
+ *   and preset voices via `modelOptions.reference_audios`
+ *   (grok-imagine-video-1.5 only)
+ * - Video editing / extension on `grok-imagine-video` via a source
+ *   `video` prompt part and `modelOptions.mode: 'edit' | 'extend'`
+ *   (`/v1/videos/edits` / `/v1/videos/extensions`; in extend mode
+ *   `duration` is the added tail)
+ * - Usage reporting: billed seconds (`usage.billed`) and exact cost
  */
 export class GrokVideoAdapter<
   TModel extends GrokVideoModel,
 > extends BaseVideoAdapter<
   TModel,
-  GrokVideoProviderOptions,
+  GrokVideoModelProviderOptionsByName[TModel],
   GrokVideoModelProviderOptionsByName,
   GrokVideoModelSizeByName,
   GrokVideoModelInputModalitiesByName,
@@ -174,98 +191,350 @@ export class GrokVideoAdapter<
 
   async createVideoJob(
     options: VideoGenerationOptions<
-      GrokVideoProviderOptions,
+      GrokVideoModelProviderOptionsByName[TModel],
       GrokVideoModelSizeByName[TModel],
       GrokVideoModelDurationByName[TModel]
     >,
   ): Promise<VideoJobResult> {
     const { model, size, modelOptions, logger } = options
 
+    // `mode` is a routing hint for this adapter, not an API field — strip it
+    // before the remaining options are spread onto the request body. The
+    // per-model map narrows what callers can pass, but modelOptions often
+    // arrives as deserialized JSON, so the adapter handles the widest option
+    // surface (the 1.5 shape) uniformly and gates by model at runtime.
+    const { mode, ...wireOptions } = (modelOptions ??
+      {}) as GrokVideoRuntimeOptions
+
+    // `mode` is typed 'edit' | 'extend' but reaches us untrusted from JSON
+    // callers. An unrecognised value must not fall through to the
+    // generations endpoint with a source-video body — that would silently
+    // run (and bill) a generation the caller never asked for.
+    if (mode !== undefined && mode !== 'edit' && mode !== 'extend') {
+      throw new Error(
+        `${this.name}: unknown modelOptions.mode '${String(mode)}'. ` +
+          `Expected 'edit' or 'extend'.`,
+      )
+    }
+
+    // The interleaved prompt decomposes into verbatim text plus typed media
+    // buckets. Reference audio is voice-id based (not an audio file), so
+    // audio prompt parts have no request field to land in.
+    const resolved = resolveMediaPrompt(options.prompt)
+    if (resolved.audios.length > 0) {
+      throw new Error(
+        `${this.name}.createVideoJob does not support audio prompt parts (model: ${model}). ` +
+          `To reference a preset voice, pass modelOptions.reference_audios ` +
+          `(e.g. [{ voice_id: 'eve' }]).`,
+      )
+    }
+
+    // A video prompt part is the source clip for edit / extension mode.
+    // Those endpoints are grok-imagine-video only — 1.5 has no video input.
+    if (
+      !isGrokVideoSourceModel(model) &&
+      (mode !== undefined || resolved.videos.length > 0)
+    ) {
+      throw new Error(
+        `${this.name}: ${model} does not support video editing or extension. ` +
+          `Use 'grok-imagine-video' for /v1/videos/edits and /v1/videos/extensions.`,
+      )
+    }
+
+    // The mode must be chosen explicitly because the two endpoints have
+    // different semantics (edit rewrites the clip, extend appends
+    // `duration` seconds).
+    if (resolved.videos.length > 1) {
+      throw new Error(
+        `${this.name}: ${model} accepts at most one source video; received ${resolved.videos.length}.`,
+      )
+    }
+    const [sourceVideo] = resolved.videos
+    if (sourceVideo && mode === undefined) {
+      throw new Error(
+        `${this.name}: a video prompt part needs modelOptions.mode set to ` +
+          `'edit' (rewrite the clip) or 'extend' (append to it).`,
+      )
+    }
+    if (!sourceVideo && mode !== undefined) {
+      throw new Error(
+        `${this.name}: modelOptions.mode '${mode}' requires a video prompt ` +
+          `part carrying the source clip.`,
+      )
+    }
+
+    if (mode !== undefined && sourceVideo) {
+      return await this.createSourceVideoJob({
+        model,
+        mode,
+        sourceVideo,
+        resolved,
+        wireOptions,
+        size,
+        genericDuration: options.duration,
+        logger,
+      })
+    }
+
     validateVideoSize(model, size)
 
+    // Pull the specially-handled keys out of the wire options: `duration`
+    // is folded into the snapped value below, and the reference fields are
+    // re-added explicitly so a JSON-serialized `null` or empty array reads
+    // as "unset" instead of leaking onto the wire.
+    const {
+      duration: rawOptionDuration,
+      reference_images: explicitReferenceImages,
+      reference_audios: referenceAudios,
+      ...generationOptions
+    } = wireOptions
+
     // Coerce the requested duration into the model's valid range (1–15s,
     // integer) instead of rejecting it — `snapDuration` clamps and rounds.
     // modelOptions wins over the generic `duration`, mirroring the size
     // precedence below.
-    const rawDuration = modelOptions?.duration ?? options.duration
+    const rawDuration = rawOptionDuration ?? options.duration
     const duration =
-      rawDuration !== undefined ? this.snapDuration(rawDuration) : undefined
-
-    // The interleaved prompt decomposes into verbatim text plus typed media
-    // buckets. The Imagine video endpoint takes a text prompt and an optional
-    // starting frame; reject the modalities it can't consume.
-    const resolved = resolveMediaPrompt(options.prompt)
-    if (resolved.videos.length > 0) {
+      rawDuration != null ? this.snapDuration(rawDuration) : undefined
+
+    // Image parts split by role: un-roled / 'start_frame' images become the
+    // starting frame (image-to-video); 'reference' / 'character' images
+    // become reference_images (reference-to-video). The Imagine API has no
+    // mask / control / end-frame inputs. Unknown role strings (possible via
+    // JSON callers) throw rather than silently dropping the part.
+    const startFrames: Array<ImagePart<MediaInputMetadata>> = []
+    const referenceImages: Array<{ url: string }> = []
+    for (const part of resolved.images) {
+      const role = part.metadata?.role
+      switch (role) {
+        case 'mask':
+        case 'control':
+        case 'end_frame':
+          throw new Error(
+            `${this.name}: the Imagine video API has no '${role}' image ` +
+              `input on model ${model}. Use an un-roled / 'start_frame' ` +
+              `image as the starting frame, or 'reference' images.`,
+          )
+        case 'reference':
+        case 'character':
+          referenceImages.push({ url: mediaPartToUrl(part) })
+          break
+        case 'start_frame':
+        case undefined:
+          startFrames.push(part)
+          break
+        default:
+          throw new Error(
+            `${this.name}: unknown image metadata.role '${String(role)}'. ` +
+              `Expected 'start_frame', 'reference', or 'character'.`,
+          )
+      }
+    }
+    if (startFrames.length > 1) {
       throw new Error(
-        `${this.name}.createVideoJob does not support video prompt parts (model: ${model}).`,
+        `${this.name}: ${model} accepts at most one starting-frame image; received ${startFrames.length}. ` +
+          `Use metadata.role: 'reference' for reference-to-video inputs.`,
       )
     }
-    if (resolved.audios.length > 0) {
+    // Explicit modelOptions.reference_images replaces the part-derived list
+    // (an explicit empty array means "none").
+    const finalReferenceImages =
+      explicitReferenceImages ??
+      (referenceImages.length > 0 ? referenceImages : undefined)
+    const referenceImageCount = finalReferenceImages?.length ?? 0
+    const referenceAudioCount = referenceAudios?.length ?? 0
+    const hasReference = referenceImageCount > 0 || referenceAudioCount > 0
+
+    // Reference inputs are a grok-imagine-video-1.5 feature. The per-model
+    // options map already hides the fields from other models at compile
+    // time; this runtime gate covers prompt-part roles and untyped callers.
+    if (!isGrokVideoReferenceModel(model) && hasReference) {
       throw new Error(
-        `${this.name}.createVideoJob does not support audio prompt parts (model: ${model}).`,
+        `${this.name}: ${model} does not support reference-to-video inputs. ` +
+          `Use 'grok-imagine-video-1.5' for reference_images / reference_audios.`,
       )
     }
-    // grok-imagine-video-1.5 is image-to-video only — text-to-video is
-    // rejected by the API, so fail fast with a clear, actionable message
-    // pointing at the model that does support text-to-video.
-    if (resolved.images.length === 0 && isImageToVideoOnlyModel(model)) {
+    if (referenceAudioCount > GROK_VIDEO_MAX_REFERENCE_AUDIOS) {
       throw new Error(
-        `${this.name}: ${model} does not support text-to-video — it is image-to-video only. ` +
-          `Include an image prompt part as the starting frame, or use 'grok-imagine-video' for text-to-video.`,
+        `${this.name}: ${model} accepts at most ${GROK_VIDEO_MAX_REFERENCE_AUDIOS} reference voices; received ${referenceAudioCount}.`,
       )
     }
-    if (resolved.images.length > 1) {
+    if (referenceImageCount > GROK_VIDEO_MAX_REFERENCE_IMAGES) {
       throw new Error(
-        `${this.name}: ${model} accepts at most one starting-frame image; received ${resolved.images.length}.`,
+        `${this.name}: ${model} accepts at most ${GROK_VIDEO_MAX_REFERENCE_IMAGES} reference images; received ${referenceImageCount}.`,
       )
     }
 
     // Image-to-video: the single image prompt part becomes the starting frame
     // and the prompt text describes the desired motion. URL sources are
     // fetched by xAI's servers; data sources are sent as base64 data URIs.
-    const [startFrame] = resolved.images
+    const [startFrame] = startFrames
+
+    // xAI rejects `image` + `reference_images` / `reference_audios` as a
+    // 400: only one of image-to-video or reference-to-video can be active.
+    if (startFrame && hasReference) {
+      throw new Error(
+        `${this.name}: image-to-video and reference-to-video cannot be combined. ` +
+          `Use a starting-frame image, or reference images / voices, not both.`,
+      )
+    }
 
     // The generic `size` option carries an "aspectRatio_resolution" template
     // (e.g. '16:9_720p') and maps to the Imagine API's `aspect_ratio` /
-    // `resolution` parameters; explicit modelOptions win over the template.
+    // `resolution` parameters; explicit modelOptions win over the template
+    // (including `reference_images`, which replaces the part-derived list).
     const parsedSize = size !== undefined ? parseGrokVideoSize(size) : undefined
+    const resolvedResolution =
+      generationOptions.resolution ?? parsedSize?.resolution
+    if (hasReference && resolvedResolution === '1080p') {
+      throw new Error(
+        `${this.name}: reference-to-video is capped at 720p on ${model}.`,
+      )
+    }
     const request = {
       model,
       prompt: resolved.text,
-      ...(startFrame && { image: { url: imagePartToUrl(startFrame) } }),
+      ...(startFrame && { image: { url: mediaPartToUrl(startFrame) } }),
+      ...(referenceImageCount > 0 && {
+        reference_images: finalReferenceImages,
+      }),
+      ...(referenceAudioCount > 0 && {
+        reference_audios: referenceAudios,
+      }),
       ...(parsedSize && {
         aspect_ratio: parsedSize.aspectRatio,
         ...(parsedSize.resolution !== undefined && {
           resolution: parsedSize.resolution,
         }),
       }),
-      ...modelOptions,
-      // Spread after modelOptions so the snapped duration is authoritative
-      // (modelOptions.duration is folded into `duration` via snapDuration above).
+      // The remaining options spread after the size template so explicit
+      // aspect_ratio / resolution win over it; duration and the reference
+      // fields were destructured out above and re-added normalized.
+      ...generationOptions,
       ...(duration !== undefined && { duration }),
     }
 
-    try {
-      logger.request(
-        `activity=video.create provider=${this.name} model=${model} size=${size ?? 'default'} duration=${duration ?? 'default'}`,
-        { provider: this.name, model },
+    return await this.postVideoJob('/videos/generations', request, {
+      model,
+      logger,
+      logLine: `activity=video.create provider=${this.name} model=${model} mode=generate size=${size ?? 'default'} duration=${duration ?? 'default'}`,
+    })
+  }
+
+  /**
+   * Build and post an edit / extension request. Both endpoints take only
+   * `model`, `prompt`, and the source `video` (plus `duration` — the length
+   * of the added tail — for extensions): output geometry is inherited from
+   * the source clip, capped at 720p, and edit outputs also inherit the
+   * source length. Rather than sending fields the API documents as ignored,
+   * the inapplicable options are rejected with actionable errors.
+   */
+  private async createSourceVideoJob(args: {
+    model: string
+    mode: 'edit' | 'extend'
+    sourceVideo: VideoPart<MediaInputMetadata>
+    resolved: ReturnType<typeof resolveMediaPrompt>
+    wireOptions: Omit<GrokVideoRuntimeOptions, 'mode'>
+    size: string | undefined
+    genericDuration: number | undefined
+    logger: VideoGenerationOptions<GrokVideoRuntimeOptions>['logger']
+  }): Promise<VideoJobResult> {
+    const { model, mode, sourceVideo, resolved, wireOptions, logger } = args
+    const endpoint = mode === 'edit' ? '/videos/edits' : '/videos/extensions'
+
+    if (resolved.images.length > 0) {
+      throw new Error(
+        `${this.name}: '${mode}' mode takes only the source video — image ` +
+          `prompt parts are not supported by ${endpoint}.`,
       )
+    }
 
-      const response = await this.request('/videos/generations', {
+    // Pull every generation-only key out of the wire options so nothing can
+    // leak into the edit/extend body via the spread below. JSON-serialized
+    // `null` values (a common "unset" encoding) are treated as absent;
+    // actual values are rejected with actionable errors.
+    const {
+      aspect_ratio: aspectRatio,
+      resolution,
+      duration: modeDuration,
+      reference_images: referenceImagesOption,
+      reference_audios: referenceAudiosOption,
+      ...passthrough
+    } = wireOptions
+    if (
+      (referenceImagesOption?.length ?? 0) > 0 ||
+      (referenceAudiosOption?.length ?? 0) > 0
+    ) {
+      throw new Error(
+        `${this.name}: reference inputs are only supported by video ` +
+          `generation, not '${mode}' mode.`,
+      )
+    }
+    if (args.size !== undefined || aspectRatio != null || resolution != null) {
+      throw new Error(
+        `${this.name}: '${mode}' mode does not accept size / aspect_ratio / ` +
+          `resolution — the output inherits the source clip's geometry ` +
+          `(capped at 720p).`,
+      )
+    }
+    const rawDuration = modeDuration ?? args.genericDuration
+    if (mode === 'edit' && rawDuration != null) {
+      throw new Error(
+        `${this.name}: 'edit' mode does not accept a duration — the output ` +
+          `inherits the source clip's length. Use mode 'extend' to append ` +
+          `seconds to the clip.`,
+      )
+    }
+    // Extend: the snapped duration is the added-tail length (1–15s).
+    const duration =
+      rawDuration != null ? this.snapDuration(rawDuration) : undefined
+
+    const request = {
+      model,
+      prompt: resolved.text,
+      video: { url: mediaPartToUrl(sourceVideo) },
+      ...passthrough,
+      ...(duration !== undefined && { duration }),
+    }
+
+    return await this.postVideoJob(endpoint, request, {
+      model,
+      logger,
+      logLine: `activity=video.create provider=${this.name} model=${model} mode=${mode} duration=${duration ?? 'default'}`,
+    })
+  }
+
+  /**
+   * POST a create-job request body to one of the Imagine video endpoints
+   * (`/videos/generations`, `/videos/edits`, `/videos/extensions`) and read
+   * the `request_id` out of the shared response shape.
+   */
+  private async postVideoJob(
+    endpoint: string,
+    request: Record<string, unknown>,
+    context: {
+      model: string
+      logger: VideoGenerationOptions<GrokVideoRuntimeOptions>['logger']
+      logLine: string
+    },
+  ): Promise<VideoJobResult> {
+    const { model, logger, logLine } = context
+    try {
+      logger.request(logLine, { provider: this.name, model })
+
+      const response = await this.request(endpoint, {
         method: 'POST',
         body: JSON.stringify(request),
       })
       if (!response.ok) {
         throw new Error(
-          `grok: video generation request failed (${response.status} ${response.statusText}): ${await this.errorMessage(response)}`,
+          `grok: ${endpoint} request failed (${response.status} ${response.statusText}): ${await this.errorMessage(response)}`,
         )
       }
 
       const result = (await response.json()) as GrokVideoCreateResponse
       if (!result.request_id) {
-        throw new Error(
-          'grok: video generation response contained no request_id',
-        )
+        throw new Error(`grok: ${endpoint} response contained no request_id`)
       }
       return { jobId: result.request_id, model }
     } catch (error: unknown) {
@@ -394,15 +663,14 @@ export class GrokVideoAdapter<
  *
  * @experimental Video generation is an experimental feature and may change.
  *
- * @param model - The model name (e.g., 'grok-imagine-video')
+ * @param model - The model name (e.g., 'grok-imagine-video-1.5')
  * @param apiKey - Your xAI API key
  * @param config - Optional additional configuration
  * @returns Configured Grok video adapter instance with resolved types
  *
  * @example
  * ```typescript
- * // grok-imagine-video (v1.0) supports text-to-video.
- * const adapter = createGrokVideo('grok-imagine-video', 'xai-...');
+ * const adapter = createGrokVideo('grok-imagine-video-1.5', 'xai-...');
  *
  * const { jobId } = await generateVideo({
  *   adapter,
@@ -440,7 +708,7 @@ export function createGrokVideo<TModel extends GrokVideoModel>(
  * // Automatically uses XAI_API_KEY from environment
  * const adapter = grokVideo('grok-imagine-video-1.5');
  *
- * // Image-to-video only: the prompt must carry a starting-frame image part.
+ * // Image-to-video: an optional image prompt part is the starting frame.
  * const { jobId } = await generateVideo({
  *   adapter,
  *   prompt: [

package/src/image/image-provider-options.ts

@@ -1,8 +1,9 @@
 /**
  * Grok Image Generation Provider Options
  *
- * These are provider-specific options for Grok image generation.
- * Grok uses the grok-2-image-1212 model for image generation.
+ * Provider-specific options for Grok image generation: the aspect-ratio
+ * sized Imagine API models (grok-imagine-image, grok-imagine-image-2.0,
+ * grok-imagine-image-quality) and the legacy pixel-sized grok-2-image-1212.
  */
 
 /**
@@ -141,12 +142,25 @@ export interface GrokImagineImageProviderOptions extends GrokImageBaseProviderOp
   service_tier?: 'default' | 'priority'
 }
 
+/**
+ * Provider options for grok-imagine-image-2.0, which adds a generation
+ * `quality` knob on top of the shared Imagine options.
+ */
+export interface GrokImagineImage2ProviderOptions extends GrokImagineImageProviderOptions {
+  /**
+   * Generation quality. Only supported by grok-imagine-image-2.0.
+   * @default 'medium'
+   */
+  quality?: 'low' | 'medium'
+}
+
 /**
  * Type-only map from model name to its specific provider options.
  */
 export type GrokImageModelProviderOptionsByName = {
   'grok-2-image-1212': GrokImageProviderOptions
   'grok-imagine-image': GrokImagineImageProviderOptions
+  'grok-imagine-image-2.0': GrokImagineImage2ProviderOptions
   'grok-imagine-image-quality': GrokImagineImageProviderOptions
 }
 
@@ -156,6 +170,7 @@ export type GrokImageModelProviderOptionsByName = {
 export type GrokImageModelSizeByName = {
   'grok-2-image-1212': GrokImageSize
   'grok-imagine-image': GrokImagineImageSize
+  'grok-imagine-image-2.0': GrokImagineImageSize
   'grok-imagine-image-quality': GrokImagineImageSize
 }
 
@@ -167,6 +182,7 @@ export type GrokImageModelSizeByName = {
 export type GrokImageModelInputModalitiesByName = {
   'grok-2-image-1212': readonly []
   'grok-imagine-image': readonly ['image']
+  'grok-imagine-image-2.0': readonly ['image']
   'grok-imagine-image-quality': readonly ['image']
 }
 

package/src/index.ts

@@ -28,6 +28,8 @@ export {
 } from './adapters/image'
 export type {
   GrokImageProviderOptions,
+  GrokImagineImageProviderOptions,
+  GrokImagineImage2ProviderOptions,
   GrokImageModelProviderOptionsByName,
 } from './image/image-provider-options'
 
@@ -43,7 +45,11 @@ export {
   getGrokVideoDurationOptions,
 } from './video/video-provider-options'
 export type {
+  GrokVideoMode,
+  GrokVideoBaseProviderOptions,
+  GrokVideoSourceProviderOptions,
   GrokVideoProviderOptions,
+  GrokVideoRuntimeOptions,
   GrokVideoModelProviderOptionsByName,
   GrokVideoModelSizeByName,
   GrokVideoModelDurationByName,
@@ -101,6 +107,7 @@ export {
   GROK_TTS_MODELS,
   GROK_TRANSCRIPTION_MODELS,
   GROK_REALTIME_MODELS,
+  GROK_DEFAULT_REALTIME_MODEL,
 } from './model-meta'
 export type {
   GrokTextMetadata,