Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

feat(api-nodes): add SeeDance 2.0 nodes (#13364)

Alexander Piskunee2db7488df0
diff --git a/comfy_api_nodes/apis/bytedance.py b/comfy_api_nodes/apis/bytedance.py
index 18455396d..3755323ac 100644
--- a/comfy_api_nodes/apis/bytedance.py
+++ b/comfy_api_nodes/apis/bytedance.py
@@ -52,6 +52,26 @@ class TaskImageContent(BaseModel):
role: Literal["first_frame", "last_frame", "reference_image"] | None = Field(None)
+class TaskVideoContentUrl(BaseModel):
+ url: str = Field(...)
+
+
+class TaskVideoContent(BaseModel):
+ type: str = Field("video_url")
+ video_url: TaskVideoContentUrl = Field(...)
+ role: str = Field("reference_video")
+
+
+class TaskAudioContentUrl(BaseModel):
+ url: str = Field(...)
+
+
+class TaskAudioContent(BaseModel):
+ type: str = Field("audio_url")
+ audio_url: TaskAudioContentUrl = Field(...)
+ role: str = Field("reference_audio")
+
+
class Text2VideoTaskCreationRequest(BaseModel):
model: str = Field(...)
content: list[TaskTextContent] = Field(..., min_length=1)
@@ -64,6 +84,17 @@ class Image2VideoTaskCreationRequest(BaseModel):
generate_audio: bool | None = Field(...)
+class Seedance2TaskCreationRequest(BaseModel):
+ model: str = Field(...)
+ content: list[TaskTextContent | TaskImageContent | TaskVideoContent | TaskAudioContent] = Field(..., min_length=1)
+ generate_audio: bool | None = Field(None)
+ resolution: str | None = Field(None)
+ ratio: str | None = Field(None)
+ duration: int | None = Field(None, ge=4, le=15)
+ seed: int | None = Field(None, ge=0, le=2147483647)
+ watermark: bool | None = Field(None)
+
+
class TaskCreationResponse(BaseModel):
id: str = Field(...)
@@ -77,12 +108,27 @@ class TaskStatusResult(BaseModel):
video_url: str = Field(...)
+class TaskStatusUsage(BaseModel):
+ completion_tokens: int = Field(0)
+ total_tokens: int = Field(0)
+
+
class TaskStatusResponse(BaseModel):
id: str = Field(...)
model: str = Field(...)
status: Literal["queued", "running", "cancelled", "succeeded", "failed"] = Field(...)
error: TaskStatusError | None = Field(None)
content: TaskStatusResult | None = Field(None)
+ usage: TaskStatusUsage | None = Field(None)
+
+
+# Dollars per 1K tokens, keyed by (model_id, has_video_input).
+SEEDANCE2_PRICE_PER_1K_TOKENS = {
+ ("dreamina-seedance-2-0-260128", False): 0.007,
+ ("dreamina-seedance-2-0-260128", True): 0.0043,
+ ("dreamina-seedance-2-0-fast-260128", False): 0.0056,
+ ("dreamina-seedance-2-0-fast-260128", True): 0.0033,
+}
RECOMMENDED_PRESETS = [
@@ -112,6 +158,12 @@ RECOMMENDED_PRESETS_SEEDREAM_4 = [
("Custom", None, None),
]
+# Seedance 2.0 reference video pixel count limits per model.
+SEEDANCE2_REF_VIDEO_PIXEL_LIMITS = {
+ "dreamina-seedance-2-0-260128": {"min": 409_600, "max": 927_408},
+ "dreamina-seedance-2-0-fast-260128": {"min": 409_600, "max": 927_408},
+}
+
# The time in this dictionary are given for 10 seconds duration.
VIDEO_TASKS_EXECUTION_TIME = {
"seedance-1-0-lite-t2v-250428": {
diff --git a/comfy_api_nodes/nodes_bytedance.py b/comfy_api_nodes/nodes_bytedance.py
index de0c22e70..1cca72f6e 100644
--- a/comfy_api_nodes/nodes_bytedance.py
+++ b/comfy_api_nodes/nodes_bytedance.py
@@ -8,16 +8,23 @@ from comfy_api.latest import IO, ComfyExtension, Input
from comfy_api_nodes.apis.bytedance import (
RECOMMENDED_PRESETS,
RECOMMENDED_PRESETS_SEEDREAM_4,
+ SEEDANCE2_PRICE_PER_1K_TOKENS,
+ SEEDANCE2_REF_VIDEO_PIXEL_LIMITS,
VIDEO_TASKS_EXECUTION_TIME,
Image2VideoTaskCreationRequest,
ImageTaskCreationResponse,
+ Seedance2TaskCreationRequest,
Seedream4Options,
Seedream4TaskCreationRequest,
+ TaskAudioContent,
+ TaskAudioContentUrl,
TaskCreationResponse,
TaskImageContent,
TaskImageContentUrl,
TaskStatusResponse,
TaskTextContent,
+ TaskVideoContent,
+ TaskVideoContentUrl,
Text2ImageTaskCreationRequest,
Text2VideoTaskCreationRequest,
)
@@ -29,7 +36,10 @@ from comfy_api_nodes.util import (
image_tensor_pair_to_batch,
poll_op,
sync_op,
+ upload_audio_to_comfyapi,
+ upload_image_to_comfyapi,
upload_images_to_comfyapi,
+ upload_video_to_comfyapi,
validate_image_aspect_ratio,
validate_image_dimensions,
validate_string,
@@ -46,12 +56,56 @@ SEEDREAM_MODELS = {
# Long-running tasks endpoints(e.g., video)
BYTEPLUS_TASK_ENDPOINT = "/proxy/byteplus/api/v3/contents/generations/tasks"
BYTEPLUS_TASK_STATUS_ENDPOINT = "/proxy/byteplus/api/v3/contents/generations/tasks" # + /{task_id}
+BYTEPLUS_SEEDANCE2_TASK_STATUS_ENDPOINT = "/proxy/byteplus-seedance2/api/v3/contents/generations/tasks" # + /{task_id}
+
+SEEDANCE_MODELS = {
+ "Seedance 2.0": "dreamina-seedance-2-0-260128",
+ "Seedance 2.0 Fast": "dreamina-seedance-2-0-fast-260128",
+}
DEPRECATED_MODELS = {"seedance-1-0-lite-t2v-250428", "seedance-1-0-lite-i2v-250428"}
+
logger = logging.getLogger(__name__)
+def _validate_ref_video_pixels(video: Input.Video, model_id: str, index: int) -> None:
+ """Validate reference video pixel count against Seedance 2.0 model limits."""
+ limits = SEEDANCE2_REF_VIDEO_PIXEL_LIMITS.get(model_id)
+ if not limits:
+ return
+ try:
+ w, h = video.get_dimensions()
+ except Exception:
+ return
+ pixels = w * h
+ min_px = limits.get("min")
+ max_px = limits.get("max")
+ if min_px and pixels < min_px:
+ raise ValueError(
+ f"Reference video {index} is too small: {w}x{h} = {pixels:,}px. " f"Minimum is {min_px:,}px for this model."
+ )
+ if max_px and pixels > max_px:
+ raise ValueError(
+ f"Reference video {index} is too large: {w}x{h} = {pixels:,}px. "
+ f"Maximum is {max_px:,}px for this model. Try downscaling the video."
+ )
+
+
+def _seedance2_price_extractor(model_id: str, has_video_input: bool):
+ """Returns a price_extractor closure for Seedance 2.0 poll_op."""
+ rate = SEEDANCE2_PRICE_PER_1K_TOKENS.get((model_id, has_video_input))
+ if rate is None:
+ return None
+
+ def extractor(response: TaskStatusResponse) -> float | None:
+ if response.usage is None:
+ return None
+ return response.usage.total_tokens * 1.43 * rate / 1_000.0
+
+ return extractor
+
+
def get_image_url_from_response(response: ImageTaskCreationResponse) -> str:
if response.error:
error_msg = f"ByteDance request failed. Code: {response.error['code']}, message: {response.error['message']}"
@@ -335,8 +389,7 @@ class ByteDanceSeedreamNode(IO.ComfyNode):
mp_provided = out_num_pixels / 1_000_000.0
if ("seedream-4-5" in model or "seedream-5-0" in model) and out_num_pixels < 3686400:
raise ValueError(
- f"Minimum image resolution for the selected model is 3.68MP, "
- f"but {mp_provided:.2f}MP provided."
+ f"Minimum image resolution for the selected model is 3.68MP, " f"but {mp_provided:.2f}MP provided."
)
if "seedream-4-0" in model and out_num_pixels < 921600:
raise ValueError(
@@ -952,33 +1005,6 @@ class ByteDanceImageReferenceNode(IO.ComfyNode):
)
-async def process_video_task(
- cls: type[IO.ComfyNode],
- payload: Text2VideoTaskCreationRequest | Image2VideoTaskCreationRequest,
- estimated_duration: int | None,
-) -> IO.NodeOutput:
- if payload.model in DEPRECATED_MODELS:
- logger.warning(
- "Model '%s' is deprecated and will be deactivated on May 13, 2026. "
- "Please switch to a newer model. Recommended: seedance-1-0-pro-fast-251015.",
- payload.model,
- )
- initial_response = await sync_op(
- cls,
- ApiEndpoint(path=BYTEPLUS_TASK_ENDPOINT, method="POST"),
- data=payload,
- response_model=TaskCreationResponse,
- )
- response = await poll_op(
- cls,
- ApiEndpoint(path=f"{BYTEPLUS_TASK_STATUS_ENDPOINT}/{initial_response.id}"),
- status_extractor=lambda r: r.status,
- estimated_duration=estimated_duration,
- response_model=TaskStatusResponse,
- )
- return IO.NodeOutput(await download_url_to_video_output(response.content.video_url))
-
-
def raise_if_text_params(prompt: str, text_params: list[str]) -> None:
for i in text_params:
if f"--{i} " in prompt:
@@ -1040,6 +1066,530 @@ PRICE_BADGE_VIDEO = IO.PriceBadge(
)
+def _seedance2_text_inputs():
+ return [
+ IO.String.Input(
+ "prompt",
+ multiline=True,
+ default="",
+ tooltip="Text prompt for video generation.",
+ ),
+ IO.Combo.Input(
+ "resolution",
+ options=["480p", "720p"],
+ tooltip="Resolution of the output video.",
+ ),
+ IO.Combo.Input(
+ "ratio",
+ options=["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"],
+ tooltip="Aspect ratio of the output video.",
+ ),
+ IO.Int.Input(
+ "duration",
+ default=7,
+ min=4,
+ max=15,
+ step=1,
+ tooltip="Duration of the output video in seconds (4-15).",
+ display_mode=IO.NumberDisplay.slider,
+ ),
+ IO.Boolean.Input(
+ "generate_audio",
+ default=True,
+ tooltip="Enable audio generation for the output video.",
+ ),
+ ]
+
+
+class ByteDance2TextToVideoNode(IO.ComfyNode):
+
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="ByteDance2TextToVideoNode",
+ display_name="ByteDance Seedance 2.0 Text to Video",
+ category="api node/video/ByteDance",
+ description="Generate video using Seedance 2.0 models based on a text prompt.",
+ inputs=[
+ IO.DynamicCombo.Input(
+ "model",
+ options=[
+ IO.DynamicCombo.Option("Seedance 2.0", _seedance2_text_inputs()),
+ IO.DynamicCombo.Option("Seedance 2.0 Fast", _seedance2_text_inputs()),
+ ],
+ tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
+ ),
+ IO.Int.Input(
+ "seed",
+ default=0,
+ min=0,
+ max=2147483647,
+ step=1,
+ display_mode=IO.NumberDisplay.number,
+ control_after_generate=True,
+ tooltip="Seed controls whether the node should re-run; "
+ "results are non-deterministic regardless of seed.",
+ ),
+ IO.Boolean.Input(
+ "watermark",
+ default=False,
+ tooltip="Whether to add a watermark to the video.",
+ advanced=True,
+ ),
+ ],
+ outputs=[
+ IO.Video.Output(),
+ ],
+ hidden=[
+ IO.Hidden.auth_token_comfy_org,
+ IO.Hidden.api_key_comfy_org,
+ IO.Hidden.unique_id,
+ ],
+ is_api_node=True,
+ price_badge=IO.PriceBadge(
+ depends_on=IO.PriceBadgeDepends(widgets=["model", "model.resolution", "model.duration"]),
+ expr="""
+ (
+ $rate480 := 10044;
+ $rate720 := 21600;
+ $m := widgets.model;
+ $pricePer1K := $contains($m, "fast") ? 0.008008 : 0.01001;
+ $res := $lookup(widgets, "model.resolution");
+ $dur := $lookup(widgets, "model.duration");
+ $rate := $res = "720p" ? $rate720 : $rate480;
+ $cost := $dur * $rate * $pricePer1K / 1000;
+ {"type": "usd", "usd": $cost, "format": {"approximate": true}}
+ )
+ """,
+ ),
+ )
+
+ @classmethod
+ async def execute(
+ cls,
+ model: dict,
+ seed: int,
+ watermark: bool,
+ ) -> IO.NodeOutput:
+ validate_string(model["prompt"], strip_whitespace=True, min_length=1)
+ model_id = SEEDANCE_MODELS[model["model"]]
+ initial_response = await sync_op(
+ cls,
+ ApiEndpoint(path=BYTEPLUS_TASK_ENDPOINT, method="POST"),
+ data=Seedance2TaskCreationRequest(
+ model=model_id,
+ content=[TaskTextContent(text=model["prompt"])],
+ generate_audio=model["generate_audio"],
+ resolution=model["resolution"],
+ ratio=model["ratio"],
+ duration=model["duration"],
+ seed=seed,
+ watermark=watermark,
+ ),
+ response_model=TaskCreationResponse,
+ )
+ response = await poll_op(
+ cls,
+ ApiEndpoint(path=f"{BYTEPLUS_SEEDANCE2_TASK_STATUS_ENDPOINT}/{initial_response.id}"),
+ response_model=TaskStatusResponse,
+ status_extractor=lambda r: r.status,
+ price_extractor=_seedance2_price_extractor(model_id, has_video_input=False),
+ poll_interval=9,
+ )
+ return IO.NodeOutput(await download_url_to_video_output(response.content.video_url))
+
+
+class ByteDance2FirstLastFrameNode(IO.ComfyNode):
+
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="ByteDance2FirstLastFrameNode",
+ display_name="ByteDance Seedance 2.0 First-Last-Frame to Video",
+ category="api node/video/ByteDance",
+ description="Generate video using Seedance 2.0 from a first frame image and optional last frame image.",
+ inputs=[
+ IO.DynamicCombo.Input(
+ "model",
+ options=[
+ IO.DynamicCombo.Option("Seedance 2.0", _seedance2_text_inputs()),
+ IO.DynamicCombo.Option("Seedance 2.0 Fast", _seedance2_text_inputs()),
+ ],
+ tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
+ ),
+ IO.Image.Input(
+ "first_frame",
+ tooltip="First frame image for the video.",
+ ),
+ IO.Image.Input(
+ "last_frame",
+ tooltip="Last frame image for the video.",
+ optional=True,
+ ),
+ IO.Int.Input(
+ "seed",
+ default=0,
+ min=0,
+ max=2147483647,
+ step=1,
+ display_mode=IO.NumberDisplay.number,
+ control_after_generate=True,
+ tooltip="Seed controls whether the node should re-run; "
+ "results are non-deterministic regardless of seed.",
+ ),
+ IO.Boolean.Input(
+ "watermark",
+ default=False,
+ tooltip="Whether to add a watermark to the video.",
+ advanced=True,
+ ),
+ ],
+ outputs=[
+ IO.Video.Output(),
+ ],
+ hidden=[
+ IO.Hidden.auth_token_comfy_org,
+ IO.Hidden.api_key_comfy_org,
+ IO.Hidden.unique_id,
+ ],
+ is_api_node=True,
+ price_badge=IO.PriceBadge(
+ depends_on=IO.PriceBadgeDepends(widgets=["model", "model.resolution", "model.duration"]),
+ expr="""
+ (
+ $rate480 := 10044;
+ $rate720 := 21600;
+ $m := widgets.model;
+ $pricePer1K := $contains($m, "fast") ? 0.008008 : 0.01001;
+ $res := $lookup(widgets, "model.resolution");
+ $dur := $lookup(widgets, "model.duration");
+ $rate := $res = "720p" ? $rate720 : $rate480;
+ $cost := $dur * $rate * $pricePer1K / 1000;
+ {"type": "usd", "usd": $cost, "format": {"approximate": true}}
+ )
+ """,
+ ),
+ )
+
+ @classmethod
+ async def execute(
+ cls,
+ model: dict,
+ first_frame: Input.Image,
+ seed: int,
+ watermark: bool,
+ last_frame: Input.Image | None = None,
+ ) -> IO.NodeOutput:
+ validate_string(model["prompt"], strip_whitespace=True, min_length=1)
+ model_id = SEEDANCE_MODELS[model["model"]]
+
+ content: list[TaskTextContent | TaskImageContent] = [
+ TaskTextContent(text=model["prompt"]),
+ TaskImageContent(
+ image_url=TaskImageContentUrl(
+ url=await upload_image_to_comfyapi(cls, first_frame, wait_label="Uploading first frame.")
+ ),
+ role="first_frame",
+ ),
+ ]
+ if last_frame is not None:
+ content.append(
+ TaskImageContent(
+ image_url=TaskImageContentUrl(
+ url=await upload_image_to_comfyapi(cls, last_frame, wait_label="Uploading last frame.")
+ ),
+ role="last_frame",
+ ),
+ )
+
+ initial_response = await sync_op(
+ cls,
+ ApiEndpoint(path=BYTEPLUS_TASK_ENDPOINT, method="POST"),
+ data=Seedance2TaskCreationRequest(
+ model=model_id,
+ content=content,
+ generate_audio=model["generate_audio"],
+ resolution=model["resolution"],
+ ratio=model["ratio"],
+ duration=model["duration"],
+ seed=seed,
+ watermark=watermark,
+ ),
+ response_model=TaskCreationResponse,
+ )
+ response = await poll_op(
+ cls,
+ ApiEndpoint(path=f"{BYTEPLUS_SEEDANCE2_TASK_STATUS_ENDPOINT}/{initial_response.id}"),
+ response_model=TaskStatusResponse,
+ status_extractor=lambda r: r.status,
+ price_extractor=_seedance2_price_extractor(model_id, has_video_input=False),
+ poll_interval=9,
+ )
+ return IO.NodeOutput(await download_url_to_video_output(response.content.video_url))
+
+
+def _seedance2_reference_inputs():
+ return [
+ *_seedance2_text_inputs(),
+ IO.Autogrow.Input(
+ "reference_images",
+ template=IO.Autogrow.TemplateNames(
+ IO.Image.Input("reference_image"),
+ names=[
+ "image_1",
+ "image_2",
+ "image_3",
+ "image_4",
+ "image_5",
+ "image_6",
+ "image_7",
+ "image_8",
+ "image_9",
+ ],
+ min=0,
+ ),
+ ),
+ IO.Autogrow.Input(
+ "reference_videos",
+ template=IO.Autogrow.TemplateNames(
+ IO.Video.Input("reference_video"),
+ names=["video_1", "video_2", "video_3"],
+ min=0,
+ ),
+ ),
+ IO.Autogrow.Input(
+ "reference_audios",
+ template=IO.Autogrow.TemplateNames(
+ IO.Audio.Input("reference_audio"),
+ names=["audio_1", "audio_2", "audio_3"],
+ min=0,
+ ),
+ ),
+ ]
+
+
+class ByteDance2ReferenceNode(IO.ComfyNode):
+
+ @classmethod
+ def define_schema(cls):
+ return IO.Schema(
+ node_id="ByteDance2ReferenceNode",
+ display_name="ByteDance Seedance 2.0 Reference to Video",
+ category="api node/video/ByteDance",
+ description="Generate, edit, or extend video using Seedance 2.0 with reference images, "
+ "videos, and audio. Supports multimodal reference, video editing, and video extension.",
+ inputs=[
+ IO.DynamicCombo.Input(
+ "model",
+ options=[
+ IO.DynamicCombo.Option("Seedance 2.0", _seedance2_reference_inputs()),
+ IO.DynamicCombo.Option("Seedance 2.0 Fast", _seedance2_reference_inputs()),
+ ],
+ tooltip="Seedance 2.0 for maximum quality; Seedance 2.0 Fast for speed optimization.",
+ ),
+ IO.Int.Input(
+ "seed",
+ default=0,
+ min=0,
+ max=2147483647,
+ step=1,
+ display_mode=IO.NumberDisplay.number,
+ control_after_generate=True,
+ tooltip="Seed controls whether the node should re-run; "
+ "results are non-deterministic regardless of seed.",
+ ),
+ IO.Boolean.Input(
+ "watermark",
+ default=False,
+ tooltip="Whether to add a watermark to the video.",
+ advanced=True,
+ ),
+ ],
+ outputs=[
+ IO.Video.Output(),
+ ],
+ hidden=[
+ IO.Hidden.auth_token_comfy_org,
+ IO.Hidden.api_key_comfy_org,
+ IO.Hidden.unique_id,
+ ],
+ is_api_node=True,
+ price_badge=IO.PriceBadge(
+ depends_on=IO.PriceBadgeDepends(
+ widgets=["model", "model.resolution", "model.duration"],
+ input_groups=["model.reference_videos"],
+ ),
+ expr="""
+ (
+ $rate480 := 10044;
+ $rate720 := 21600;
+ $m := widgets.model;
+ $hasVideo := $lookup(inputGroups, "model.reference_videos") > 0;
+ $noVideoPricePer1K := $contains($m, "fast") ? 0.008008 : 0.01001;
+ $videoPricePer1K := $contains($m, "fast") ? 0.004719 : 0.006149;
+ $res := $lookup(widgets, "model.resolution");
+ $dur := $lookup(widgets, "model.duration");
+ $rate := $res = "720p" ? $rate720 : $rate480;
+ $noVideoCost := $dur * $rate * $noVideoPricePer1K / 1000;
+ $minVideoFactor := $ceil($dur * 5 / 3);
+ $minVideoCost := $minVideoFactor * $rate * $videoPricePer1K / 1000;
+ $maxVideoCost := (15 + $dur) * $rate * $videoPricePer1K / 1000;
+ $hasVideo
+ ? {
+ "type": "range_usd",
+ "min_usd": $minVideoCost,
+ "max_usd": $maxVideoCost,
+ "format": {"approximate": true}
+ }
+ : {
+ "type": "usd",
+ "usd": $noVideoCost,
+ "format": {"approximate": true}
+ }
+ )
+ """,
+ ),
+ )
+
+ @classmethod
+ async def execute(
+ cls,
+ model: dict,
+ seed: int,
+ watermark: bool,
+ ) -> IO.NodeOutput:
+ validate_string(model["prompt"], strip_whitespace=True, min_length=1)
+
+ reference_images = model.get("reference_images", {})
+ reference_videos = model.get("reference_videos", {})
+ reference_audios = model.get("reference_audios", {})
+
+ if not reference_images and not reference_videos:
+ raise ValueError("At least one reference image or video is required.")
+
+ model_id = SEEDANCE_MODELS[model["model"]]
+ has_video_input = len(reference_videos) > 0
+ total_video_duration = 0.0
+ for i, key in enumerate(reference_videos, 1):
+ video = reference_videos[key]
+ _validate_ref_video_pixels(video, model_id, i)
+ try:
+ dur = video.get_duration()
+ if dur < 1.8:
+ raise ValueError(f"Reference video {i} is too short: {dur:.1f}s. Minimum duration is 1.8 seconds.")
+ total_video_duration += dur
+ except ValueError:
+ raise
+ except Exception:
+ pass
+ if total_video_duration > 15.1:
+ raise ValueError(f"Total reference video duration is {total_video_duration:.1f}s. Maximum is 15.1 seconds.")
+
+ total_audio_duration = 0.0
+ for i, key in enumerate(reference_audios, 1):
+ audio = reference_audios[key]
+ dur = int(audio["waveform"].shape[-1]) / int(audio["sample_rate"])
+ if dur < 1.8:
+ raise ValueError(f"Reference audio {i} is too short: {dur:.1f}s. Minimum duration is 1.8 seconds.")
+ total_audio_duration += dur
+ if total_audio_duration > 15.1:
+ raise ValueError(f"Total reference audio duration is {total_audio_duration:.1f}s. Maximum is 15.1 seconds.")
+
+ content: list[TaskTextContent | TaskImageContent | TaskVideoContent | TaskAudioContent] = [
+ TaskTextContent(text=model["prompt"]),
+ ]
+ for i, key in enumerate(reference_images, 1):
+ content.append(
+ TaskImageContent(
+ image_url=TaskImageContentUrl(
+ url=await upload_image_to_comfyapi(
+ cls,
+ image=reference_images[key],
+ wait_label=f"Uploading image {i}",
+ ),
+ ),
+ role="reference_image",
+ ),
+ )
+ for i, key in enumerate(reference_videos, 1):
+ content.append(
+ TaskVideoContent(
+ video_url=TaskVideoContentUrl(
+ url=await upload_video_to_comfyapi(
+ cls,
+ reference_videos[key],
+ wait_label=f"Uploading video {i}",
+ ),
+ ),
+ ),
+ )
+ for key in reference_audios:
+ content.append(
+ TaskAudioContent(
+ audio_url=TaskAudioContentUrl(
+ url=await upload_audio_to_comfyapi(
+ cls,
+ reference_audios[key],
+ container_format="mp3",
+ codec_name="libmp3lame",
+ mime_type="audio/mpeg",
+ ),
+ ),
+ ),
+ )
+ initial_response = await sync_op(
+ cls,
+ ApiEndpoint(path=BYTEPLUS_TASK_ENDPOINT, method="POST"),
+ data=Seedance2TaskCreationRequest(
+ model=model_id,
+ content=content,
+ generate_audio=model["generate_audio"],
+ resolution=model["resolution"],
+ ratio=model["ratio"],
+ duration=model["duration"],
+ seed=seed,
+ watermark=watermark,
+ ),
+ response_model=TaskCreationResponse,
+ )
+ response = await poll_op(
+ cls,
+ ApiEndpoint(path=f"{BYTEPLUS_SEEDANCE2_TASK_STATUS_ENDPOINT}/{initial_response.id}"),
+ response_model=TaskStatusResponse,
+ status_extractor=lambda r: r.status,
+ price_extractor=_seedance2_price_extractor(model_id, has_video_input=has_video_input),
+ poll_interval=9,
+ )
+ return IO.NodeOutput(await download_url_to_video_output(response.content.video_url))
+
+
+async def process_video_task(
+ cls: type[IO.ComfyNode],
+ payload: Text2VideoTaskCreationRequest | Image2VideoTaskCreationRequest,
+ estimated_duration: int | None,
+) -> IO.NodeOutput:
+ if payload.model in DEPRECATED_MODELS:
+ logger.warning(
+ "Model '%s' is deprecated and will be deactivated on May 13, 2026. "
+ "Please switch to a newer model. Recommended: seedance-1-0-pro-fast-251015.",
+ payload.model,
+ )
+ initial_response = await sync_op(
+ cls,
+ ApiEndpoint(path=BYTEPLUS_TASK_ENDPOINT, method="POST"),
+ data=payload,
+ response_model=TaskCreationResponse,
+ )
+ response = await poll_op(
+ cls,
+ ApiEndpoint(path=f"{BYTEPLUS_TASK_STATUS_ENDPOINT}/{initial_response.id}"),
+ status_extractor=lambda r: r.status,
+ estimated_duration=estimated_duration,
+ response_model=TaskStatusResponse,
+ )
+ return IO.NodeOutput(await download_url_to_video_output(response.content.video_url))
+
+
class ByteDanceExtension(ComfyExtension):
@override
async def get_node_list(self) -> list[type[IO.ComfyNode]]:
@@ -1050,6 +1600,9 @@ class ByteDanceExtension(ComfyExtension):
ByteDanceImageToVideoNode,
ByteDanceFirstLastFrameNode,
ByteDanceImageReferenceNode,
+ ByteDance2TextToVideoNode,
+ ByteDance2FirstLastFrameNode,
+ ByteDance2ReferenceNode,
]