feat(xai): support Grok Imagine Video 1.5 (#103316)

* feat(media): add per-model generation catalog metadata

* feat(xai): support Grok Imagine Video 1.5

* test(plugin-sdk): update public surface budget

packages/media-generation-core/src/catalog.test.ts

@@ -56,6 +56,49 @@ describe("media-generation catalog", () => {
     ).toEqual(["video-default", "video-pro"]);
   });
 
+  it("uses per-model capabilities and modes when provided", () => {
+    type VideoCapabilities = {
+      generate?: { maxVideos: number };
+      imageToVideo?: { enabled: boolean; maxInputImages: number };
+    };
+    const providerCapabilities: VideoCapabilities = {
+      generate: { maxVideos: 1 },
+    };
+    const alternateCapabilities: VideoCapabilities = {
+      imageToVideo: { enabled: true, maxInputImages: 1 },
+    };
+
+    const rows = synthesizeMediaGenerationCatalogEntries({
+      kind: "video_generation",
+      provider: {
+        id: "example",
+        defaultModel: "default-video",
+        models: ["default-video", "image-video"],
+        capabilities: providerCapabilities,
+        catalogByModel: {
+          "image-video": {
+            capabilities: alternateCapabilities,
+            modes: ["imageToVideo"],
+          },
+        },
+      },
+      modes: ["generate"],
+    });
+
+    expect(rows).toEqual([
+      expect.objectContaining({
+        model: "default-video",
+        capabilities: providerCapabilities,
+        modes: ["generate"],
+      }),
+      expect.objectContaining({
+        model: "image-video",
+        capabilities: alternateCapabilities,
+        modes: ["imageToVideo"],
+      }),
+    ]);
+  });
+
   it("marks a trimmed default model as the catalog default", () => {
     expect(
       synthesizeMediaGenerationCatalogEntries({

packages/media-generation-core/src/catalog.ts

@@ -30,6 +30,12 @@ export type MediaGenerationCatalogEntry<TCapabilities = unknown> = {
   warnings?: readonly string[];
 };
 
+/** Static catalog metadata that overrides provider defaults for one model. */
+export type MediaGenerationCatalogModelEntry<TCapabilities = unknown> = {
+  capabilities?: TCapabilities;
+  modes?: readonly string[];
+};
+
 /** Provider metadata used to synthesize static media generation catalog entries. */
 export type MediaGenerationCatalogProvider<TCapabilities = unknown> = {
   id: string;
@@ -38,6 +44,7 @@ export type MediaGenerationCatalogProvider<TCapabilities = unknown> = {
   defaultModel?: string;
   models?: readonly string[];
   capabilities: TCapabilities;
+  catalogByModel?: Readonly<Record<string, MediaGenerationCatalogModelEntry<TCapabilities>>>;
 };
 
 /** Return unique configured models with default model first when present. */
@@ -53,12 +60,13 @@ export function synthesizeMediaGenerationCatalogEntries<TCapabilities>(params: {
 }): Array<MediaGenerationCatalogEntry<TCapabilities>> {
   const defaultModel = uniqueTrimmedStrings([params.provider.defaultModel])[0];
   return uniqueModels(params.provider).map((model) => {
+    const modelCatalogEntry = params.provider.catalogByModel?.[model];
     const entry: MediaGenerationCatalogEntry<TCapabilities> = {
       kind: params.kind,
       provider: params.provider.id,
       model,
       source: "static",
-      capabilities: params.provider.capabilities,
+      capabilities: modelCatalogEntry?.capabilities ?? params.provider.capabilities,
     };
     if (params.provider.label) {
       entry.label = params.provider.label;
@@ -66,8 +74,9 @@ export function synthesizeMediaGenerationCatalogEntries<TCapabilities>(params: {
     if (model === defaultModel) {
       entry.default = true;
     }
-    if (params.modes) {
-      entry.modes = params.modes;
+    const modes = modelCatalogEntry?.modes ?? params.modes;
+    if (modes) {
+      entry.modes = modes;
     }
     return entry;
   });