Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/fal/video-generation-provider.ts

@@ -0,0 +1,714 @@
+// Fal provider module implements model/runtime integration.
+import { extensionForMime } from "openclaw/plugin-sdk/media-mime";
+import { resolvePositiveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { isProviderApiKeyConfigured } from "openclaw/plugin-sdk/provider-auth";
+import {
+  assertOkOrThrowHttpError,
+  createProviderOperationDeadline,
+  readProviderJsonResponse,
+  type ProviderOperationDeadline,
+} from "openclaw/plugin-sdk/provider-http";
+import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
+import {
+  fetchWithSsrFGuard,
+  type SsrFPolicy,
+  ssrfPolicyFromDangerouslyAllowPrivateNetwork,
+} from "openclaw/plugin-sdk/ssrf-runtime";
+import {
+  isRecord,
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+} from "openclaw/plugin-sdk/string-coerce-runtime";
+import type {
+  GeneratedVideoAsset,
+  VideoGenerationProvider,
+  VideoGenerationRequest,
+} from "openclaw/plugin-sdk/video-generation";
+import { resolveFalHttpRequestConfig } from "./http-config.js";
+
+const DEFAULT_FAL_QUEUE_BASE_URL = "https://queue.fal.run";
+const DEFAULT_FAL_VIDEO_MODEL = "fal-ai/minimax/video-01-live";
+const HEYGEN_VIDEO_AGENT_MODEL = "fal-ai/heygen/v2/video-agent";
+const SEEDANCE_2_TEXT_IMAGE_VIDEO_MODELS = [
+  "bytedance/seedance-2.0/fast/text-to-video",
+  "bytedance/seedance-2.0/fast/image-to-video",
+  "bytedance/seedance-2.0/text-to-video",
+  "bytedance/seedance-2.0/image-to-video",
+] as const;
+const SEEDANCE_2_REFERENCE_VIDEO_MODELS = [
+  "bytedance/seedance-2.0/fast/reference-to-video",
+  "bytedance/seedance-2.0/reference-to-video",
+] as const;
+const SEEDANCE_2_VIDEO_MODELS = [
+  ...SEEDANCE_2_TEXT_IMAGE_VIDEO_MODELS,
+  ...SEEDANCE_2_REFERENCE_VIDEO_MODELS,
+] as const;
+const SEEDANCE_2_DURATION_SECONDS = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] as const;
+const SEEDANCE_REFERENCE_MAX_IMAGES = 9;
+const SEEDANCE_REFERENCE_MAX_VIDEOS = 3;
+const SEEDANCE_REFERENCE_MAX_AUDIOS = 3;
+const SEEDANCE_REFERENCE_MAX_FILES = 12;
+const SEEDANCE_REFERENCE_MAX_IMAGES_BY_MODEL = Object.fromEntries(
+  SEEDANCE_2_REFERENCE_VIDEO_MODELS.map((model) => [model, SEEDANCE_REFERENCE_MAX_IMAGES]),
+);
+const SEEDANCE_REFERENCE_MAX_VIDEOS_BY_MODEL = Object.fromEntries(
+  SEEDANCE_2_REFERENCE_VIDEO_MODELS.map((model) => [model, SEEDANCE_REFERENCE_MAX_VIDEOS]),
+);
+const SEEDANCE_REFERENCE_MAX_AUDIOS_BY_MODEL = Object.fromEntries(
+  SEEDANCE_2_REFERENCE_VIDEO_MODELS.map((model) => [model, SEEDANCE_REFERENCE_MAX_AUDIOS]),
+);
+const DEFAULT_HTTP_TIMEOUT_MS = 30_000;
+const DEFAULT_OPERATION_TIMEOUT_MS = 1_200_000;
+const DEFAULT_GENERATED_VIDEO_MAX_BYTES = 16 * 1024 * 1024;
+const POLL_INTERVAL_MS = 5_000;
+const FAL_VIDEO_MALFORMED_RESPONSE = "fal video generation response malformed";
+const FAL_VIDEO_PENDING_STATUSES = new Set([
+  "IN_QUEUE",
+  "IN_PROGRESS",
+  "PROCESSING",
+  "QUEUED",
+  "STARTED",
+]);
+
+type FalVideoResponse = {
+  video?: {
+    url?: string;
+    content_type?: string;
+  };
+  videos?: Array<{
+    url?: string;
+    content_type?: string;
+  }>;
+  prompt?: string;
+  seed?: number;
+};
+
+type FalQueueResponse = {
+  status?: string;
+  request_id?: string;
+  response_url?: string;
+  status_url?: string;
+  cancel_url?: string;
+  detail?: string;
+  response?: FalVideoResponse;
+  prompt?: string;
+  error?: {
+    message?: string;
+  };
+};
+
+let falFetchGuard = fetchWithSsrFGuard;
+
+export function setFalVideoFetchGuardForTesting(impl: typeof fetchWithSsrFGuard | null): void {
+  falFetchGuard = impl ?? fetchWithSsrFGuard;
+}
+
+function normalizeFalVideoUrl(value: unknown): string | undefined {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized && value !== undefined && value !== null) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  return normalized;
+}
+
+function readFalVideoPayload(payload: unknown): FalVideoResponse {
+  if (!isRecord(payload)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  const video = payload.video;
+  const videos = payload.videos;
+  if (video !== undefined && video !== null && !isRecord(video)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  if (videos !== undefined && videos !== null && !Array.isArray(videos)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  return {
+    video: isRecord(video)
+      ? {
+          url: normalizeFalVideoUrl(video.url),
+          content_type: normalizeOptionalString(video.content_type),
+        }
+      : undefined,
+    videos: Array.isArray(videos)
+      ? videos.map((entry) => {
+          if (!isRecord(entry)) {
+            throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+          }
+          return {
+            url: normalizeFalVideoUrl(entry.url),
+            content_type: normalizeOptionalString(entry.content_type),
+          };
+        })
+      : undefined,
+    prompt: normalizeOptionalString(payload.prompt),
+    seed: typeof payload.seed === "number" ? payload.seed : undefined,
+  };
+}
+
+function readFalQueueResponse(payload: unknown): FalQueueResponse {
+  if (!isRecord(payload)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  const error = payload.error;
+  if (error !== undefined && error !== null && !isRecord(error)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  return {
+    status: normalizeOptionalString(payload.status),
+    request_id: normalizeOptionalString(payload.request_id),
+    response_url: normalizeOptionalString(payload.response_url),
+    status_url: normalizeOptionalString(payload.status_url),
+    cancel_url: normalizeOptionalString(payload.cancel_url),
+    detail: normalizeOptionalString(payload.detail),
+    response: payload.response === undefined ? undefined : readFalVideoPayload(payload.response),
+    prompt: normalizeOptionalString(payload.prompt),
+    error: isRecord(error) ? { message: normalizeOptionalString(error.message) } : undefined,
+  };
+}
+
+function readFalCompletedQueueResult(payload: unknown): FalQueueResponse {
+  if (!isRecord(payload)) {
+    throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+  }
+  if (
+    payload.response !== undefined ||
+    (payload.video === undefined && payload.videos === undefined)
+  ) {
+    return readFalQueueResponse(payload);
+  }
+  return {
+    response: readFalVideoPayload(payload),
+  };
+}
+
+function toDataUrl(buffer: Buffer, mimeType: string): string {
+  return `data:${mimeType};base64,${buffer.toString("base64")}`;
+}
+
+function buildPolicy(allowPrivateNetwork: boolean): SsrFPolicy | undefined {
+  return allowPrivateNetwork ? ssrfPolicyFromDangerouslyAllowPrivateNetwork(true) : undefined;
+}
+
+function extractFalVideoEntry(payload: FalVideoResponse) {
+  if (normalizeOptionalString(payload.video?.url)) {
+    return payload.video;
+  }
+  return payload.videos?.find((entry) => normalizeOptionalString(entry.url));
+}
+
+function resolveGeneratedVideoMaxBytes(req: VideoGenerationRequest): number {
+  const configured = req.cfg.agents?.defaults?.mediaMaxMb;
+  if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+    return Math.floor(configured * 1024 * 1024);
+  }
+  return DEFAULT_GENERATED_VIDEO_MAX_BYTES;
+}
+
+async function downloadFalVideo(
+  url: string,
+  policy: SsrFPolicy | undefined,
+  maxBytes: number,
+): Promise<GeneratedVideoAsset> {
+  const { response, release } = await falFetchGuard({
+    url,
+    timeoutMs: DEFAULT_HTTP_TIMEOUT_MS,
+    policy,
+    auditContext: "fal-video-download",
+  });
+  try {
+    await assertOkOrThrowHttpError(response, "fal generated video download failed");
+    const mimeType = normalizeOptionalString(response.headers.get("content-type")) ?? "video/mp4";
+    const fileName = `video-1.${extensionForMime(mimeType)?.slice(1) ?? "mp4"}`;
+    let exceededMaxBytes = false;
+    let buffer: Buffer;
+    try {
+      buffer = await readResponseWithLimit(response, maxBytes, {
+        onOverflow: ({ maxBytes: maxBytesLocal }) => {
+          exceededMaxBytes = true;
+          return new Error(`fal generated video download exceeds ${maxBytesLocal} bytes`);
+        },
+      });
+    } catch (error) {
+      if (exceededMaxBytes) {
+        return {
+          url,
+          mimeType,
+          fileName,
+        };
+      }
+      throw error;
+    }
+    return {
+      url,
+      buffer,
+      mimeType,
+      fileName,
+    };
+  } finally {
+    await release();
+  }
+}
+
+function resolveFalQueueBaseUrl(baseUrl: string): string {
+  try {
+    const url = new URL(baseUrl);
+    if (url.hostname === "fal.run") {
+      url.hostname = "queue.fal.run";
+      return url.toString().replace(/\/$/, "");
+    }
+    return baseUrl.replace(/\/$/, "");
+  } catch {
+    return DEFAULT_FAL_QUEUE_BASE_URL;
+  }
+}
+
+function isFalMiniMaxLiveModel(model: string): boolean {
+  return normalizeLowercaseStringOrEmpty(model) === DEFAULT_FAL_VIDEO_MODEL;
+}
+
+function isFalSeedance2Model(model: string): boolean {
+  return SEEDANCE_2_VIDEO_MODELS.includes(model as (typeof SEEDANCE_2_VIDEO_MODELS)[number]);
+}
+
+function isFalSeedance2ReferenceModel(model: string): boolean {
+  return SEEDANCE_2_REFERENCE_VIDEO_MODELS.includes(
+    model as (typeof SEEDANCE_2_REFERENCE_VIDEO_MODELS)[number],
+  );
+}
+
+function isFalHeyGenVideoAgentModel(model: string): boolean {
+  return normalizeLowercaseStringOrEmpty(model) === HEYGEN_VIDEO_AGENT_MODEL;
+}
+
+function resolveFalResolution(resolution: VideoGenerationRequest["resolution"], model: string) {
+  if (!resolution) {
+    return undefined;
+  }
+  if (isFalSeedance2Model(model)) {
+    return resolution.toLowerCase();
+  }
+  return resolution;
+}
+
+function resolveFalDuration(
+  durationSeconds: number | undefined,
+  model: string,
+): number | string | undefined {
+  if (typeof durationSeconds !== "number" || !Number.isFinite(durationSeconds)) {
+    return undefined;
+  }
+  const duration = Math.max(1, Math.round(durationSeconds));
+  if (isFalSeedance2Model(model)) {
+    return SEEDANCE_2_DURATION_SECONDS.includes(
+      duration as (typeof SEEDANCE_2_DURATION_SECONDS)[number],
+    )
+      ? String(duration)
+      : undefined;
+  }
+  return duration;
+}
+
+function resolveFalReferenceUrl(
+  asset: NonNullable<VideoGenerationRequest["inputImages"]>[number] | undefined,
+  defaultMimeType: string,
+  label: string,
+): string {
+  const assetUrl = normalizeOptionalString(asset?.url);
+  if (assetUrl) {
+    return assetUrl;
+  }
+  if (!asset?.buffer) {
+    throw new Error(`fal ${label} is missing media data.`);
+  }
+  return toDataUrl(asset.buffer, normalizeOptionalString(asset.mimeType) ?? defaultMimeType);
+}
+
+function resolveFalReferenceUrls(
+  assets: VideoGenerationRequest["inputImages"],
+  defaultMimeType: string,
+  label: string,
+): string[] {
+  return (assets ?? []).map((asset) => resolveFalReferenceUrl(asset, defaultMimeType, label));
+}
+
+function applyFalSeedanceControls(params: {
+  req: VideoGenerationRequest;
+  model: string;
+  body: Record<string, unknown>;
+}): void {
+  const aspectRatio = normalizeOptionalString(params.req.aspectRatio);
+  if (aspectRatio) {
+    params.body.aspect_ratio = aspectRatio;
+  }
+  const size = normalizeOptionalString(params.req.size);
+  if (size) {
+    params.body.size = size;
+  }
+  const resolution = resolveFalResolution(params.req.resolution, params.model);
+  if (resolution) {
+    params.body.resolution = resolution;
+  }
+  const duration = resolveFalDuration(params.req.durationSeconds, params.model);
+  if (duration) {
+    params.body.duration = duration;
+  }
+  if (isFalSeedance2Model(params.model) && typeof params.req.audio === "boolean") {
+    params.body.generate_audio = params.req.audio;
+  }
+}
+
+function buildFalVideoRequestBody(params: {
+  req: VideoGenerationRequest;
+  model: string;
+}): Record<string, unknown> {
+  const requestBody: Record<string, unknown> = {
+    prompt: params.req.prompt,
+  };
+
+  if (isFalSeedance2ReferenceModel(params.model)) {
+    const imageUrls = resolveFalReferenceUrls(
+      params.req.inputImages,
+      "image/png",
+      "reference image",
+    );
+    const videoUrls = resolveFalReferenceUrls(
+      params.req.inputVideos,
+      "video/mp4",
+      "reference video",
+    );
+    const audioUrls = resolveFalReferenceUrls(
+      params.req.inputAudios,
+      "audio/mpeg",
+      "reference audio",
+    );
+    if (imageUrls.length > 0) {
+      requestBody.image_urls = imageUrls;
+    }
+    if (videoUrls.length > 0) {
+      requestBody.video_urls = videoUrls;
+    }
+    if (audioUrls.length > 0) {
+      requestBody.audio_urls = audioUrls;
+    }
+    applyFalSeedanceControls({ req: params.req, model: params.model, body: requestBody });
+    return requestBody;
+  }
+
+  const input = params.req.inputImages?.[0];
+  if (input) {
+    requestBody.image_url = normalizeOptionalString(input.url)
+      ? normalizeOptionalString(input.url)
+      : input.buffer
+        ? toDataUrl(input.buffer, normalizeOptionalString(input.mimeType) ?? "image/png")
+        : undefined;
+  }
+  // MiniMax Live on fal currently documents prompt + optional image_url only.
+  // Keep the default model conservative so queue requests do not hang behind
+  // unsupported knobs such as duration/resolution/aspect-ratio overrides.
+  if (isFalMiniMaxLiveModel(params.model) || isFalHeyGenVideoAgentModel(params.model)) {
+    return requestBody;
+  }
+  applyFalSeedanceControls({ req: params.req, model: params.model, body: requestBody });
+  return requestBody;
+}
+
+function validateFalVideoReferenceInputs(params: {
+  req: VideoGenerationRequest;
+  model: string;
+}): void {
+  const imageCount = params.req.inputImages?.length ?? 0;
+  const videoCount = params.req.inputVideos?.length ?? 0;
+  const audioCount = params.req.inputAudios?.length ?? 0;
+  if (isFalSeedance2ReferenceModel(params.model)) {
+    if (imageCount > SEEDANCE_REFERENCE_MAX_IMAGES) {
+      throw new Error(
+        `fal Seedance reference-to-video supports at most ${SEEDANCE_REFERENCE_MAX_IMAGES} reference images.`,
+      );
+    }
+    if (videoCount > SEEDANCE_REFERENCE_MAX_VIDEOS) {
+      throw new Error(
+        `fal Seedance reference-to-video supports at most ${SEEDANCE_REFERENCE_MAX_VIDEOS} reference videos.`,
+      );
+    }
+    if (audioCount > SEEDANCE_REFERENCE_MAX_AUDIOS) {
+      throw new Error(
+        `fal Seedance reference-to-video supports at most ${SEEDANCE_REFERENCE_MAX_AUDIOS} reference audios.`,
+      );
+    }
+    const totalFiles = imageCount + videoCount + audioCount;
+    if (totalFiles > SEEDANCE_REFERENCE_MAX_FILES) {
+      throw new Error(
+        `fal Seedance reference-to-video supports at most ${SEEDANCE_REFERENCE_MAX_FILES} total reference files.`,
+      );
+    }
+    if (audioCount > 0 && imageCount === 0 && videoCount === 0) {
+      throw new Error(
+        "fal Seedance reference-to-video requires at least one image or video reference when audio references are provided.",
+      );
+    }
+    return;
+  }
+
+  if (videoCount > 0) {
+    throw new Error("fal video generation does not support video reference inputs.");
+  }
+  if (audioCount > 0) {
+    throw new Error("fal video generation does not support audio reference inputs.");
+  }
+  if (imageCount > 1) {
+    throw new Error("fal video generation supports at most one image reference.");
+  }
+}
+
+async function fetchFalJson(params: {
+  url: string;
+  init?: RequestInit;
+  timeoutMs: number;
+  policy: SsrFPolicy | undefined;
+  dispatcherPolicy: Parameters<typeof fetchWithSsrFGuard>[0]["dispatcherPolicy"];
+  auditContext: string;
+  errorContext: string;
+}): Promise<unknown> {
+  const { response, release } = await falFetchGuard({
+    url: params.url,
+    init: params.init,
+    timeoutMs: params.timeoutMs,
+    policy: params.policy,
+    dispatcherPolicy: params.dispatcherPolicy,
+    auditContext: params.auditContext,
+  });
+  try {
+    await assertOkOrThrowHttpError(response, params.errorContext);
+    try {
+      return await readProviderJsonResponse<unknown>(response, params.errorContext);
+    } catch (error) {
+      if (error instanceof Error && error.message.endsWith(": malformed JSON response")) {
+        throw new Error(FAL_VIDEO_MALFORMED_RESPONSE, { cause: error });
+      }
+      throw error;
+    }
+  } finally {
+    await release();
+  }
+}
+
+async function waitForFalQueueResult(params: {
+  statusUrl: string;
+  responseUrl: string;
+  headers: Headers;
+  deadline: ProviderOperationDeadline;
+  policy: SsrFPolicy | undefined;
+  dispatcherPolicy: Parameters<typeof fetchWithSsrFGuard>[0]["dispatcherPolicy"];
+}): Promise<FalQueueResponse> {
+  let lastStatus = "unknown";
+  for (;;) {
+    const requestTimeoutMs = resolveFalQueueRemainingMs(
+      params.deadline,
+      lastStatus,
+      DEFAULT_HTTP_TIMEOUT_MS,
+    );
+    const payload = readFalQueueResponse(
+      await fetchFalJson({
+        url: params.statusUrl,
+        init: {
+          method: "GET",
+          headers: params.headers,
+        },
+        timeoutMs: requestTimeoutMs,
+        policy: params.policy,
+        dispatcherPolicy: params.dispatcherPolicy,
+        auditContext: "fal-video-status",
+        errorContext: "fal video status request failed",
+      }),
+    );
+    const status = normalizeOptionalString(payload.status)?.toUpperCase();
+    if (!status) {
+      throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+    }
+    lastStatus = status;
+    if (status === "COMPLETED") {
+      return readFalCompletedQueueResult(
+        await fetchFalJson({
+          url: params.responseUrl,
+          init: {
+            method: "GET",
+            headers: params.headers,
+          },
+          timeoutMs: resolveFalQueueRemainingMs(
+            params.deadline,
+            lastStatus,
+            DEFAULT_HTTP_TIMEOUT_MS,
+          ),
+          policy: params.policy,
+          dispatcherPolicy: params.dispatcherPolicy,
+          auditContext: "fal-video-result",
+          errorContext: "fal video result request failed",
+        }),
+      );
+    }
+    if (status === "FAILED" || status === "CANCELLED") {
+      throw new Error(
+        normalizeOptionalString(payload.detail) ||
+          normalizeOptionalString(payload.error?.message) ||
+          `fal video generation ${normalizeLowercaseStringOrEmpty(status)}`,
+      );
+    }
+    if (!FAL_VIDEO_PENDING_STATUSES.has(status)) {
+      throw new Error(FAL_VIDEO_MALFORMED_RESPONSE);
+    }
+    const pollDelayMs = resolveFalQueueRemainingMs(params.deadline, lastStatus, POLL_INTERVAL_MS);
+    await new Promise((resolve) => {
+      setTimeout(resolve, pollDelayMs);
+    });
+  }
+}
+
+function resolveFalQueueRemainingMs(
+  deadline: ProviderOperationDeadline,
+  lastStatus: string,
+  defaultTimeoutMs: number,
+): number {
+  const defaultMs = resolvePositiveTimerTimeoutMs(defaultTimeoutMs, 1);
+  if (typeof deadline.deadlineAtMs !== "number") {
+    return defaultMs;
+  }
+  const remainingMs = deadline.deadlineAtMs - Date.now();
+  if (remainingMs <= 0) {
+    throw new Error(`fal video generation did not finish in time (last status: ${lastStatus})`);
+  }
+  return Math.max(1, Math.min(defaultMs, remainingMs));
+}
+
+function extractFalVideoPayload(payload: FalQueueResponse): FalVideoResponse {
+  if (payload.response) {
+    return payload.response;
+  }
+  return readFalVideoPayload(payload);
+}
+
+export function buildFalVideoGenerationProvider(): VideoGenerationProvider {
+  return {
+    id: "fal",
+    label: "fal",
+    defaultModel: DEFAULT_FAL_VIDEO_MODEL,
+    models: [
+      DEFAULT_FAL_VIDEO_MODEL,
+      HEYGEN_VIDEO_AGENT_MODEL,
+      ...SEEDANCE_2_VIDEO_MODELS,
+      "fal-ai/kling-video/v2.1/master/text-to-video",
+      "fal-ai/wan/v2.2-a14b/text-to-video",
+      "fal-ai/wan/v2.2-a14b/image-to-video",
+    ],
+    isConfigured: ({ agentDir }) =>
+      isProviderApiKeyConfigured({
+        provider: "fal",
+        agentDir,
+      }),
+    capabilities: {
+      generate: {
+        maxVideos: 1,
+        supportedDurationSecondsByModel: Object.fromEntries(
+          SEEDANCE_2_VIDEO_MODELS.map((model) => [model, SEEDANCE_2_DURATION_SECONDS]),
+        ),
+        supportsAspectRatio: true,
+        supportsResolution: true,
+        supportsSize: true,
+        supportsAudio: true,
+      },
+      imageToVideo: {
+        enabled: true,
+        maxVideos: 1,
+        maxInputImages: 1,
+        maxInputImagesByModel: SEEDANCE_REFERENCE_MAX_IMAGES_BY_MODEL,
+        maxInputAudiosByModel: SEEDANCE_REFERENCE_MAX_AUDIOS_BY_MODEL,
+        supportedDurationSecondsByModel: Object.fromEntries(
+          SEEDANCE_2_VIDEO_MODELS.map((model) => [model, SEEDANCE_2_DURATION_SECONDS]),
+        ),
+        supportsAspectRatio: true,
+        supportsResolution: true,
+        supportsSize: true,
+        supportsAudio: true,
+      },
+      videoToVideo: {
+        enabled: true,
+        maxVideos: 1,
+        maxInputImages: 0,
+        maxInputImagesByModel: SEEDANCE_REFERENCE_MAX_IMAGES_BY_MODEL,
+        maxInputVideos: 0,
+        maxInputVideosByModel: SEEDANCE_REFERENCE_MAX_VIDEOS_BY_MODEL,
+        maxInputAudiosByModel: SEEDANCE_REFERENCE_MAX_AUDIOS_BY_MODEL,
+        supportedDurationSecondsByModel: Object.fromEntries(
+          SEEDANCE_2_REFERENCE_VIDEO_MODELS.map((model) => [model, SEEDANCE_2_DURATION_SECONDS]),
+        ),
+        supportsAspectRatio: true,
+        supportsResolution: true,
+        supportsSize: true,
+        supportsAudio: true,
+      },
+    },
+    async generateVideo(req) {
+      const model = normalizeOptionalString(req.model) || DEFAULT_FAL_VIDEO_MODEL;
+      validateFalVideoReferenceInputs({ req, model });
+      const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } =
+        await resolveFalHttpRequestConfig({ req, capability: "video" });
+      const requestBody = buildFalVideoRequestBody({ req, model });
+      const policy = buildPolicy(allowPrivateNetwork);
+      const queueBaseUrl = resolveFalQueueBaseUrl(baseUrl);
+      const submitted = readFalQueueResponse(
+        await fetchFalJson({
+          url: `${queueBaseUrl}/${model}`,
+          init: {
+            method: "POST",
+            headers,
+            body: JSON.stringify(requestBody),
+          },
+          timeoutMs: DEFAULT_HTTP_TIMEOUT_MS,
+          policy,
+          dispatcherPolicy,
+          auditContext: "fal-video-submit",
+          errorContext: "fal video generation failed",
+        }),
+      );
+      const statusUrl = normalizeOptionalString(submitted.status_url);
+      const responseUrl = normalizeOptionalString(submitted.response_url);
+      if (!statusUrl || !responseUrl) {
+        throw new Error("fal video generation response missing queue URLs");
+      }
+      const operationTimeoutMs = resolvePositiveTimerTimeoutMs(
+        req.timeoutMs,
+        DEFAULT_OPERATION_TIMEOUT_MS,
+      );
+      const operationDeadline = createProviderOperationDeadline({
+        timeoutMs: operationTimeoutMs,
+        label: "fal video generation",
+      });
+      const payload = await waitForFalQueueResult({
+        statusUrl,
+        responseUrl,
+        headers,
+        deadline: operationDeadline,
+        policy,
+        dispatcherPolicy,
+      });
+      const videoPayload = extractFalVideoPayload(payload);
+      const entry = extractFalVideoEntry(videoPayload);
+      const url = normalizeOptionalString(entry?.url);
+      if (!url) {
+        throw new Error("fal video generation response missing output URL");
+      }
+      const video = await downloadFalVideo(url, policy, resolveGeneratedVideoMaxBytes(req));
+      return {
+        videos: [video],
+        model,
+        metadata: {
+          ...(normalizeOptionalString(submitted.request_id)
+            ? { requestId: normalizeOptionalString(submitted.request_id) }
+            : {}),
+          ...(videoPayload.prompt ? { prompt: videoPayload.prompt } : {}),
+          ...(typeof videoPayload.seed === "number" ? { seed: videoPayload.seed } : {}),
+        },
+      };
+    },
+  };
+}