diff --git a/.changeset/openrouter-video-adapter.md b/.changeset/openrouter-video-adapter.md
new file mode 100644
index 000000000..d1b9e7f7d
--- /dev/null
+++ b/.changeset/openrouter-video-adapter.md
@@ -0,0 +1,7 @@
+---
+'@tanstack/ai-openrouter': minor
+---
+
+Add `openRouterVideo`, a video generation adapter for OpenRouter's dedicated async API (`POST /api/v1/videos`) — Seedance, Veo 3.1, Wan, Kling, and Sora 2 Pro through one API key. Follows the jobs/polling architecture (`generateVideo()` → `getVideoJobStatus()`), with per-model `size` / `duration` / provider-option types generated from OpenRouter's `GET /api/v1/videos/models` metadata and validated before submit. Image-conditioned prompts map `metadata.role` onto the wire: `start_frame` / `end_frame` → `frame_images[]` (`first_frame` / `last_frame`), `reference` / `character` → `input_references[]`; frame roles are validated against each model's `supported_frame_images`. Completed videos are downloaded server-side and returned as `data:` URLs (OpenRouter's download URLs require the API key), and the gateway-reported cost is surfaced as `usage.cost`.
+
+Image adapter fixes from the #624 review: requested `size` is now validated (the `WIDTHxHEIGHT` union previously used a Unicode `×`, so every size except `1024x1024` silently dropped its aspect ratio; unsupported sizes now throw with the supported list), `numberOfImages > 1` throws instead of silently returning one image (verified live: the gateway ignores all count keys in `image_config`), and `image_config.strength` (0.0–1.0 image-to-image influence) is exposed via `modelOptions.strength`.
diff --git a/docs/adapters/openrouter.md b/docs/adapters/openrouter.md
index cd8984511..eff6d0aec 100644
--- a/docs/adapters/openrouter.md
+++ b/docs/adapters/openrouter.md
@@ -219,6 +219,91 @@ fields are simply absent and the stream completes normally. Both
 `openRouterText` and `openRouterResponsesText` populate cost when OpenRouter
 returns it.
 
+## Image Generation
+
+`openRouterImage` routes image generation through OpenRouter's
+chat-completions surface (`modalities: ['image']`). Multimodal prompts are
+supported — text and image parts are forwarded in order for
+image-conditioned generation:
+
+```typescript
+import { generateImage } from "@tanstack/ai";
+import { openRouterImage } from "@tanstack/ai-openrouter";
+
+const result = await generateImage({
+  adapter: openRouterImage("google/gemini-2.5-flash-image"),
+  prompt: "A watercolor lighthouse at dusk",
+  size: "1344x768", // mapped to image_config.aspect_ratio ('16:9')
+  modelOptions: {
+    image_size: "2K", // resolution (Gemini models)
+    strength: 0.35, // image-to-image influence, i2i-capable models only
+  },
+});
+```
+
+Notes:
+
+- The pathway returns **exactly one image per request** — `numberOfImages > 1`
+  throws instead of silently under-delivering. Make multiple requests if you
+  need multiple candidates.
+- `size` must be one of the ten supported `WIDTHxHEIGHT` values (it is
+  converted to `image_config.aspect_ratio`); anything else throws with the
+  supported list.
+
+## Video Generation (Experimental)
+
+`openRouterVideo` targets OpenRouter's dedicated **async video API**
+(`POST /api/v1/videos`) — Seedance, Veo 3.1, Wan, Kling, and Sora 2 Pro
+through your one OpenRouter key. It follows the jobs/polling architecture
+shared by all TanStack AI video adapters:
+
+```typescript
+// Server: create the job, then poll
+import { generateVideo, getVideoJobStatus } from "@tanstack/ai";
+import { openRouterVideo } from "@tanstack/ai-openrouter";
+
+const adapter = openRouterVideo("bytedance/seedance-2.0");
+
+const { jobId } = await generateVideo({
+  adapter,
+  prompt: [
+    { type: "text", content: "Animate this product shot, slow push-in" },
+    {
+      type: "image",
+      source: { type: "url", value: "https://your-cdn.com/product.png" },
+      metadata: { role: "start_frame" },
+    },
+  ],
+  size: "1280x720",
+  duration: 8,
+});
+
+let status = await getVideoJobStatus({ adapter, jobId });
+while (status.status !== "completed" && status.status !== "failed") {
+  await new Promise((r) => setTimeout(r, 5000));
+  status = await getVideoJobStatus({ adapter, jobId });
+}
+// status.url is a data: URL (OpenRouter download URLs require the API key,
+// so the adapter downloads server-side); status.usage?.cost is the real
+// billed cost reported by the gateway.
+```
+
+```tsx
+// Client: track the job with the useGenerateVideo hook
+import { useGenerateVideo, fetchServerSentEvents } from "@tanstack/ai-react";
+
+const { generate, result, videoStatus, isLoading } = useGenerateVideo({
+  connection: fetchServerSentEvents("/api/generate/video"),
+});
+// result?.url renders directly: <video src={result.url} controls />
+```
+
+Sizes, durations, and per-model options (`resolution`, `aspectRatio`,
+`generateAudio`, `seed`, …) are typed and validated per model from
+OpenRouter's video model metadata. See
+[Video Generation](../media/video-generation.md) for the full lifecycle,
+streaming mode, and the image-to-video role-mapping table.
+
 ## Next Steps
 
 - [Getting Started](../getting-started/quick-start) - Learn the basics
diff --git a/docs/config.json b/docs/config.json
index e3fc3b712..d840f1f3f 100644
--- a/docs/config.json
+++ b/docs/config.json
@@ -249,13 +249,13 @@
           "label": "Image Generation",
           "to": "media/image-generation",
           "addedAt": "2026-04-15",
