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.pyindex 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.pyindex 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, Inputfrom 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.0if ("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):@overrideasync def get_node_list(self) -> list[type[IO.ComfyNode]]:@@ -1050,6 +1600,9 @@ class ByteDanceExtension(ComfyExtension):ByteDanceImageToVideoNode,ByteDanceFirstLastFrameNode,ByteDanceImageReferenceNode,+ ByteDance2TextToVideoNode,+ ByteDance2FirstLastFrameNode,+ ByteDance2ReferenceNode,]