-          "updatedAt": "2026-06-08"
+          "updatedAt": "2026-06-10"
         },
         {
           "label": "Video Generation",
           "to": "media/video-generation",
           "addedAt": "2026-04-15",
-          "updatedAt": "2026-06-08"
+          "updatedAt": "2026-06-10"
         },
         {
           "label": "Generation Hooks",
@@ -440,7 +440,8 @@
         {
           "label": "OpenRouter Adapter",
           "to": "adapters/openrouter",
-          "addedAt": "2026-04-15"
+          "addedAt": "2026-04-15",
+          "updatedAt": "2026-06-10"
         },
         {
           "label": "OpenAI-Compatible",
diff --git a/docs/media/image-generation.md b/docs/media/image-generation.md
index 358e9bd9e..9554723eb 100644
--- a/docs/media/image-generation.md
+++ b/docs/media/image-generation.md
@@ -287,7 +287,7 @@ await generateImage({
 | **Gemini**   | Native models (`gemini-*-flash-image`, "nano-banana", etc.) → prompt parts map 1:1 onto multimodal `contents`, preserving interleaved order. Up to ~14 input images (provider limit, not enforced by the SDK).<br>Imagen models → throws (text-to-image only). |
 | **fal.ai**   | Field names resolve per endpoint from a map generated from the fal SDK's endpoint types (e.g. nano-banana edit gets `image_urls`, Fooocus masks get `mask_image_url`). Defaults for unknown endpoints: 1 input → `image_url`; multiple → `image_urls`; `role: 'mask'` → `mask_url`; `role: 'control'` → `control_image_url`; `role: 'reference'` / `'character'` → `reference_image_urls`. Override with `modelOptions` for endpoint-specific fields. |
 | **Grok**     | grok-imagine models → xAI's `/v1/images/edits` (up to 3 source images, addressed by xAI in request order; prompt sent verbatim). `role: 'mask'` / `'control'` throw (no Imagine API equivalent). `grok-2-image-1212` throws (text-to-image only). |
-| **OpenRouter** | Prompt parts map 1:1 onto multimodal `image_url` / `text` content parts, preserving interleaved order, and are forwarded to the underlying image model.                                                                                    |
+| **OpenRouter** | Prompt parts map 1:1 onto multimodal `image_url` / `text` content parts, preserving interleaved order, and are forwarded to the underlying image model. `modelOptions.strength` (0.0–1.0) controls image-to-image influence on models that document it (e.g. Recraft). One image per request — `numberOfImages > 1` throws (the gateway ignores count keys).                                                                                    |
 | **Anthropic** | n/a — no image generation API.                                                                                                                                                                          |
 
 Adapters that don't support image-conditioned generation throw a clear
diff --git a/docs/media/video-generation.md b/docs/media/video-generation.md
index dd175b3b6..086c6504f 100644
--- a/docs/media/video-generation.md
+++ b/docs/media/video-generation.md
@@ -2,15 +2,19 @@
 title: Video Generation
 id: video-generation
 order: 6
-description: "Generate video from text prompts with OpenAI Sora using TanStack AI's experimental generateVideo() jobs/polling API."
+description: "Generate video from text prompts with OpenAI Sora, fal.ai, or OpenRouter (Seedance, Veo, Wan) using TanStack AI's experimental generateVideo() jobs/polling API."
 keywords:
   - tanstack ai
   - video generation
   - sora
+  - openrouter
+  - seedance
+  - veo
   - generateVideo
   - jobs api
   - experimental
   - text-to-video
+  - image-to-video
 ---
 
 # Video Generation (Experimental)
@@ -36,6 +40,8 @@ TanStack AI provides experimental support for video generation through dedicated
 
 Currently supported:
 - **OpenAI**: Sora-2 and Sora-2-Pro models (when available)
+- **fal.ai**: Kling, MiniMax, Hunyuan, and other fal-hosted video endpoints
+- **OpenRouter**: Seedance, Veo 3.1, Wan, Kling, Sora 2 Pro and others via the dedicated async video API (`POST /api/v1/videos`)
 
 ## Basic Usage
 
@@ -415,12 +421,12 @@ for the per-provider table.
 Each `ImagePart` can carry an optional `metadata.role` hint that the
 adapter uses to route the input to the provider-specific field:
 
-| Role            | Maps to                                                       |
-| --------------- | ------------------------------------------------------------- |
-| `'start_frame'` | fal `start_image_url` (positional default for the first input)         |
-| `'end_frame'`   | fal `end_image_url` (Veo `lastFrame` planned — no Veo adapter yet)      |
-| `'reference'`   | fal `reference_image_urls` (Veo `referenceImages` planned)              |
-| `'character'`   | Same as `'reference'` — character consistency images                    |
+| Role            | Maps to                                                                                                  |
+| --------------- | --------------------------------------------------------------------------------------------------------- |
+| `'start_frame'` | fal `start_image_url`; OpenRouter `frame_images[]` with `frame_type: 'first_frame'` (positional default for the first input) |
+| `'end_frame'`   | fal `end_image_url`; OpenRouter `frame_images[]` with `frame_type: 'last_frame'` (Veo `lastFrame` planned — no Veo adapter yet) |
+| `'reference'`   | fal `reference_image_urls`; OpenRouter `input_references[]` (Veo `referenceImages` planned)              |
+| `'character'`   | Same as `'reference'` — character consistency images                                                     |
 
 ```typescript
 import { falVideo } from '@tanstack/ai-fal'
@@ -445,7 +451,8 @@ await generateVideo({
 | ------------ | -------------------------------------------------------------------------------------------------------- |
 | **OpenAI**   | Sora-2 / Sora-2-Pro → the image part goes to `input_reference`; flattened text is the prompt. Single image only — throws if more than one. |
 | **fal.ai**   | Field names resolve per endpoint from a map generated from the fal SDK's endpoint types — e.g. `role: 'start_frame'` lands on `image_url` for Kling/Veo image-to-video, `first_frame_url` for first-last-frame endpoints, and `start_image_url` otherwise. Defaults: single input → `image_url` (start frame); `role: 'end_frame'` → `end_image_url`; `role: 'reference'` / `'character'` → `reference_image_urls`. Override per-endpoint via `modelOptions` — the media-conditioning fields are typed optional there (even when the endpoint requires them) since they usually arrive as prompt parts. |
-| **Gemini**   | Veo adapter not yet implemented — image prompt parts will be supported when Veo lands.                    |
+| **OpenRouter** | `role: 'start_frame'` / `'end_frame'` → `frame_images[]` with `frame_type: 'first_frame'` / `'last_frame'`; `role: 'reference'` / `'character'` → `input_references[]`; an unroled image defaults to the start frame. At most one start and one end frame; frame roles are validated against the model's `supported_frame_images` metadata (e.g. Hailuo only takes a first frame). When both frame images and references are present, OpenRouter treats the request as image-to-video and references take lower priority. URL image sources pass through verbatim and `data` sources become data URIs — OpenRouter does not fetch URLs behind redirects or bot checks, so use directly accessible URLs. |
+| **Gemini**   | Veo adapter not yet implemented — image prompt parts will be supported when Veo lands (Veo models are available today through `openRouterVideo`). |
 
 Adapters whose underlying API can't accept image inputs throw a clear
 runtime error so calls fail fast.
@@ -488,6 +495,45 @@ const { jobId } = await generateVideo({
 })
 ```
 
+### OpenRouter Model Options
+
+OpenRouter's [video generation API](https://openrouter.ai/docs/guides/overview/multimodal/video-generation)
+runs Seedance, Veo, Wan, Kling, Sora 2 Pro and others behind one async jobs
+API. `size`, `duration`, and the per-model options below are typed **and
+validated per model** from OpenRouter's published model capabilities (a size
+or duration the model doesn't support throws before the request is sent):
+
+```typescript
+import { generateVideo } from '@tanstack/ai'
+import { openRouterVideo } from '@tanstack/ai-openrouter'
+
+const { jobId } = await generateVideo({
+  adapter: openRouterVideo('bytedance/seedance-2.0'),
+  prompt: 'A beautiful sunset over the ocean',
+  size: '1280x720',          // per-model union from OpenRouter's model metadata
+  duration: 8,               // validated against the model's supported durations
+  modelOptions: {
+    resolution: '720p',      // alternative to size: resolution + aspectRatio
+    aspectRatio: '16:9',
+    generateAudio: true,     // omitted from the type for models that can't
+    seed: 42,                // omitted from the type for models that can't
+    callbackUrl: 'https://your-app.com/webhooks/openrouter-video',
+    provider: { options: { bytedance: { watermark: false } } }, // passthrough
+  },
+})
+```
+
+Two OpenRouter-specific behaviors to know about:
+
+- **The completed video arrives as a `data:` URL.** OpenRouter's download
+  URLs require your API key in an `Authorization` header, so the adapter
+  downloads the content server-side and returns a base64 data URL that can
+  be handed straight to a `<video>` tag. Videos over ~10 MiB log a warning —
+  prefer re-uploading to your own storage/CDN over passing large data URLs
+  around.
+- **Cost is reported on completion.** The gateway reports the real billed
+  cost for the job; it's surfaced as `usage.cost` on the completed result.
+
 ## Response Types
 
 > **Note:** The interfaces below are the underlying adapter-level types. The `getVideoJobStatus()` helper returns a single merged object, `{ status, progress?, url?, error?, usage? }` — it does not return `jobId` or `expiresAt`.
@@ -586,9 +632,12 @@ Check the [OpenAI documentation](https://platform.openai.com/docs) for current l
 
 ## Environment Variables
 
-The video adapter uses the same environment variable as other OpenAI adapters:
+The video adapters use the same environment variables as the other adapters
+from their packages:
 
-- `OPENAI_API_KEY`: Your OpenAI API key
+- `OPENAI_API_KEY`: Your OpenAI API key (`openaiVideo`)
+- `OPENROUTER_API_KEY`: Your OpenRouter API key (`openRouterVideo`)
+- `FAL_KEY`: Your fal.ai API key (`falVideo`)
 
 ## Explicit API Keys
 
diff --git a/packages/ai-openrouter/package.json b/packages/ai-openrouter/package.json
index ef59cab93..fd034b282 100644
--- a/packages/ai-openrouter/package.json
+++ b/packages/ai-openrouter/package.json
@@ -52,7 +52,7 @@
     "model-router"
   ],
   "dependencies": {
-    "@openrouter/sdk": "0.12.35",
+    "@openrouter/sdk": "0.12.79",
     "@tanstack/ai-utils": "workspace:*"
   },
   "devDependencies": {
diff --git a/packages/ai-openrouter/src/adapters/image.ts b/packages/ai-openrouter/src/adapters/image.ts
index ced370e54..323aaf2bf 100644
--- a/packages/ai-openrouter/src/adapters/image.ts
+++ b/packages/ai-openrouter/src/adapters/image.ts
@@ -44,6 +44,25 @@ const SIZE_TO_ASPECT_RATIO: Record<string, string> = {
   '1536x672': '21:9',
 }
 
+/**
+ * Resolve a requested size to the aspect ratio OpenRouter's chat-completions
+ * image pathway understands (`image_config.aspect_ratio`). The pathway has
+ * no free-form size field, so a size outside the mapping table cannot be
+ * expressed — throw rather than silently generating at the default 1:1.
+ * Accepts the multiplication sign ('×') as a separator for tolerance.
+ */
+function sizeToAspectRatio(size: string | undefined): string | undefined {
+  if (!size) return undefined
+  const normalized = size.replace('×', 'x')
+  const aspectRatio = SIZE_TO_ASPECT_RATIO[normalized]
+  if (!aspectRatio) {
+    throw new Error(
+      `openrouter: unsupported image size '${size}'. Supported sizes: ${Object.keys(SIZE_TO_ASPECT_RATIO).join(', ')}.`,
+    )
+  }
+  return aspectRatio
+}
+
 /**
  * Convert a TanStack ImagePart into the URL string accepted by OpenRouter's
  * `image_url` content parts: public URLs pass through, data sources become
@@ -89,8 +108,16 @@ export class OpenRouterImageAdapter<
     }
 
     const { model, numberOfImages, size, modelOptions, logger } = options
-    // Use provided aspect_ratio or derive from size
-    const aspectRatio = size ? SIZE_TO_ASPECT_RATIO[size] : undefined
+    // OpenRouter's chat-completions image pathway returns exactly one image
+    // per request and ignores any count key in image_config (verified
+    // against the live API), so reject multi-image requests instead of
+    // silently under-delivering.
+    if (numberOfImages !== undefined && numberOfImages > 1) {
+      throw new Error(
+        `openrouter: the chat-completions image pathway generates one image per request (numberOfImages: ${numberOfImages}). Make multiple requests instead.`,
+      )
+    }
+    const aspectRatio = sizeToAspectRatio(size)
 
     // Image-conditioned generation: map the prompt parts 1:1 onto
     // chat-completions content parts, preserving the interleaved order —
@@ -135,9 +162,11 @@ export class OpenRouterImageAdapter<
         ],
         modalities: ['image'],
         stream: false,
-        // OpenRouter filters out invalid config per provider specifications
+        // The SDK serializes this record verbatim as `image_config`, so keys
+        // must match the HTTP API's documented snake_case fields — miskeyed
+        // entries are silently ignored by the gateway (verified live:
+        // `aspect_ratio` changes output dimensions, `aspectRatio` does not).
         imageConfig: {
-          ...(numberOfImages ? { numberOfImages } : {}),
           ...(aspectRatio
             ? {
                 aspect_ratio: aspectRatio,
@@ -148,6 +177,11 @@ export class OpenRouterImageAdapter<
                 image_size: modelOptions.image_size,
               }
             : {}),
+          ...(modelOptions?.strength !== undefined
+            ? {
+                strength: modelOptions.strength,
+              }
+            : {}),
         },
       },
     })
diff --git a/packages/ai-openrouter/src/adapters/video.ts b/packages/ai-openrouter/src/adapters/video.ts
new file mode 100644
index 000000000..7de92f326
--- /dev/null
+++ b/packages/ai-openrouter/src/adapters/video.ts
@@ -0,0 +1,423 @@
+import { OpenRouter } from '@openrouter/sdk'
+import { buildBaseUsage, resolveMediaPrompt } from '@tanstack/ai'
+import { BaseVideoAdapter } from '@tanstack/ai/adapters'
+import { arrayBufferToBase64 } from '@tanstack/ai-utils'
+import { getOpenRouterApiKeyFromEnv } from '../utils'
+import {
+  getVideoModelMeta,
+  validateVideoDuration,
+  validateVideoSize,
+} from '../video/video-provider-options'
+import type {
+  OpenRouterVideoModel,
+  OpenRouterVideoModelInputModalitiesByName,
+  OpenRouterVideoModelProviderOptionsByName,
+  OpenRouterVideoModelSizeByName,
+  OpenRouterVideoProviderOptions,
+} from '../video/video-provider-options'
+import type {
+  AspectRatio,
+  ContentPartImage,
+  FrameImage,
+  Resolution,
+  VideoGenerationRequest,
+  VideoGenerationResponse,
+} from '@openrouter/sdk/models'
+import type {
+  ImagePart,
+  MediaInputMetadata,
+  TokenUsage,
+  VideoGenerationOptions,
+  VideoJobResult,
+  VideoStatusResult,
+  VideoUrlResult,
+} from '@tanstack/ai'
+import type { OpenRouterClientConfig } from '../utils'
+
+/**
+ * Configuration for the OpenRouter video adapter.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export interface OpenRouterVideoConfig extends OpenRouterClientConfig {
+  /**
+   * Injectable fetch implementation used for the authenticated video
+   * content download (tests, custom runtimes). Defaults to the global
+   * fetch.
+   */
+  fetch?: typeof globalThis.fetch
+}
+
+/**
+ * Threshold for emitting a "this download will probably OOM serverless
+ * runtimes" warning. Anything larger than this (in bytes) gets surfaced via
+ * console.warn — workers and small isolates routinely run out of memory once
+ * a downloaded video is base64-encoded.
+ */
+const LARGE_MEDIA_BUFFER_BYTES = 10 * 1024 * 1024
+
+function warnIfLargeMediaBuffer(byteLength: number): void {
+  if (byteLength <= LARGE_MEDIA_BUFFER_BYTES) return
+  console.warn(
+    `[openrouter.video] downloaded ${(byteLength / 1024 / 1024).toFixed(1)} MiB into memory before base64 encoding. ` +
+      `Workers/serverless runtimes commonly run out of memory above ~10 MiB. ` +
+      `Consider streaming the video through a CDN or your own storage layer instead.`,
+  )
+}
+
+/**
+ * Convert a TanStack ImagePart into the URL string accepted by OpenRouter's
+ * video API image fields: public URLs pass through verbatim, data sources
+ * become base64 data URIs. OpenRouter never fetches URLs through redirects
+ * or bot checks on your behalf — pass directly accessible URLs.
+ */
+function imagePartToUrl(part: ImagePart<MediaInputMetadata>): string {
+  if (part.source.type === 'url') return part.source.value
+  return `data:${part.source.mimeType};base64,${part.source.value}`
+}
+
+interface VideoImageFields {
+  frameImages?: Array<FrameImage>
+  inputReferences?: Array<ContentPartImage>
+}
+
+/**
+ * Map the prompt's image parts onto OpenRouter's video request fields:
+ *
+ * - `metadata.role === 'start_frame'`             → `frame_images[]` with `frame_type: 'first_frame'`
+ * - `metadata.role === 'end_frame'`               → `frame_images[]` with `frame_type: 'last_frame'`
+ * - `metadata.role === 'reference' | 'character'` → `input_references[]`
+ * - `metadata.role === 'mask' | 'control'`        → throws (no video routing)
+ * - remaining parts (no role)                     → start frame (positional default)
+ *
+ * When both `frame_images` and `input_references` are present OpenRouter
+ * treats the request as image-to-video and references take lower priority.
+ * Frame roles are validated against the model's `supported_frame_images`
+ * metadata when known.
+ */
+function mapImagePartsToVideoFields(
+  model: string,
+  images: Array<ImagePart<MediaInputMetadata>>,
+): VideoImageFields {
+  if (images.length === 0) return {}
+
+  const starts: Array<string> = []
+  const ends: Array<string> = []
+  const references: Array<string> = []
+  for (const part of images) {
+    const role = part.metadata?.role
+    if (role === 'mask' || role === 'control') {
+      throw new Error(
+        `openrouter: metadata.role === '${role}' is not supported for video generation on model ${model}. Remove the role or use 'start_frame' / 'end_frame' / 'reference'.`,
+      )
+    }
+    const url = imagePartToUrl(part)
+    if (role === 'end_frame') ends.push(url)
+    else if (role === 'reference' || role === 'character') references.push(url)
+    // Unroled parts default to the start frame (image-to-video).
+    else starts.push(url)
+  }
+
+  if (starts.length > 1) {
+    throw new Error(
+      `openrouter: at most one start-frame image is supported per request (received ${starts.length}). Mark additional images with metadata.role 'reference' or 'end_frame'.`,
+    )
+  }
+  if (ends.length > 1) {
+    throw new Error(
+      `openrouter: at most one input with metadata.role === 'end_frame' is supported per request (received ${ends.length}).`,
+    )
+  }
+
+  const supportedFrames = getVideoModelMeta(model)?.frameImages
+  if (supportedFrames) {
+    if (starts.length > 0 && !supportedFrames.includes('first_frame')) {
+      throw new Error(
+        `openrouter: model ${model} does not accept a start-frame image (supported frame images: ${supportedFrames.join(', ') || 'none'}).`,
+      )
+    }
+    if (ends.length > 0 && !supportedFrames.includes('last_frame')) {
+      throw new Error(
+        `openrouter: model ${model} does not accept an end-frame image (supported frame images: ${supportedFrames.join(', ') || 'none'}).`,
+      )
+    }
+  }
+
+  const frameImages: Array<FrameImage> = [
+    ...starts.map(
+      (url): FrameImage => ({
+        type: 'image_url',
+        imageUrl: { url },
+        frameType: 'first_frame',
+      }),
+    ),
+    ...ends.map(
+      (url): FrameImage => ({
+        type: 'image_url',
+        imageUrl: { url },
+        frameType: 'last_frame',
+      }),
+    ),
+  ]
+
+  return {
+    ...(frameImages.length > 0 ? { frameImages } : {}),
+    ...(references.length > 0
+      ? {
+          inputReferences: references.map(
+            (url): ContentPartImage => ({
+              type: 'image_url',
+              imageUrl: { url },
+            }),
+          ),
+        }
+      : {}),
+  }
+}
+
+/**
+ * Map OpenRouter job status onto the TanStack video job status. OpenRouter
+ * reports `pending → in_progress → completed | failed`, plus `cancelled` and
+ * `expired` terminals.
+ */
+function mapStatus(
+  apiStatus: VideoGenerationResponse['status'],
+): VideoStatusResult['status'] {
+  switch (apiStatus) {
+    case 'pending':
+      return 'pending'
+    case 'in_progress':
+      return 'processing'
+    case 'completed':
+      return 'completed'
+    case 'failed':
+    case 'cancelled':
+    case 'expired':
+      return 'failed'
+    default:
+      return 'processing'
+  }
+}
+
+/**
+ * Build TokenUsage from the job's usage block. Video generation bills by
+ * cost, not tokens, so the token counts are zero and the gateway-reported
+ * cost is surfaced via `usage.cost`.
+ */
+function buildVideoUsage(
+  usage: VideoGenerationResponse['usage'],
+): TokenUsage | undefined {
+  if (usage?.cost == null) return undefined
+  const result = buildBaseUsage({
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+  })
+  result.cost = usage.cost
+  return result
+}
+
+/**
+ * OpenRouter Video Generation Adapter
+ *
+ * Tree-shakeable adapter for OpenRouter's dedicated async video generation
+ * API (`POST /api/v1/videos`) — Seedance, Veo, Wan, Kling, Sora and others
+ * through one gateway. Uses a jobs/polling architecture: submit a job, poll
+ * `GET /api/v1/videos/{jobId}` until completed, then download from the
+ * job's unsigned URLs.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ */
+export class OpenRouterVideoAdapter<
+  TModel extends OpenRouterVideoModel,
+> extends BaseVideoAdapter<
+  TModel,
+  OpenRouterVideoProviderOptions,
+  OpenRouterVideoModelProviderOptionsByName,
+  OpenRouterVideoModelSizeByName,
+  OpenRouterVideoModelInputModalitiesByName
+> {
+  override readonly kind = 'video' as const
+  readonly name = 'openrouter' as const
+
+  private readonly client: OpenRouter
+  private readonly clientConfig: OpenRouterVideoConfig
+
+  constructor(config: OpenRouterVideoConfig, model: TModel) {
+    super({}, model)
+    this.clientConfig = config
+    this.client = new OpenRouter({
+      ...config,
+      apiKey: config.apiKey,
+      serverURL: config.baseURL,
+    })
+  }
+
+  async createVideoJob(
+    options: VideoGenerationOptions<OpenRouterVideoProviderOptions>,
+  ): Promise<VideoJobResult> {
+    const { size, duration, modelOptions, logger } = options
+
+    const resolved = resolveMediaPrompt(options.prompt)
+    if (resolved.videos.length > 0) {
+      throw new Error(
+        `openrouter.createVideoJob does not support video prompt parts (model: ${this.model}).`,
+      )
+    }
+    if (resolved.audios.length > 0) {
+      throw new Error(
+        `openrouter.createVideoJob does not support audio prompt parts (model: ${this.model}).`,
+      )
+    }
+
+    validateVideoSize(this.model, size)
+    validateVideoDuration(this.model, duration)
+
+    const imageFields = mapImagePartsToVideoFields(this.model, resolved.images)
+
+    const request: VideoGenerationRequest = {
+      model: this.model,
+      prompt: resolved.text,
+      ...imageFields,
+      ...(size ? { size } : {}),
+      ...(duration !== undefined ? { duration } : {}),
+      ...(modelOptions?.seed !== undefined ? { seed: modelOptions.seed } : {}),
+      ...(modelOptions?.generateAudio !== undefined
+        ? { generateAudio: modelOptions.generateAudio }
+        : {}),
+      ...(modelOptions?.callbackUrl
+        ? { callbackUrl: modelOptions.callbackUrl }
+        : {}),
+      ...(modelOptions?.provider ? { provider: modelOptions.provider } : {}),
+    }
+    // The SDK types these as branded open enums; the per-model literal
+    // unions derived from OPENROUTER_VIDEO_MODEL_META can be broader than
+    // the SDK's enum members (e.g. grok-imagine-video's '3:2'), so narrow at
+    // the boundary — the wire format is a plain string either way.
+    if (modelOptions?.resolution) {
+      request.resolution = modelOptions.resolution as Resolution
+    }
+    if (modelOptions?.aspectRatio) {
+      request.aspectRatio = modelOptions.aspectRatio as AspectRatio
+    }
+
+    try {
+      logger.request(
+        `activity=video.create provider=${this.name} model=${this.model} size=${size ?? 'default'} duration=${duration ?? 'default'}`,
+        { provider: this.name, model: this.model },
+      )
+      const response = await this.client.videoGeneration.generate({
+        videoGenerationRequest: request,
+      })
+      return { jobId: response.id, model: this.model }
+    } catch (error) {
+      logger.errors(`${this.name}.createVideoJob fatal`, {
+        error,
+        source: `${this.name}.createVideoJob`,
+      })
+      throw error
+    }
+  }
+
+  async getVideoStatus(jobId: string): Promise<VideoStatusResult> {
+    const response = await this.client.videoGeneration.getGeneration({ jobId })
+    return {
+      jobId,
+      status: mapStatus(response.status),
+      ...(response.error !== undefined ? { error: response.error } : {}),
+    }
+  }
+
+  async getVideoUrl(jobId: string): Promise<VideoUrlResult> {
+    const response = await this.client.videoGeneration.getGeneration({ jobId })
+    const status = mapStatus(response.status)
+    if (status === 'failed') {
+      throw new Error(
+        `openrouter: video job ${jobId} ${response.status}${response.error ? `: ${response.error}` : ''}`,
+      )
+    }
+    const contentUrl = response.unsignedUrls?.[0]
+    if (status !== 'completed' || !contentUrl) {
+      throw new Error(
+        `openrouter: video job ${jobId} has no downloadable content yet (status: ${response.status}). Poll until the job is completed before requesting the URL.`,
+      )
+    }
+
+    // The job's `unsigned_urls` require the OpenRouter `Authorization`
+    // header (verified live: plain GET returns 401), so they can't be
+    // handed to a browser <video> tag. Download the content server-side and
+    // return a data URL instead — same policy as the OpenAI video adapter.
+    // Fetched directly rather than via the SDK's `getVideoContent`, whose
+    // response matcher (as of @openrouter/sdk 0.12.35) only accepts
+    // `application/octet-stream` while the live endpoint serves `video/mp4`.
+    const doFetch = this.clientConfig.fetch ?? globalThis.fetch
+    const contentResponse = await doFetch(contentUrl, {
+      headers: { Authorization: `Bearer ${this.clientConfig.apiKey}` },
+    })
+    if (!contentResponse.ok) {
+      throw new Error(
+        `openrouter: failed to download video content for job ${jobId}: HTTP ${contentResponse.status}`,
+      )
+    }
+    const buffer = await contentResponse.arrayBuffer()
+    warnIfLargeMediaBuffer(buffer.byteLength)
+    const base64 = arrayBufferToBase64(buffer)
+    const mimeType = contentResponse.headers.get('content-type') || 'video/mp4'
+
+    const usage = buildVideoUsage(response.usage)
+    return {
+      jobId,
+      url: `data:${mimeType};base64,${base64}`,
+      ...(usage ? { usage } : {}),
+    }
+  }
+}
+
+/**
+ * Creates an OpenRouter video adapter with an explicit API key.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ *
+ * @example
+ * ```typescript
+ * const adapter = createOpenRouterVideo('bytedance/seedance-2.0', 'your-api-key')
+ *
+ * const { jobId } = await generateVideo({
+ *   adapter,
+ *   prompt: 'A beautiful sunset over the ocean',
+ * })
+ * ```
+ */
+export function createOpenRouterVideo<TModel extends OpenRouterVideoModel>(
+  model: TModel,
+  apiKey: string,
+  config?: Omit<OpenRouterVideoConfig, 'apiKey'>,
+): OpenRouterVideoAdapter<TModel> {
+  return new OpenRouterVideoAdapter({ apiKey, ...config }, model)
+}
+
+/**
+ * Creates an OpenRouter video adapter using the `OPENROUTER_API_KEY`
+ * environment variable.
+ *
+ * @experimental Video generation is an experimental feature and may change.
+ *
+ * @example
+ * ```typescript
+ * const adapter = openRouterVideo('google/veo-3.1')
+ *
+ * const { jobId } = await generateVideo({
+ *   adapter,
+ *   prompt: 'A cat playing piano in a jazz bar',
+ * })
+ *
+ * const status = await getVideoJobStatus({ adapter, jobId })
+ * ```
+ */
+export function openRouterVideo<TModel extends OpenRouterVideoModel>(
+  model: TModel,
+  config?: Omit<OpenRouterVideoConfig, 'apiKey'>,
+): OpenRouterVideoAdapter<TModel> {
+  const apiKey = getOpenRouterApiKeyFromEnv()
+  return createOpenRouterVideo(model, apiKey, config)
+}
diff --git a/packages/ai-openrouter/src/image/image-provider-options.ts b/packages/ai-openrouter/src/image/image-provider-options.ts
index 3c4c00a4a..1758761df 100644
--- a/packages/ai-openrouter/src/image/image-provider-options.ts
+++ b/packages/ai-openrouter/src/image/image-provider-options.ts
@@ -9,6 +9,14 @@ export interface OpenRouterImageProviderOptions {
    * '1K' = 1024x1024, '2K' = 2048x2048, '4K' = 4096x4096
    */
   image_size?: '1K' | '2K' | '4K'
+  /**
+   * Image-to-image influence (0.0–1.0): how strongly the input image
+   * constrains the output. Lower values stay closer to the input; higher
+   * values give the model more freedom. Only meaningful for
+   * image-to-image-capable models that document `image_config.strength`
+   * (e.g. Recraft) — other providers ignore it.
+   */
+  strength?: number
 }
 
 /**
@@ -26,15 +34,15 @@ export type OpenRouterImageModelProviderOptionsByName = {
 export type OpenRouterImageModelSizeByName = {
   [K in (typeof OPENROUTER_IMAGE_MODELS)[number]]:
     | '1024x1024' // "1:1"
-    | '832×1248' // "2:3"
-    | '1248×832' // "3:2"
-    | '864×1184' // "3:4"
-    | '1184×864' // "4:3"
-    | '896×1152' // "4:5"
-    | '1152×896' // "5:4"
-    | '768×1344' // "9:16"
-    | '1344×768' // "16:9"
-    | '1536×672' // "21:9"
+    | '832x1248' // "2:3"
+    | '1248x832' // "3:2"
+    | '864x1184' // "3:4"
+    | '1184x864' // "4:3"
+    | '896x1152' // "4:5"
+    | '1152x896' // "5:4"
+    | '768x1344' // "9:16"
+    | '1344x768' // "16:9"
+    | '1536x672' // "21:9"
 }
 
 /**
diff --git a/packages/ai-openrouter/src/index.ts b/packages/ai-openrouter/src/index.ts
index aeebd5c64..eabc61421 100644
--- a/packages/ai-openrouter/src/index.ts
+++ b/packages/ai-openrouter/src/index.ts
@@ -41,6 +41,21 @@ export type {
   OpenRouterImageModelSizeByName,
 } from './image/image-provider-options'
 
+// Video adapter - for async video generation (POST /api/v1/videos)
+export {
+  OpenRouterVideoAdapter,
+  createOpenRouterVideo,
+  openRouterVideo,
+  type OpenRouterVideoConfig,
+} from './adapters/video'
+export type {
+  OpenRouterVideoModel,
+  OpenRouterVideoProviderOptions,
+  OpenRouterVideoModelProviderOptionsByName,
+  OpenRouterVideoModelSizeByName,
+  OpenRouterVideoModelInputModalitiesByName,
+} from './video/video-provider-options'
+
 // ============================================================================
 // Type Exports
 // ============================================================================
diff --git a/packages/ai-openrouter/src/model-meta.ts b/packages/ai-openrouter/src/model-meta.ts
index 42122cd2c..5ca813ea1 100644
--- a/packages/ai-openrouter/src/model-meta.ts
+++ b/packages/ai-openrouter/src/model-meta.ts
@@ -15635,7 +15635,260 @@ export type OpenRouterChatModelToolCapabilitiesByName = {
     'web_fetch',
   ]
 }
-
+export const OPENROUTER_VIDEO_MODELS = [
+  'alibaba/wan-2.6',
+  'alibaba/wan-2.7',
+  'bytedance/seedance-1-5-pro',
+  'bytedance/seedance-2.0',
+  'bytedance/seedance-2.0-fast',
+  'google/veo-3.1',
+  'google/veo-3.1-fast',
+  'google/veo-3.1-lite',
+  'kwaivgi/kling-v3.0-pro',
+  'kwaivgi/kling-v3.0-std',
+  'kwaivgi/kling-video-o1',
+  'minimax/hailuo-2.3',
+  'openai/sora-2-pro',
+  'x-ai/grok-imagine-video',
+] as const
+export const OPENROUTER_VIDEO_MODEL_META = {
+  'alibaba/wan-2.6': {
+    name: 'Alibaba: Wan 2.6',
+    durations: [5, 10],
+    resolutions: ['720p', '1080p'],
+    aspectRatios: ['16:9', '9:16'],
+    frameImages: ['first_frame'],
+    sizes: ['1280x720', '1080x1920', '720x1280', '1920x1080'],
+    generateAudio: true,
+    seed: true,
+  },
+  'alibaba/wan-2.7': {
+    name: 'Alibaba: Wan 2.7',
+    durations: [2, 3, 4, 5, 6, 7, 8, 9, 10],
+    resolutions: ['720p', '1080p'],
+    aspectRatios: ['16:9', '9:16', '1:1', '4:3', '3:4'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '1280x720',
+      '720x1280',
+      '1920x1080',
+      '1080x1920',
+      '720x720',
+      '1080x1080',
+      '960x720',
+      '720x960',
+      '1440x1080',
+      '1080x1440',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'bytedance/seedance-1-5-pro': {
+    name: 'ByteDance: Seedance 1.5 Pro',
+    durations: [4, 5, 6, 7, 8, 9, 10, 11, 12],
+    resolutions: ['480p', '720p', '1080p'],
+    aspectRatios: ['1:1', '3:4', '9:16', '9:21', '4:3', '16:9', '21:9'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '480x480',
+      '480x640',
+      '480x854',
+      '480x1120',
+      '640x480',
+      '720x720',
+      '720x960',
+      '720x1280',
+      '720x1680',
+      '854x480',
+      '960x720',
+      '1080x1080',
+      '1080x1440',
+      '1080x1920',
+      '1080x2520',
+      '1120x480',
+      '1280x720',
+      '1440x1080',
+      '1680x720',
+      '1920x1080',
+      '2520x1080',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'bytedance/seedance-2.0': {
+    name: 'ByteDance: Seedance 2.0',
+    durations: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    resolutions: ['480p', '720p', '1080p'],
+    aspectRatios: ['1:1', '3:4', '9:16', '4:3', '16:9', '21:9', '9:21'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '480x480',
+      '480x640',
+      '480x854',
+      '640x480',
+      '854x480',
+      '1120x480',
+      '720x720',
+      '720x960',
+      '720x1280',
+      '720x1680',
+      '960x720',
+      '1280x720',
+      '1680x720',
+      '1080x1080',
+      '1080x1440',
+      '1080x1920',
+      '1440x1080',
+      '1920x1080',
+      '2520x1080',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'bytedance/seedance-2.0-fast': {
+    name: 'ByteDance: Seedance 2.0 Fast',
+    durations: [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    resolutions: ['480p', '720p'],
+    aspectRatios: ['1:1', '3:4', '9:16', '4:3', '16:9', '21:9', '9:21'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '480x480',
+      '480x640',
+      '480x854',
+      '640x480',
+      '854x480',
+      '1120x480',
+      '720x720',
+      '720x960',
+      '720x1280',
+      '720x1680',
+      '960x720',
+      '1280x720',
+      '1680x720',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'google/veo-3.1': {
+    name: 'Google: Veo 3.1',
+    durations: [4, 6, 8],
+    resolutions: ['720p', '1080p', '4K'],
+    aspectRatios: ['16:9', '9:16'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '1280x720',
+      '1080x1920',
+      '1920x1080',
+      '720x1280',
+      '3840x2160',
+      '2160x3840',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'google/veo-3.1-fast': {
+    name: 'Google: Veo 3.1 Fast',
+    durations: [4, 6, 8],
+    resolutions: ['720p', '1080p', '4K'],
+    aspectRatios: ['16:9', '9:16'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: [
+      '1280x720',
+      '1080x1920',
+      '1920x1080',
+      '720x1280',
+      '3840x2160',
+      '2160x3840',
+    ],
+    generateAudio: true,
+    seed: true,
+  },
+  'google/veo-3.1-lite': {
+    name: 'Google: Veo 3.1 Lite',
+    durations: [8, 4, 6],
+    resolutions: ['720p', '1080p'],
+    aspectRatios: ['16:9', '9:16'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: ['1280x720', '720x1280', '1920x1080', '1080x1920'],
+    generateAudio: true,
+    seed: true,
+  },
+  'kwaivgi/kling-v3.0-pro': {
+    name: 'Kling: Video v3.0 Pro',
+    durations: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    resolutions: ['720p'],
+    aspectRatios: ['16:9', '9:16', '1:1'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: ['1280x720', '720x1280', '720x720'],
+    generateAudio: true,
+    seed: false,
+  },
+  'kwaivgi/kling-v3.0-std': {
+    name: 'Kling: Video v3.0 Standard',
+    durations: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    resolutions: ['720p'],
+    aspectRatios: ['16:9', '9:16', '1:1'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: ['1280x720', '720x1280', '720x720'],
+    generateAudio: true,
+    seed: false,
+  },
+  'kwaivgi/kling-video-o1': {
+    name: 'Kling: Video O1',
+    durations: [5, 10],
+    resolutions: ['720p'],
+    aspectRatios: ['16:9', '9:16', '1:1'],
+    frameImages: ['first_frame', 'last_frame'],
+    sizes: ['1280x720', '720x1280', '720x720'],
+    generateAudio: true,
+    seed: false,
+  },
+  'minimax/hailuo-2.3': {
+    name: 'MiniMax: Hailuo 2.3',
+    durations: [6, 10],
+    resolutions: ['1080p'],
+    aspectRatios: ['16:9'],
+    frameImages: ['first_frame'],
+    sizes: ['1920x1080'],
+    generateAudio: false,
+    seed: null,
+  },
+  'openai/sora-2-pro': {
+    name: 'OpenAI: Sora 2 Pro',
+    durations: [4, 8, 12, 16, 20],
+    resolutions: ['720p', '1080p'],
+    aspectRatios: ['16:9', '9:16'],
+    frameImages: null,
+    sizes: ['1280x720', '1080x1920', '1920x1080', '720x1280'],
+    generateAudio: true,
+    seed: false,
+  },
+  'x-ai/grok-imagine-video': {
+    name: 'xAI: Grok Imagine Video',
+    durations: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    resolutions: ['480p', '720p'],
+    aspectRatios: ['16:9', '9:16', '1:1', '4:3', '3:4', '3:2', '2:3'],
+    frameImages: ['first_frame'],
+    sizes: [
+      '854x480',
+      '1280x720',
+      '480x854',
+      '720x1280',
+      '480x480',
+      '720x720',
+      '640x480',
+      '960x720',
+      '480x640',
+      '720x960',
+      '720x480',
+      '1080x720',
+      '480x720',
+      '720x1080',
+    ],
+    generateAudio: null,
+    seed: null,
+  },
+} as const
 export const OPENROUTER_IMAGE_MODELS = [
   GOOGLE_GEMINI_2_5_FLASH_IMAGE.id,
   GOOGLE_GEMINI_3_PRO_IMAGE_PREVIEW.id,
diff --git a/packages/ai-openrouter/src/video/video-provider-options.ts b/packages/ai-openrouter/src/video/video-provider-options.ts
new file mode 100644
index 000000000..abb0b20e8
--- /dev/null
+++ b/packages/ai-openrouter/src/video/video-provider-options.ts
@@ -0,0 +1,157 @@
+import { OPENROUTER_VIDEO_MODEL_META } from '../model-meta'
+import type { VideoGenerationRequestProvider } from '@openrouter/sdk/models'
+import type { OPENROUTER_VIDEO_MODELS } from '../model-meta'
+
+export type OpenRouterVideoModel = (typeof OPENROUTER_VIDEO_MODELS)[number]
+
+type VideoMeta = typeof OPENROUTER_VIDEO_MODEL_META
+
+/**
+ * Element type of a capability array from the generated video model meta,
+ * falling back to `TFallback` when the API reported `null` (capabilities
+ * unknown) for that model.
+ */
+type ElementOf<T, TFallback> = T extends ReadonlyArray<infer U> ? U : TFallback
+
+/**
+ * Runtime view of one `OPENROUTER_VIDEO_MODEL_META` entry, widened from the
+ * generated literal types so validators can work with any model id.
+ */
+export interface OpenRouterVideoModelMeta {
+  name: string
+  durations: ReadonlyArray<number> | null
+  resolutions: ReadonlyArray<string> | null
+  aspectRatios: ReadonlyArray<string> | null
+  frameImages: ReadonlyArray<string> | null
+  sizes: ReadonlyArray<string> | null
+  generateAudio: boolean | null
+  seed: boolean | null
+}
+
+const VIDEO_MODEL_META: Record<string, OpenRouterVideoModelMeta> =
+  OPENROUTER_VIDEO_MODEL_META
+
+/** Capability metadata for a video model, or undefined when unknown. */
+export function getVideoModelMeta(
+  model: string,
+): OpenRouterVideoModelMeta | undefined {
+  return VIDEO_MODEL_META[model]
+}
+
+/**
+ * Options common to every OpenRouter video model.
+ */
+export interface OpenRouterVideoCommonOptions {
+  /**
+   * HTTPS URL to receive a webhook notification when the video generation
+   * job completes (events like `video.generation.completed` /
+   * `video.generation.failed`, signed with HMAC-SHA256). Overrides the
+   * workspace-level default callback URL if set.
+   */
+  callbackUrl?: string
+  /**
+   * Provider-specific passthrough configuration, keyed by provider slug.
+   * The options for the matched provider are spread into the upstream
+   * request body.
+   */
+  provider?: VideoGenerationRequestProvider
+}
+
+/**
+ * Base (widest) video generation options for OpenRouter's
+ * `POST /api/v1/videos` API. Per-model narrowing happens in
+ * {@link OpenRouterVideoModelProviderOptionsByName}.
+ */
+export interface OpenRouterVideoProviderOptions extends OpenRouterVideoCommonOptions {
+  /** Resolution of the generated video (e.g. '720p', '1080p'). */
+  resolution?: string
+  /** Aspect ratio of the generated video (e.g. '16:9', '9:16'). */
+  aspectRatio?: string
+  /**
+   * Deterministic sampling seed. Repeated requests with the same seed and
+   * parameters should return the same result (not guaranteed by all
+   * providers).
+   */
+  seed?: number
+  /**
+   * Whether to generate audio alongside the video. Defaults to the
+   * endpoint's `generate_audio` capability flag.
+   */
+  generateAudio?: boolean
+}
+
+/**
+ * Provider options narrowed to one model's capabilities from the generated
+ * `OPENROUTER_VIDEO_MODEL_META`: `resolution` / `aspectRatio` become literal
+ * unions of the supported values, and `seed` / `generateAudio` are omitted
+ * for models whose metadata reports them unsupported (`false`; `null` means
+ * unknown and stays permissive).
+ */
+export type OpenRouterVideoProviderOptionsFor<TModel extends string> =
+  OpenRouterVideoCommonOptions &
+    (TModel extends keyof VideoMeta
+      ? {
+          resolution?: ElementOf<VideoMeta[TModel]['resolutions'], string>
+          aspectRatio?: ElementOf<VideoMeta[TModel]['aspectRatios'], string>
+        } & (VideoMeta[TModel]['seed'] extends false
+          ? unknown
+          : { seed?: number }) &
+          (VideoMeta[TModel]['generateAudio'] extends false
+            ? unknown
+            : { generateAudio?: boolean })
+      : OpenRouterVideoProviderOptions)
+
+/** Per-model provider options for video generation. */
+export type OpenRouterVideoModelProviderOptionsByName = {
+  [K in OpenRouterVideoModel]: OpenRouterVideoProviderOptionsFor<K>
+}
+
+/**
+ * Per-model `size` values ('WIDTHxHEIGHT'), from the generated meta.
+ * `size` is interchangeable with `resolution` + `aspectRatio`.
+ */
+export type OpenRouterVideoModelSizeByName = {
+  [K in OpenRouterVideoModel]: ElementOf<VideoMeta[K]['sizes'], string>
+}
+
+/**
+ * Per-model prompt input modalities. Every model on the dedicated video API
+ * accepts image conditioning — `frame_images` (first/last frame) and/or
+ * `input_references` (reference-guided generation).
+ */
+export type OpenRouterVideoModelInputModalitiesByName = {
+  [K in OpenRouterVideoModel]: readonly ['image']
+}
+
+/**
+ * Validate a requested size against the model's supported sizes. No-op when
+ * the model (or its size list) is unknown — OpenRouter then validates
+ * server-side.
+ */
+export function validateVideoSize(
+  model: string,
+  size: string | undefined,
+): void {
+  if (!size) return
+  const sizes = VIDEO_MODEL_META[model]?.sizes
+  if (!sizes || sizes.includes(size)) return
+  throw new Error(
+    `openrouter: model ${model} does not support size '${size}'. Supported sizes: ${sizes.join(', ')}.`,
+  )
+}
+
+/**
+ * Validate a requested duration (seconds) against the model's supported
+ * durations. No-op when the model (or its duration list) is unknown.
+ */
+export function validateVideoDuration(
+  model: string,
+  duration: number | undefined,
+): void {
+  if (duration === undefined) return
+  const durations = VIDEO_MODEL_META[model]?.durations
+  if (!durations || durations.includes(duration)) return
+  throw new Error(
+    `openrouter: model ${model} does not support duration ${duration}s. Supported durations: ${durations.join(', ')}s.`,
+  )
+}
diff --git a/packages/ai-openrouter/tests/image-adapter.test.ts b/packages/ai-openrouter/tests/image-adapter.test.ts
index 4f078fd33..2cd605001 100644
--- a/packages/ai-openrouter/tests/image-adapter.test.ts
+++ b/packages/ai-openrouter/tests/image-adapter.test.ts
@@ -111,10 +111,28 @@ describe('OpenRouter Image Adapter', () => {
     })
   })
 
-  it('generates multiple images', async () => {
+  it('throws for numberOfImages > 1 (the pathway returns exactly one image)', async () => {
+    mockSend = vi.fn()
+
+    const adapter = createAdapter()
+
+    // Verified live: OpenRouter's chat-completions image pathway ignores any
+    // count key in image_config and always returns one image — passing the
+    // count through would silently under-deliver.
+    await expect(
+      adapter.generateImages({
+        model: 'google/gemini-2.5-flash-image',
+        prompt: 'A cute robot mascot',
+        numberOfImages: 2,
+        logger: testLogger,
+      }),
+    ).rejects.toThrow(/one image per request/)
+    expect(mockSend).not.toHaveBeenCalled()
+  })
+
+  it('accepts numberOfImages: 1 without sending a count key', async () => {
     const mockResponse = createMockImageResponse([
       { url: 'https://example.com/image1.png' },
-      { url: 'https://example.com/image2.png' },
     ])
 
     mockSend = vi.fn().mockResolvedValueOnce(mockResponse)
@@ -124,19 +142,14 @@ describe('OpenRouter Image Adapter', () => {
     const result = await adapter.generateImages({
       model: 'google/gemini-2.5-flash-image',
       prompt: 'A cute robot mascot',
-      numberOfImages: 2,
+      numberOfImages: 1,
       logger: testLogger,
     })
 
     const callArgs = mockSend.mock.calls[0]![0].chatRequest
-    expect(callArgs.imageConfig).toMatchObject({
-      numberOfImages: 2,
-    })
+    expect(callArgs.imageConfig).not.toHaveProperty('numberOfImages')
     expect(callArgs.imageConfig).not.toHaveProperty('n')
-
-    expect(result.images).toHaveLength(2)
-    expect(result.images[0]!.url).toBe('https://example.com/image1.png')
-    expect(result.images[1]!.url).toBe('https://example.com/image2.png')
+    expect(result.images).toHaveLength(1)
   })
 
   it('handles base64 image responses', async () => {
@@ -205,6 +218,70 @@ describe('OpenRouter Image Adapter', () => {
     })
   })
 
+  it("normalizes the '×' size separator before the aspect-ratio lookup", async () => {
+    const mockResponse = createMockImageResponse([
+      { url: 'https://example.com/image.png' },
+    ])
+
+    mockSend = vi.fn().mockResolvedValueOnce(mockResponse)
+
+    const adapter = createAdapter()
+
+    await adapter.generateImages({
+      model: 'google/gemini-2.5-flash-image',
+      prompt: 'A portrait image',
+      size: '832×1248',
+      logger: testLogger,
+    })
+
+    const callArgs = mockSend.mock.calls[0]![0].chatRequest
+    expect(callArgs.imageConfig).toMatchObject({
+      aspect_ratio: '2:3',
+    })
+  })
+
+  it('throws for sizes outside the aspect-ratio table instead of dropping them', async () => {
+    mockSend = vi.fn()
+
+    const adapter = createAdapter()
+
+    await expect(
+      adapter.generateImages({
+        model: 'google/gemini-2.5-flash-image',
+        prompt: 'A weirdly sized image',
+        size: '512x512',
+        logger: testLogger,
+      }),
+    ).rejects.toThrow(/unsupported image size '512x512'/)
+    expect(mockSend).not.toHaveBeenCalled()
+  })
+
+  it('passes strength through to image_config', async () => {
+    const mockResponse = createMockImageResponse([
+      { url: 'https://example.com/image.png' },
+    ])
+
+    mockSend = vi.fn().mockResolvedValueOnce(mockResponse)
+
+    const adapter = createAdapter()
+
+    await adapter.generateImages({
+      model: 'google/gemini-2.5-flash-image',
+      prompt: [
+        {
+          type: 'image',
+          source: { type: 'url', value: 'https://example.com/source.png' },
+        },
+        { type: 'text', content: 'Repaint in watercolor' },
+      ],
+      modelOptions: { strength: 0.35 },
+      logger: testLogger,
+    })
+
+    const callArgs = mockSend.mock.calls[0]![0].chatRequest
+    expect(callArgs.imageConfig).toMatchObject({ strength: 0.35 })
+  })
+
   it('propagates SDK errors without rewrapping', async () => {
     mockSend = vi.fn().mockRejectedValueOnce(new Error('Model not found'))
 
diff --git a/packages/ai-openrouter/tests/video-adapter.test.ts b/packages/ai-openrouter/tests/video-adapter.test.ts
new file mode 100644
index 000000000..3ba440438
--- /dev/null
+++ b/packages/ai-openrouter/tests/video-adapter.test.ts
@@ -0,0 +1,488 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { resolveDebugOption } from '@tanstack/ai/adapter-internals'
+import { createOpenRouterVideo } from '../src/adapters/video'
+
+const testLogger = resolveDebugOption(false)
+
+// Declare mocks at module level
+let mockGenerate: any
+let mockGetGeneration: any
+
+// Mock the OpenRouter SDK
+vi.mock('@openrouter/sdk', () => {
+  return {
+    OpenRouter: class {
+      videoGeneration = {
+        generate: (...args: Array<unknown>) => mockGenerate(...args),
+        getGeneration: (...args: Array<unknown>) => mockGetGeneration(...args),
+      }
+    },
+  }
+})
+
+/**
+ * Injectable fetch for the content download path, resolving to a video
+ * response with the given bytes. The adapter takes it via config so tests
+ * never touch globalThis.fetch.
+ */
+function fetchReturning(bytes: Uint8Array) {
+  return vi.fn().mockResolvedValue(
+    new Response(bytes.slice().buffer, {
+      status: 200,
+      headers: { 'content-type': 'video/mp4' },
+    }),
+  )
+}
+
+const createAdapter = () =>
+  createOpenRouterVideo('bytedance/seedance-2.0', 'test-key')
+
+function createMockJobResponse(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'job-123',
+    pollingUrl: 'https://openrouter.ai/api/v1/videos/job-123',
+    status: 'pending',
+    ...overrides,
+  }
+}
+
+describe('OpenRouter Video Adapter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('createVideoJob', () => {
+    it('submits a text-to-video request and returns the job id', async () => {
+      mockGenerate = vi.fn().mockResolvedValueOnce(createMockJobResponse())
+
+      const adapter = createAdapter()
+      const result = await adapter.createVideoJob({
+        model: 'bytedance/seedance-2.0',
+        prompt: 'A red panda surfing a wave at golden hour',
+        logger: testLogger,
+      })
+
+      expect(mockGenerate).toHaveBeenCalledTimes(1)
+      const request = mockGenerate.mock.calls[0]![0].videoGenerationRequest
+      expect(request).toEqual({
+        model: 'bytedance/seedance-2.0',
+        prompt: 'A red panda surfing a wave at golden hour',
+      })
+      expect(result).toEqual({
+        jobId: 'job-123',
+        model: 'bytedance/seedance-2.0',
+      })
+    })
+
+    it('passes size, duration, and provider options through', async () => {
+      mockGenerate = vi.fn().mockResolvedValueOnce(createMockJobResponse())
+
+      const adapter = createAdapter()
+      await adapter.createVideoJob({
+        model: 'bytedance/seedance-2.0',
+        prompt: 'A drone shot over a fjord',
+        size: '1280x720',
+        duration: 8,
+        modelOptions: {
+          seed: 42,
+          generateAudio: true,
+          callbackUrl: 'https://example.com/webhook',
+          resolution: '720p',
+          aspectRatio: '16:9',
+          provider: { options: { openai: { quality: 'high' } } },
+        },
+        logger: testLogger,
+      })
+
+      const request = mockGenerate.mock.calls[0]![0].videoGenerationRequest
+      expect(request).toMatchObject({
+        model: 'bytedance/seedance-2.0',
+        prompt: 'A drone shot over a fjord',
+        size: '1280x720',
+        duration: 8,
+        seed: 42,
+        generateAudio: true,
+        callbackUrl: 'https://example.com/webhook',
+        resolution: '720p',
+        aspectRatio: '16:9',
+        provider: { options: { openai: { quality: 'high' } } },
+      })
+    })
+
+    it('throws for a size the model does not support', async () => {
+      mockGenerate = vi.fn()
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: 'A timelapse of clouds',
+          size: '333x333',
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/does not support size '333x333'/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('throws for a duration the model does not support', async () => {
+      mockGenerate = vi.fn()
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: 'A timelapse of clouds',
+          duration: 99,
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/does not support duration 99s/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('maps start_frame / end_frame roles onto frame_images and references onto input_references', async () => {
+      mockGenerate = vi.fn().mockResolvedValueOnce(createMockJobResponse())
+
+      const adapter = createAdapter()
+      await adapter.createVideoJob({
+        model: 'bytedance/seedance-2.0',
+        prompt: [
+          { type: 'text', content: 'Animate between these two stills' },
+          {
+            type: 'image',
+            source: { type: 'url', value: 'https://example.com/first.png' },
+            metadata: { role: 'start_frame' },
+          },
+          {
+            type: 'image',
+            source: { type: 'data', value: 'bGFzdA==', mimeType: 'image/png' },
+            metadata: { role: 'end_frame' },
+          },
+          {
+            type: 'image',
+            source: { type: 'url', value: 'https://example.com/style.png' },
+            metadata: { role: 'reference' },
+          },
+          {
+            type: 'image',
+            source: { type: 'url', value: 'https://example.com/hero.png' },
+            metadata: { role: 'character' },
+          },
+        ],
+        logger: testLogger,
+      })
+
+      const request = mockGenerate.mock.calls[0]![0].videoGenerationRequest
+      expect(request.prompt).toBe('Animate between these two stills')
+      expect(request.frameImages).toEqual([
+        {
+          type: 'image_url',
+          imageUrl: { url: 'https://example.com/first.png' },
+          frameType: 'first_frame',
+        },
+        {
+          type: 'image_url',
+          imageUrl: { url: 'data:image/png;base64,bGFzdA==' },
+          frameType: 'last_frame',
+        },
+      ])
+      expect(request.inputReferences).toEqual([
+        {
+          type: 'image_url',
+          imageUrl: { url: 'https://example.com/style.png' },
+        },
+        {
+          type: 'image_url',
+          imageUrl: { url: 'https://example.com/hero.png' },
+        },
+      ])
+    })
+
+    it('treats an unroled image as the start frame', async () => {
+      mockGenerate = vi.fn().mockResolvedValueOnce(createMockJobResponse())
+
+      const adapter = createAdapter()
+      await adapter.createVideoJob({
+        model: 'bytedance/seedance-2.0',
+        prompt: [
+          { type: 'text', content: 'Bring this photo to life' },
+          {
+            type: 'image',
+            source: { type: 'url', value: 'https://example.com/photo.png' },
+          },
+        ],
+        logger: testLogger,
+      })
+
+      const request = mockGenerate.mock.calls[0]![0].videoGenerationRequest
+      expect(request.frameImages).toEqual([
+        {
+          type: 'image_url',
+          imageUrl: { url: 'https://example.com/photo.png' },
+          frameType: 'first_frame',
+        },
+      ])
+      expect(request.inputReferences).toBeUndefined()
+    })
+
+    it('throws when two images compete for the start frame', async () => {
+      mockGenerate = vi.fn()
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: [
+            {
+              type: 'image',
+              source: { type: 'url', value: 'https://example.com/a.png' },
+            },
+            {
+              type: 'image',
+              source: { type: 'url', value: 'https://example.com/b.png' },
+              metadata: { role: 'start_frame' },
+            },
+          ],
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/at most one start-frame image/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('throws for mask / control roles (no video routing)', async () => {
+      mockGenerate = vi.fn()
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: [
+            {
+              type: 'image',
+              source: { type: 'url', value: 'https://example.com/mask.png' },
+              metadata: { role: 'mask' },
+            },
+          ],
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/role === 'mask' is not supported/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('throws for an end_frame on a model that only supports first_frame', async () => {
+      mockGenerate = vi.fn()
+
+      // minimax/hailuo-2.3 reports supported_frame_images: ['first_frame']
+      const adapter = createOpenRouterVideo('minimax/hailuo-2.3', 'test-key')
+      await expect(
+        adapter.createVideoJob({
+          model: 'minimax/hailuo-2.3',
+          prompt: [
+            { type: 'text', content: 'Fade to this still' },
+            {
+              type: 'image',
+              source: { type: 'url', value: 'https://example.com/last.png' },
+              metadata: { role: 'end_frame' },
+            },
+          ],
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/does not accept an end-frame image/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('throws for video / audio prompt parts', async () => {
+      mockGenerate = vi.fn()
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: [
+            { type: 'text', content: 'Test' },
+            {
+              type: 'video',
+              source: { type: 'url', value: 'https://example.com/v.mp4' },
+            },
+          ],
+          logger: testLogger,
+        }),
+      ).rejects.toThrow(/does not support video prompt parts/)
+      expect(mockGenerate).not.toHaveBeenCalled()
+    })
+
+    it('propagates SDK errors without rewrapping', async () => {
+      mockGenerate = vi
+        .fn()
+        .mockRejectedValueOnce(new Error('Payment required'))
+
+      const adapter = createAdapter()
+      await expect(
+        adapter.createVideoJob({
+          model: 'bytedance/seedance-2.0',
+          prompt: 'A scene',
+          logger: testLogger,
+        }),
+      ).rejects.toThrowError(new Error('Payment required'))
+    })
+  })
+
+  describe('getVideoStatus', () => {
+    it.each([
+      ['pending', 'pending'],
+      ['in_progress', 'processing'],
+      ['completed', 'completed'],
+      ['failed', 'failed'],
+      ['cancelled', 'failed'],
+      ['expired', 'failed'],
+    ] as const)('maps API status %s to %s', async (apiStatus, expected) => {
+      mockGetGeneration = vi
+        .fn()
+        .mockResolvedValueOnce(createMockJobResponse({ status: apiStatus }))
+
+      const adapter = createAdapter()
+      const status = await adapter.getVideoStatus('job-123')
+
+      expect(mockGetGeneration).toHaveBeenCalledWith({ jobId: 'job-123' })
+      expect(status).toMatchObject({ jobId: 'job-123', status: expected })
+    })
+
+    it('surfaces the job error message on failure', async () => {
+      mockGetGeneration = vi.fn().mockResolvedValueOnce(
+        createMockJobResponse({
+          status: 'failed',
+          error: 'Content policy violation',
+        }),
+      )
+
+      const adapter = createAdapter()
+      const status = await adapter.getVideoStatus('job-123')
+
+      expect(status).toEqual({
+        jobId: 'job-123',
+        status: 'failed',
+        error: 'Content policy violation',
+      })
+    })
+  })
+
+  describe('getVideoUrl', () => {
+    const CONTENT_URL =
+      'https://openrouter.ai/api/v1/videos/job-123/content?index=0'
+
+    it('downloads the content into a data URL with gateway-reported cost', async () => {
+      mockGetGeneration = vi.fn().mockResolvedValueOnce(
+        createMockJobResponse({
+          status: 'completed',
+          unsignedUrls: [CONTENT_URL],
+          usage: { cost: 0.45 },
+        }),
+      )
+      const bytes = new TextEncoder().encode('mp4-bytes')
+      const mockFetch = fetchReturning(bytes)
+
+      const adapter = createOpenRouterVideo(
+        'bytedance/seedance-2.0',
+        'test-key',
+        {
+          fetch: mockFetch,
+        },
+      )
+      const result = await adapter.getVideoUrl('job-123')
+
+      // The unsigned URL is fetched with the Authorization header — it 401s
+      // without one, so it can't be returned to the caller as-is.
+      expect(mockFetch).toHaveBeenCalledWith(CONTENT_URL, {
+        headers: { Authorization: 'Bearer test-key' },
+      })
+      expect(result.url).toBe(
+        `data:video/mp4;base64,${Buffer.from(bytes).toString('base64')}`,
+      )
+      expect(result.jobId).toBe('job-123')
+      expect(result.usage).toMatchObject({ cost: 0.45 })
+    })
+
+    it('omits usage when the job reports no cost', async () => {
+      mockGetGeneration = vi.fn().mockResolvedValueOnce(
+        createMockJobResponse({
+          status: 'completed',
+          unsignedUrls: [CONTENT_URL],
+        }),
+      )
+
+      const adapter = createOpenRouterVideo(
+        'bytedance/seedance-2.0',
+        'test-key',
+        {
+          fetch: fetchReturning(new Uint8Array([1, 2, 3])),
+        },
+      )
+      const result = await adapter.getVideoUrl('job-123')
+
+      expect(result.usage).toBeUndefined()
+    })
+
+    it('throws when the content download fails', async () => {
+      mockGetGeneration = vi.fn().mockResolvedValueOnce(
+        createMockJobResponse({
+          status: 'completed',
+          unsignedUrls: [CONTENT_URL],
+        }),
+      )
+      const mockFetch = vi
+        .fn()
+        .mockResolvedValue(new Response(null, { status: 401 }))
+
+      const adapter = createOpenRouterVideo(
+        'bytedance/seedance-2.0',
+        'test-key',
+        {
+          fetch: mockFetch,
+        },
+      )
+      await expect(adapter.getVideoUrl('job-123')).rejects.toThrow(
+        /failed to download video content for job job-123: HTTP 401/,
+      )
+    })
+
+    it('throws when the job failed', async () => {
+      mockGetGeneration = vi.fn().mockResolvedValueOnce(
+        createMockJobResponse({
+          status: 'failed',
+          error: 'Provider rejected the prompt',
+        }),
+      )
+      const mockFetch = vi.fn()
+
+      const adapter = createOpenRouterVideo(
+        'bytedance/seedance-2.0',
+        'test-key',
+        {
+          fetch: mockFetch,
+        },
+      )
+      await expect(adapter.getVideoUrl('job-123')).rejects.toThrow(
+        /job-123 failed: Provider rejected the prompt/,
+      )
+      expect(mockFetch).not.toHaveBeenCalled()
+    })
+
+    it('throws when the job has no downloadable content yet', async () => {
+      mockGetGeneration = vi
+        .fn()
+        .mockResolvedValueOnce(createMockJobResponse({ status: 'in_progress' }))
+      const mockFetch = vi.fn()
+
+      const adapter = createOpenRouterVideo(
+        'bytedance/seedance-2.0',
+        'test-key',
+        {
+          fetch: mockFetch,
+        },
+      )
+      await expect(adapter.getVideoUrl('job-123')).rejects.toThrow(
+        /no downloadable content yet/,
+      )
+      expect(mockFetch).not.toHaveBeenCalled()
+    })
+  })
+})
diff --git a/packages/ai/skills/ai-core/media-generation/SKILL.md b/packages/ai/skills/ai-core/media-generation/SKILL.md
index af9d80cf0..88555e629 100644
--- a/packages/ai/skills/ai-core/media-generation/SKILL.md
+++ b/packages/ai/skills/ai-core/media-generation/SKILL.md
@@ -242,7 +242,8 @@ await generateImage({
   ],
 })
 
-// Image-to-video (OpenAI Sora: single input_reference; fal: image_url + optional end_image_url)
+// Image-to-video (OpenAI Sora: single input_reference; fal: image_url + optional
+// end_image_url; OpenRouter: frame_images + input_references)
 import { generateVideo } from '@tanstack/ai'
 import { falVideo } from '@tanstack/ai-fal'
 
@@ -262,25 +263,25 @@ await generateVideo({
 
 **Role hints** (`metadata.role`):
 
-| Role            | Maps to                                                                                               |
-| --------------- | ----------------------------------------------------------------------------------------------------- |
-| `'reference'`   | fal `reference_image_urls`; Gemini multimodal part; positional otherwise                              |
-| `'character'`   | Same as `'reference'`; Veo `referenceImages` slot (planned — no Veo adapter yet)                      |
-| `'mask'`        | OpenAI `mask` (gpt-image-2, gpt-image-1, dall-e-2); fal `mask_url`                                    |
-| `'control'`     | fal `control_image_url` (ControlNet / depth / pose)                                                   |
-| `'start_frame'` | fal `start_image_url` (or the endpoint's field, e.g. `image_url` on Kling i2v); Veo `image` (planned) |
-| `'end_frame'`   | fal `end_image_url` (or e.g. `tail_image_url` / `last_frame_url`); Veo `lastFrame` (planned)          |
+| Role            | Maps to                                                                                                                                          |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `'reference'`   | fal `reference_image_urls`; OpenRouter video `input_references[]`; Gemini multimodal part; positional otherwise                                  |
+| `'character'`   | Same as `'reference'`; Veo `referenceImages` slot (planned — no Veo adapter yet)                                                                 |
+| `'mask'`        | OpenAI `mask` (gpt-image-2, gpt-image-1, dall-e-2); fal `mask_url`                                                                               |
+| `'control'`     | fal `control_image_url` (ControlNet / depth / pose)                                                                                              |
+| `'start_frame'` | fal `start_image_url` (or the endpoint's field, e.g. `image_url` on Kling i2v); OpenRouter `frame_images[]` `first_frame`; Veo `image` (planned) |
+| `'end_frame'`   | fal `end_image_url` (or e.g. `tail_image_url` / `last_frame_url`); OpenRouter `frame_images[]` `last_frame`; Veo `lastFrame` (planned)           |
 
 **Provider support matrix:**
 
-| Provider   | `generateImage` image parts                                                                                                                                                                              | `generateVideo` image parts                                                                                                                                                                        |
-| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| OpenAI     | gpt-image-2 / gpt-image-1 / -mini → `images.edit()` (up to 16). dall-e-2 → edit (1). dall-e-3 throws.                                                                                                    | Sora-2 / -pro → `input_reference` (single). Throws if >1.                                                                                                                                          |
-| Gemini     | Native (gemini-\*-flash-image, "nano-banana") → multimodal `contents`. Imagen throws.                                                                                                                    | No native Veo adapter yet — deferred to a follow-up.                                                                                                                                               |
-| fal        | Per-endpoint field names from a generated map (`pnpm generate:fal-image-fields`). Defaults: 1 input → `image_url`; >1 → `image_urls`; roles → `mask_url` / `control_image_url` / `reference_image_urls`. | Per-endpoint map (e.g. Kling i2v start frame → `image_url`). Defaults: 1 input → `image_url`; `start_frame`/`end_frame` → `start_image_url`/`end_image_url`; `reference` → `reference_image_urls`. |
-| Grok       | grok-imagine models → `/v1/images/edits` JSON endpoint (≤3 sources, addressed by xAI in request order; prompt sent verbatim; mask/control throw). grok-2-image-1212 throws.                              | n/a                                                                                                                                                                                                |
-| OpenRouter | Prompt parts map 1:1 onto multimodal `text` / `image_url` content parts, preserving interleaved order.                                                                                                   | n/a                                                                                                                                                                                                |
-| Anthropic  | n/a (no image generation API).                                                                                                                                                                           | n/a                                                                                                                                                                                                |
+| Provider   | `generateImage` image parts                                                                                                                                                                              | `generateVideo` image parts                                                                                                                                                                                                                                                                    |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| OpenAI     | gpt-image-2 / gpt-image-1 / -mini → `images.edit()` (up to 16). dall-e-2 → edit (1). dall-e-3 throws.                                                                                                    | Sora-2 / -pro → `input_reference` (single). Throws if >1.                                                                                                                                                                                                                                      |
+| Gemini     | Native (gemini-\*-flash-image, "nano-banana") → multimodal `contents`. Imagen throws.                                                                                                                    | No native Veo adapter yet — deferred to a follow-up.                                                                                                                                                                                                                                           |
+| fal        | Per-endpoint field names from a generated map (`pnpm generate:fal-image-fields`). Defaults: 1 input → `image_url`; >1 → `image_urls`; roles → `mask_url` / `control_image_url` / `reference_image_urls`. | Per-endpoint map (e.g. Kling i2v start frame → `image_url`). Defaults: 1 input → `image_url`; `start_frame`/`end_frame` → `start_image_url`/`end_image_url`; `reference` → `reference_image_urls`.                                                                                             |
+| Grok       | grok-imagine models → `/v1/images/edits` JSON endpoint (≤3 sources, addressed by xAI in request order; prompt sent verbatim; mask/control throw). grok-2-image-1212 throws.                              | n/a                                                                                                                                                                                                                                                                                            |
+| OpenRouter | Prompt parts map 1:1 onto multimodal `text` / `image_url` content parts, preserving interleaved order.                                                                                                   | Dedicated async API (`openRouterVideo`): `start_frame`/`end_frame` → `frame_images[]` (`first_frame`/`last_frame`); `reference`/`character` → `input_references[]`; an unroled image defaults to the start frame. Frame roles validated against the model's `supported_frame_images` metadata. |
+| Anthropic  | n/a (no image generation API).                                                                                                                                                                           | n/a                                                                                                                                                                                                                                                                                            |
 
 Video and audio prompt parts follow the same `metadata.role` convention
 for video-to-video and lipsync flows on fal; other providers throw when
@@ -393,7 +394,12 @@ const { generate, result, isLoading } = useTranscription({
 ### 5. Video Generation (Experimental -- async polling)
 
 Video generation uses a jobs/polling architecture. The server creates a job,
-polls for status, and streams updates to the client.
+polls for status, and streams updates to the client. Adapters: `openaiVideo`
+(Sora), `falVideo` (Kling, MiniMax, Hunyuan, …), and `openRouterVideo`
+(OpenRouter's dedicated `POST /api/v1/videos` gateway — Seedance, Veo, Wan,
+Kling, Sora 2 Pro and others through one API key; `getVideoJobStatus()`
+returns the video as a `data:` URL since OpenRouter's download URLs require
+the API key, and surfaces the gateway-reported cost as `usage.cost`).
 
 ```typescript
 import {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3fe7276d9..9c57c611c 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1439,8 +1439,8 @@ importers:
   packages/ai-openrouter:
     dependencies:
       '@openrouter/sdk':
-        specifier: 0.12.35
-        version: 0.12.35
+        specifier: 0.12.79
+        version: 0.12.79
       '@tanstack/ai-utils':
         specifier: workspace:*
         version: link:../ai-utils
@@ -1842,8 +1842,8 @@ importers:
         specifier: ^1.29.0
         version: 1.29.0(zod@4.3.6)
       '@openrouter/sdk':
-        specifier: 0.12.35
-        version: 0.12.35
+        specifier: 0.12.79
+        version: 0.12.79
       '@opentelemetry/api':
         specifier: ^1.9.0
         version: 1.9.1
@@ -4401,8 +4401,8 @@ packages:
     resolution: {integrity: sha512-T8TbSnGsxo6TDBJx/Sgv/BlVJL3tshxZP7Aq5R1mSnM5OcHY2dQaxLMu2+E8u3gN0MLOzdjurqN4ZRVuzQycOQ==}
     engines: {node: '>=8.0'}
 
-  '@openrouter/sdk@0.12.35':
-    resolution: {integrity: sha512-s4QVLLnG1AmfW3TjnnHUqGfsCkzwVK+kboGcZmKbde09m1DPqgzl4RUFt/HJ5v97MX8aEaN0UG3mKv2S+qj2Gw==}
+  '@openrouter/sdk@0.12.79':
+    resolution: {integrity: sha512-0ZpwtnuHh3/B1piW9kHCUIQy6PAsaK/vjFdZuHxmCdAenCyUNsLA2mFpmfHNWRNb+bOO3yBc4IALa264UyzmBA==}
 
   '@opentelemetry/api@1.9.1':
     resolution: {integrity: sha512-gLyJlPHPZYdAk1JENA9LeHejZe1Ti77/pTeFm/nMXmQH/HFZlcS/O2XJB+L8fkbrNSqhdtlvjBVjxwUYanNH5Q==}
@@ -16276,7 +16276,7 @@ snapshots:
 
   '@oozcitak/util@8.3.8': {}
 
-  '@openrouter/sdk@0.12.35':
+  '@openrouter/sdk@0.12.79':
     dependencies:
       zod: 4.3.6
 
diff --git a/scripts/convert-openrouter-models.ts b/scripts/convert-openrouter-models.ts
index 3722bddf7..126c83786 100644
--- a/scripts/convert-openrouter-models.ts
+++ b/scripts/convert-openrouter-models.ts
@@ -9,7 +9,9 @@
 
 import { writeFile } from 'node:fs/promises'
 import { models } from './openrouter.models'
+import { videoModels as videoApiModels } from './openrouter.video-models'
 import type { OpenRouterModel } from './openrouter.models'
+import type { OpenRouterVideoApiModel } from './openrouter.video-models'
 
 type InputModality = 'text' | 'image' | 'audio' | 'video' | 'document'
 
@@ -88,15 +90,57 @@ function generateImageModelsArray(): string {
 }
 
 function generateVideoModelsArray(): string {
-  const modelIds = Array.from(videoModels)
-  if (modelIds.length === 0) {
+  // Video generation models come from the dedicated `GET /api/v1/videos/models`
+  // endpoint (openrouter.video-models.json) — they don't appear in the plain
+  // models listing. Models the main listing reports with a `video` output
+  // modality (none today) are merged in for completeness.
+  const ids = new Set(videoApiModels.map((m) => `'${m.id}'`))
+  for (const constRef of videoModels) ids.add(constRef)
+  if (ids.size === 0) {
     return ''
   }
-  return `export const OPENROUTER_VIDEO_MODELS = [\n${modelIds
+  return `export const OPENROUTER_VIDEO_MODELS = [\n${Array.from(ids)
     .map((id) => `  ${id},`)
     .join('\n')}\n] as const`
 }
 
+function videoMetaLiteral(value: Array<number | string> | null): string {
+  if (value === null) return 'null'
+  return `[${value
+    .map((v) => (typeof v === 'number' ? `${v}` : `'${v}'`))
+    .join(', ')}]`
+}
+
+/**
+ * Per-model capability metadata for the dedicated video generation API.
+ * `@tanstack/ai-openrouter/src/video/video-provider-options.ts` derives the
+ * per-model provider-option and size types from this const, and the video
+ * adapter validates sizes / durations / frame roles against it at runtime.
+ */
+function generateVideoModelMeta(): string {
+  if (videoApiModels.length === 0) {
+    return ''
+  }
+  const entries = videoApiModels.map((m: OpenRouterVideoApiModel) => {
+    const lines = [
+      `  '${m.id}': {`,
+      `    name: '${m.name.replace(/'/g, "\\'")}',`,
+      `    durations: ${videoMetaLiteral(m.supported_durations)},`,
+      `    resolutions: ${videoMetaLiteral(m.supported_resolutions)},`,
+      `    aspectRatios: ${videoMetaLiteral(m.supported_aspect_ratios)},`,
+      `    frameImages: ${videoMetaLiteral(m.supported_frame_images)},`,
+      `    sizes: ${videoMetaLiteral(m.supported_sizes)},`,
+      `    generateAudio: ${m.generate_audio},`,
+      `    seed: ${m.seed},`,
+      `  },`,
+    ]
+    return lines.join('\n')
+  })
+  return `export const OPENROUTER_VIDEO_MODEL_META = {\n${entries.join(
+    '\n',
+  )}\n} as const`
+}
+
 function createPerModelModelOptions(): string {
   const entries = Object.entries(perModelProviderOptions).map(
     ([modelId, typeStr]) => `  [${modelId}]: ${typeStr};`,
@@ -322,6 +366,7 @@ ${generateChatModelsArray()}
 
 ${generateChatToolCapabilitiesType()}
 ${generateVideoModelsArray()}
+${generateVideoModelMeta()}
 ${generateImageModelsArray()}
 `
 console.log(file)
diff --git a/scripts/fetch-openrouter-models.ts b/scripts/fetch-openrouter-models.ts
index f08780fbb..32ec03f35 100644
--- a/scripts/fetch-openrouter-models.ts
+++ b/scripts/fetch-openrouter-models.ts
@@ -1,14 +1,20 @@
 /**
- * Fetches models from the OpenRouter API and writes them to openrouter.models.json.
+ * Fetches models from the OpenRouter API and writes them to openrouter.models.json
+ * and openrouter.video-models.json.
  *
  * Usage:
  *   pnpm tsx scripts/fetch-openrouter-models.ts
  *
+ * Video generation models do NOT appear in the plain `GET /api/v1/models`
+ * listing — they live behind the dedicated `GET /api/v1/videos/models`
+ * endpoint, so this script fetches both and writes each to its own JSON file.
+ *
  * The output is plain JSON so a malicious or compromised upstream response
  * cannot smuggle executable code into the build (JSON.stringify cannot produce
- * a JS expression). The committed wrapper at `openrouter.models.ts` re-exports
- * this JSON typed as `Array<OpenRouterModel>` so consumers don't need to know
- * where the data lives.
+ * a JS expression). The committed wrappers at `openrouter.models.ts` /
+ * `openrouter.video-models.ts` re-export the JSON typed as
+ * `Array<OpenRouterModel>` / `Array<OpenRouterVideoApiModel>` so consumers
+ * don't need to know where the data lives.
  */
 
 import { writeFile } from 'node:fs/promises'
@@ -17,7 +23,9 @@ import { fileURLToPath } from 'node:url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const OUTPUT_PATH = resolve(__dirname, 'openrouter.models.json')
+const VIDEO_OUTPUT_PATH = resolve(__dirname, 'openrouter.video-models.json')
 const API_URL = 'https://openrouter.ai/api/v1/models'
+const VIDEO_API_URL = 'https://openrouter.ai/api/v1/videos/models'
 
 interface ApiModel {
   id: string
@@ -80,9 +88,37 @@ function isValidModel(model: ApiModel): boolean {
   return true
 }
 
-async function main() {
-  console.log(`Fetching models from ${API_URL}...`)
-  const response = await fetch(API_URL, {
+interface VideoApiModel {
+  id: string
+  name: string
+  supported_durations: Array<number> | null
+  supported_resolutions: Array<string> | null
+  supported_aspect_ratios: Array<string> | null
+  supported_frame_images: Array<string> | null
+  supported_sizes: Array<string> | null
+  generate_audio: boolean | null
+  seed: boolean | null
+  pricing_skus?: Record<string, string> | null
+  allowed_passthrough_parameters?: Array<string>
+}
+
+function isValidVideoModel(model: VideoApiModel): boolean {
+  if (typeof model.id !== 'string' || typeof model.name !== 'string') {
+    return false
+  }
+  const arrayOrNull = (v: unknown) => v === null || Array.isArray(v)
+  return (
+    arrayOrNull(model.supported_durations) &&
+    arrayOrNull(model.supported_resolutions) &&
+    arrayOrNull(model.supported_aspect_ratios) &&
+    arrayOrNull(model.supported_frame_images) &&
+    arrayOrNull(model.supported_sizes)
+  )
+}
+
+async function fetchJson<T>(url: string): Promise<T> {
+  console.log(`Fetching models from ${url}...`)
+  const response = await fetch(url, {
     signal: AbortSignal.timeout(30_000),
   })
 
@@ -92,7 +128,11 @@ async function main() {
     )
   }
 
-  const json = (await response.json()) as { data: Array<ApiModel> }
+  return (await response.json()) as T
+}
+
+async function main() {
+  const json = await fetchJson<{ data: Array<ApiModel> }>(API_URL)
   const allModels = json.data
 
   const validModels = allModels.filter(isValidModel)
@@ -112,6 +152,27 @@ async function main() {
   )
   console.log(`Fetched ${validModels.length} models`)
   console.log(`Written to ${OUTPUT_PATH}`)
+
+  const videoJson = await fetchJson<{ data: Array<VideoApiModel> }>(
+    VIDEO_API_URL,
+  )
+  const validVideoModels = videoJson.data.filter(isValidVideoModel)
+  const skippedVideo = videoJson.data.length - validVideoModels.length
+  if (skippedVideo > 0) {
+    console.log(
+      `Skipped ${skippedVideo} video models with malformed fields (id, name, supported_* arrays)`,
+    )
+  }
+
+  validVideoModels.sort((a, b) => a.id.localeCompare(b.id))
+
+  await writeFile(
+    VIDEO_OUTPUT_PATH,
+    JSON.stringify(validVideoModels, null, 2) + '\n',
+    'utf-8',
+  )
+  console.log(`Fetched ${validVideoModels.length} video models`)
+  console.log(`Written to ${VIDEO_OUTPUT_PATH}`)
 }
 
 main().catch((error) => {
diff --git a/scripts/openrouter.video-models.json b/scripts/openrouter.video-models.json
new file mode 100644
index 000000000..c43b17ec2
--- /dev/null
+++ b/scripts/openrouter.video-models.json
@@ -0,0 +1,463 @@
+[
+  {
+    "id": "alibaba/wan-2.6",
+    "canonical_slug": "alibaba/wan-2.6-20260327",
+    "hugging_face_id": null,
+    "name": "Alibaba: Wan 2.6",
+    "created": 1774659190,
+    "description": "Alibaba's most advanced video generation model, supporting over 10 visual creation capabilities in a unified system. Wan 2.6 generates 1080p video at 24fps from text, images, reference videos, or audio,...",
+    "supported_resolutions": ["720p", "1080p"],
+    "supported_aspect_ratios": ["16:9", "9:16"],
+    "supported_sizes": ["1280x720", "1080x1920", "720x1280", "1920x1080"],
+    "supported_durations": [5, 10],
+    "supported_frame_images": ["first_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "text_to_video_duration_seconds_480p": "0.04",
+      "text_to_video_duration_seconds_720p": "0.08",
+      "image_to_video_duration_seconds_720p": "0.10",
+      "text_to_video_duration_seconds_1080p": "0.12",
+      "image_to_video_duration_seconds_1080p": "0.15"
+    },
+    "allowed_passthrough_parameters": [
+      "negative_prompt",
+      "enable_prompt_expansion",
+      "shot_type",
+      "audio",
+      "size"
+    ]
+  },
+  {
+    "id": "alibaba/wan-2.7",
+    "canonical_slug": "alibaba/wan-2.7-20260414",
+    "hugging_face_id": null,
+    "name": "Alibaba: Wan 2.7",
+    "created": 1776211362,
+    "description": "Wan 2.7 is a video generation model from Alibaba. It supports text-to-video, image-to-video with first and last frame control, and reference-to-video, where multiple reference images guide the style and content...",
+    "supported_resolutions": ["720p", "1080p"],
+    "supported_aspect_ratios": ["16:9", "9:16", "1:1", "4:3", "3:4"],
+    "supported_sizes": [
+      "1280x720",
+      "720x1280",
+      "1920x1080",
+      "1080x1920",
+      "720x720",
+      "1080x1080",
+      "960x720",
+      "720x960",
+      "1440x1080",
+      "1080x1440"
+    ],
+    "supported_durations": [2, 3, 4, 5, 6, 7, 8, 9, 10],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "duration_seconds": "0.1"
+    },
+    "allowed_passthrough_parameters": [
+      "negative_prompt",
+      "prompt_extend",
+      "audio",
+      "ratio",
+      "last_image",
+      "video",
+      "videos",
+      "images"
+    ]
+  },
+  {
+    "id": "bytedance/seedance-1-5-pro",
+    "canonical_slug": "bytedance/seedance-1-5-pro-20260320",
+    "hugging_face_id": null,
+    "name": "ByteDance: Seedance 1.5 Pro",
+    "created": 1774277608,
+    "description": "ByteDance's next-generation audio-visual generation model with a 4.5B parameter Dual-Branch Diffusion Transformer architecture. Seedance 1.5 Pro generates video and audio simultaneously in a single unified pass — eliminating the timing...",
+    "supported_resolutions": ["480p", "720p", "1080p"],
+    "supported_aspect_ratios": [
+      "1:1",
+      "3:4",
+      "9:16",
+      "9:21",
+      "4:3",
+      "16:9",
+      "21:9"
+    ],
+    "supported_sizes": [
+      "480x480",
+      "480x640",
+      "480x854",
+      "480x1120",
+      "640x480",
+      "720x720",
+      "720x960",
+      "720x1280",
+      "720x1680",
+      "854x480",
+      "960x720",
+      "1080x1080",
+      "1080x1440",
+      "1080x1920",
+      "1080x2520",
+      "1120x480",
+      "1280x720",
+      "1440x1080",
+      "1680x720",
+      "1920x1080",
+      "2520x1080"
+    ],
+    "supported_durations": [4, 5, 6, 7, 8, 9, 10, 11, 12],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "video_tokens": "0.0000024",
+      "video_tokens_without_audio": "0.0000012"
+    },
+    "allowed_passthrough_parameters": ["watermark", "req_key"]
+  },
+  {
+    "id": "bytedance/seedance-2.0",
+    "canonical_slug": "bytedance/seedance-2.0-20260414",
+    "hugging_face_id": null,
+    "name": "ByteDance: Seedance 2.0",
+    "created": 1776211362,
+    "description": "Seedance 2.0 is a video generation model from ByteDance. It supports text-to-video, image-to-video with first and last frame control, and multimodal reference-to-video. It is particularly strong at preserving character consistency,...",
+    "supported_resolutions": ["480p", "720p", "1080p"],
+    "supported_aspect_ratios": [
+      "1:1",
+      "3:4",
+      "9:16",
+      "4:3",
+      "16:9",
+      "21:9",
+      "9:21"
+    ],
+    "supported_sizes": [
+      "480x480",
+      "480x640",
+      "480x854",
+      "640x480",
+      "854x480",
+      "1120x480",
+      "720x720",
+      "720x960",
+      "720x1280",
+      "720x1680",
+      "960x720",
+      "1280x720",
+      "1680x720",
+      "1080x1080",
+      "1080x1440",
+      "1080x1920",
+      "1440x1080",
+      "1920x1080",
+      "2520x1080"
+    ],
+    "supported_durations": [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "video_tokens": "0.000007",
+      "video_tokens_without_audio": "0.000007"
+    },
+    "allowed_passthrough_parameters": ["watermark", "req_key"]
+  },
+  {
+    "id": "bytedance/seedance-2.0-fast",
+    "canonical_slug": "bytedance/seedance-2.0-fast-20260414",
+    "hugging_face_id": null,
+    "name": "ByteDance: Seedance 2.0 Fast",
+    "created": 1776211362,
+    "description": "Seedance 2.0 Fast is a video generation model from ByteDance. It supports text-to-video, image-to-video with first and last frame control, and multimodal reference-to-video. It prioritizes generation speed and lower cost...",
+    "supported_resolutions": ["480p", "720p"],
+    "supported_aspect_ratios": [
+      "1:1",
+      "3:4",
+      "9:16",
+      "4:3",
+      "16:9",
+      "21:9",
+      "9:21"
+    ],
+    "supported_sizes": [
+      "480x480",
+      "480x640",
+      "480x854",
+      "640x480",
+      "854x480",
+      "1120x480",
+      "720x720",
+      "720x960",
+      "720x1280",
+      "720x1680",
+      "960x720",
+      "1280x720",
+      "1680x720"
+    ],
+    "supported_durations": [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "video_tokens": "0.0000056",
+      "video_tokens_without_audio": "0.0000056"
+    },
+    "allowed_passthrough_parameters": ["watermark", "req_key"]
+  },
+  {
+    "id": "google/veo-3.1",
+    "canonical_slug": "google/veo-3.1-20260320",
+    "hugging_face_id": null,
+    "name": "Google: Veo 3.1",
+    "created": 1774277148,
+    "description": "Google's state-of-the-art video generation model, built for maximum visual fidelity in final production cuts. Veo 3.1 generates high-quality 1080p video from text or image prompts with native synchronized audio —...",
+    "supported_resolutions": ["720p", "1080p", "4K"],
+    "supported_aspect_ratios": ["16:9", "9:16"],
+    "supported_sizes": [
+      "1280x720",
+      "1080x1920",
+      "1920x1080",
+      "720x1280",
+      "3840x2160",
+      "2160x3840"
+    ],
+    "supported_durations": [4, 6, 8],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "duration_seconds_with_audio": "0.40",
+      "duration_seconds_with_audio_4k": "0.60",
+      "duration_seconds_without_audio": "0.20",
+      "duration_seconds_without_audio_4k": "0.40"
+    },
+    "allowed_passthrough_parameters": [
+      "personGeneration",
+      "aspectRatio",
+      "negativePrompt",
+      "conditioningScale",
+      "enhancePrompt"
+    ]
+  },
+  {
+    "id": "google/veo-3.1-fast",
+    "canonical_slug": "google/veo-3.1-fast-20260320",
+    "hugging_face_id": null,
+    "name": "Google: Veo 3.1 Fast",
+    "created": 1776994666,
+    "description": "Google's mid-tier video generation model balancing speed and quality. Veo 3.1 Fast generates high-quality video from text or image prompts with native synchronized audio, offering faster turnaround than Veo 3.1...",
+    "supported_resolutions": ["720p", "1080p", "4K"],
+    "supported_aspect_ratios": ["16:9", "9:16"],
+    "supported_sizes": [
+      "1280x720",
+      "1080x1920",
+      "1920x1080",
+      "720x1280",
+      "3840x2160",
+      "2160x3840"
+    ],
+    "supported_durations": [4, 6, 8],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "duration_seconds_with_audio": "0.12",
+      "duration_seconds_with_audio_4k": "0.30",
+      "duration_seconds_without_audio": "0.10",
+      "duration_seconds_with_audio_720p": "0.10",
+      "duration_seconds_without_audio_4k": "0.25",
+      "duration_seconds_without_audio_720p": "0.08"
+    },
+    "allowed_passthrough_parameters": [
+      "personGeneration",
+      "aspectRatio",
+      "negativePrompt",
+      "conditioningScale",
+      "enhancePrompt"
+    ]
+  },
+  {
+    "id": "google/veo-3.1-lite",
+    "canonical_slug": "google/veo-3.1-lite-20260331",
+    "hugging_face_id": null,
+    "name": "Google: Veo 3.1 Lite",
+    "created": 1776978818,
+    "description": "Google's most cost-effective video generation model, designed for high-volume applications and rapid iteration. Veo 3.1 Lite generates 720p and 1080p video from text or image prompts with native synchronized audio...",
+    "supported_resolutions": ["720p", "1080p"],
+    "supported_aspect_ratios": ["16:9", "9:16"],
+    "supported_sizes": ["1280x720", "720x1280", "1920x1080", "1080x1920"],
+    "supported_durations": [8, 4, 6],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": true,
+    "pricing_skus": {
+      "duration_seconds_with_audio": "0.08",
+      "duration_seconds_without_audio": "0.05",
+      "duration_seconds_with_audio_720p": "0.05",
+      "duration_seconds_without_audio_720p": "0.03"
+    },
+    "allowed_passthrough_parameters": [
+      "personGeneration",
+      "aspectRatio",
+      "negativePrompt",
+      "conditioningScale",
+      "enhancePrompt"
+    ]
+  },
+  {
+    "id": "kwaivgi/kling-v3.0-pro",
+    "canonical_slug": "kwaivgi/kling-v3.0-pro-20260429",
+    "hugging_face_id": null,
+    "name": "Kling: Video v3.0 Pro",
+    "created": 1777496206,
+    "description": "Kling v3.0 Pro is Kuaishou's premium video generation model, offering higher visual quality than the Standard tier. It supports text-to-video and image-to-video workflows, with first-frame and last-frame control for precise...",
+    "supported_resolutions": ["720p"],
+    "supported_aspect_ratios": ["16:9", "9:16", "1:1"],
+    "supported_sizes": ["1280x720", "720x1280", "720x720"],
+    "supported_durations": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": false,
+    "pricing_skus": {
+      "duration_seconds": "0.112",
+      "duration_seconds_with_audio": "0.168",
+      "text_to_video_duration_seconds_480p": "0.112",
+      "text_to_video_duration_seconds_720p": "0.112",
+      "image_to_video_duration_seconds_720p": "0.112",
+      "text_to_video_duration_seconds_1080p": "0.112",
+      "image_to_video_duration_seconds_1080p": "0.112"
+    },
+    "allowed_passthrough_parameters": ["negative_prompt", "cfg_scale"]
+  },
+  {
+    "id": "kwaivgi/kling-v3.0-std",
+    "canonical_slug": "kwaivgi/kling-v3.0-std-20260429",
+    "hugging_face_id": null,
+    "name": "Kling: Video v3.0 Standard",
+    "created": 1777496205,
+    "description": "Kling v3.0 Standard is a video generation model from Kuaishou. It supports text-to-video and image-to-video workflows, with first-frame and last-frame control for guided scene composition. Clips range from 3 to...",
+    "supported_resolutions": ["720p"],
+    "supported_aspect_ratios": ["16:9", "9:16", "1:1"],
+    "supported_sizes": ["1280x720", "720x1280", "720x720"],
+    "supported_durations": [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": false,
+    "pricing_skus": {
+      "duration_seconds": "0.084",
+      "duration_seconds_with_audio": "0.126",
+      "text_to_video_duration_seconds_480p": "0.084",
+      "text_to_video_duration_seconds_720p": "0.084",
+      "image_to_video_duration_seconds_720p": "0.084",
+      "text_to_video_duration_seconds_1080p": "0.084",
+      "image_to_video_duration_seconds_1080p": "0.084"
+    },
+    "allowed_passthrough_parameters": ["negative_prompt", "cfg_scale"]
+  },
+  {
+    "id": "kwaivgi/kling-video-o1",
+    "canonical_slug": "kwaivgi/kling-video-o1-20260420",
+    "hugging_face_id": null,
+    "name": "Kling: Video O1",
+    "created": 1776704777,
+    "description": "Kling Video O1 is a video generation model from Kuaishou. It supports text and image inputs with video output, enabling text-to-video and image-to-video workflows. It is suited for cinematic content...",
+    "supported_resolutions": ["720p"],
+    "supported_aspect_ratios": ["16:9", "9:16", "1:1"],
+    "supported_sizes": ["1280x720", "720x1280", "720x720"],
+    "supported_durations": [5, 10],
+    "supported_frame_images": ["first_frame", "last_frame"],
+    "generate_audio": true,
+    "seed": false,
+    "pricing_skus": {
+      "duration_seconds": "0.1120"
+    },
+    "allowed_passthrough_parameters": ["negative_prompt"]
+  },
+  {
+    "id": "minimax/hailuo-2.3",
+    "canonical_slug": "minimax/hailuo-2.3-20260420",
+    "hugging_face_id": null,
+    "name": "MiniMax: Hailuo 2.3",
+    "created": 1776702740,
+    "description": "Hailuo 2.3 is a video generation model from MiniMax. It accepts text prompts and reference images as input and generates video output, supporting both text-to-video and image-to-video workflows. It is...",
+    "supported_resolutions": ["1080p"],
+    "supported_aspect_ratios": ["16:9"],
+    "supported_sizes": ["1920x1080"],
+    "supported_durations": [6, 10],
+    "supported_frame_images": ["first_frame"],
+    "generate_audio": false,
+    "seed": null,
+    "pricing_skus": {
+      "duration_seconds": "0.0817"
+    },
+    "allowed_passthrough_parameters": ["prompt_optimizer", "fast_pretreatment"]
+  },
+  {
+    "id": "openai/sora-2-pro",
+    "canonical_slug": "openai/sora-2-pro-20260320",
+    "hugging_face_id": null,
+    "name": "OpenAI: Sora 2 Pro",
+    "created": 1774277521,
+    "description": "OpenAI's flagship video generation model, delivering production-quality video with physics-accurate motion, synchronized audio, and world-state persistence across shots. Sora 2 Pro follows intricate multi-shot instructions while maintaining consistent spatial relationships...",
+    "supported_resolutions": ["720p", "1080p"],
+    "supported_aspect_ratios": ["16:9", "9:16"],
+    "supported_sizes": ["1280x720", "1080x1920", "1920x1080", "720x1280"],
+    "supported_durations": [4, 8, 12, 16, 20],
+    "supported_frame_images": null,
+    "generate_audio": true,
+    "seed": false,
+    "pricing_skus": {
+      "duration_seconds_720p": "0.30",
+      "duration_seconds_1024p": "0.50",
+      "duration_seconds_1080p": "0.50"
+    },
+    "allowed_passthrough_parameters": ["quality", "style"]
+  },
+  {
+    "id": "x-ai/grok-imagine-video",
+    "canonical_slug": "x-ai/grok-imagine-video-20260512",
+    "hugging_face_id": null,
+    "name": "xAI: Grok Imagine Video",
+    "created": 1779117586,
+    "description": "Grok Imagine Video is xAI's fast, text-, image-, and reference-conditioned video generation model. It produces short videos (1–15 seconds, 24 fps) at 480p or 720p across seven aspect ratios -...",
+    "supported_resolutions": ["480p", "720p"],
+    "supported_aspect_ratios": [
+      "16:9",
+      "9:16",
+      "1:1",
+      "4:3",
+      "3:4",
+      "3:2",
+      "2:3"
+    ],
+    "supported_sizes": [
+      "854x480",
+      "1280x720",
+      "480x854",
+      "720x1280",
+      "480x480",
+      "720x720",
+      "640x480",
+      "960x720",
+      "480x640",
+      "720x960",
+      "720x480",
+      "1080x720",
+      "480x720",
+      "720x1080"
+    ],
+    "supported_durations": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
+    "supported_frame_images": ["first_frame"],
+    "generate_audio": null,
+    "seed": null,
+    "pricing_skus": {
+      "cents_per_image_input": "0.2",
+      "cents_per_video_output_second_480p": "5",
+      "cents_per_video_output_second_720p": "7"
+    },
+    "allowed_passthrough_parameters": []
+  }
+]
diff --git a/scripts/openrouter.video-models.ts b/scripts/openrouter.video-models.ts
new file mode 100644
index 000000000..bb2b11741
--- /dev/null
+++ b/scripts/openrouter.video-models.ts
@@ -0,0 +1,45 @@
+/**
+ * Hand-written wrapper. DO NOT regenerate this file.
+ *
+ * The model data lives in `openrouter.video-models.json` (regenerated by
+ * `fetch-openrouter-models.ts` from `GET /api/v1/videos/models` — video
+ * generation models do not appear in the plain `GET /api/v1/models`
+ * listing). This wrapper re-exports it typed so consumers can keep
+ * `import { videoModels } from './openrouter.video-models'`.
+ *
+ * The data is loaded via `JSON.parse(readFileSync(...))` rather than an
+ * `import ... with { type: 'json' }` attribute so the loader doesn't have
+ * to support JSON import attributes.
+ */
+
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export interface OpenRouterVideoApiModel {
+  id: string
+  name: string
+  /** Supported clip lengths in seconds; null when the API doesn't report them. */
+  supported_durations: Array<number> | null
+  /** e.g. '480p' | '720p' | '1080p' | '1K' | '2K' | '4K'; null when unreported. */
+  supported_resolutions: Array<string> | null
+  /** e.g. '16:9' | '9:16' | '1:1'; null when unreported. */
+  supported_aspect_ratios: Array<string> | null
+  /** Which `frame_images[].frame_type` values the model accepts; null when unreported. */
+  supported_frame_images: Array<string> | null
+  /** Exact 'WIDTHxHEIGHT' sizes; null when unreported. */
+  supported_sizes: Array<string> | null
+  /** Whether the model can generate audio; null when unknown. */
+  generate_audio: boolean | null
+  /** Whether the model honors a deterministic seed; null when unknown. */
+  seed: boolean | null
+  pricing_skus?: Record<string, string> | null
+  allowed_passthrough_parameters?: Array<string>
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const DATA_PATH = resolve(__dirname, 'openrouter.video-models.json')
+
+export const videoModels: Array<OpenRouterVideoApiModel> = JSON.parse(
+  readFileSync(DATA_PATH, 'utf-8'),
+)
diff --git a/testing/e2e/package.json b/testing/e2e/package.json
index 68381f527..480f69a49 100644
--- a/testing/e2e/package.json
+++ b/testing/e2e/package.json
@@ -13,7 +13,7 @@
   "dependencies": {
     "@copilotkit/aimock": "^1.28.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@openrouter/sdk": "0.12.35",
+    "@openrouter/sdk": "0.12.79",
     "@opentelemetry/api": "^1.9.0",
     "@tailwindcss/vite": "^4.1.18",
     "@tanstack/ai": "workspace:*",
diff --git a/testing/e2e/src/lib/feature-support.ts b/testing/e2e/src/lib/feature-support.ts
index b4e85a715..9572275ea 100644
--- a/testing/e2e/src/lib/feature-support.ts
+++ b/testing/e2e/src/lib/feature-support.ts
@@ -191,12 +191,20 @@ export const matrix: Record<Feature, Set<Provider>> = {
   'sound-effects': new Set(['elevenlabs']),
   tts: new Set(['openai', 'grok', 'elevenlabs']),
   transcription: new Set(['openai', 'grok', 'elevenlabs']),
+  // OpenRouter excluded: its dedicated async video API
+  // (`POST /api/v1/videos` → poll → `unsigned_urls`) is a different wire
+  // shape from the OpenAI `/v1/videos` handler aimock 1.29 mocks. The
+  // adapter's submit/poll/download lifecycle is covered by unit tests
+  // (packages/ai-openrouter/tests/video-adapter.test.ts). Add it here when
+  // aimock learns the OpenRouter job endpoints
+  // (https://github.com/CopilotKit/aimock/issues/261).
   'video-gen': new Set(['openai']),
   // image-to-video (image parts in the generateVideo prompt). aimock 1.29's
   // `/v1/videos` handler parses Sora's multipart upload (the SDK switches to
   // multipart when `input_reference` carries a File) and matches on the
   // `prompt` form field, so the OpenAI/Sora route runs end-to-end. fal's
-  // endpoint-specific fields remain unit-test-only.
+  // endpoint-specific fields and OpenRouter's `frame_images` /
+  // `input_references` mapping remain unit-test-only.
   'image-to-video': new Set(['openai']),
   // Only Gemini currently surfaces a first-class stateful conversation API via
   // the adapter (geminiTextInteractions, behind @tanstack/ai-gemini/experimental).