The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
convert Minimax API nodes to the V3 schema (#9693)
Alexander Piskun45bc1f5c0030
diff --git a/comfy_api_nodes/nodes_minimax.py b/comfy_api_nodes/nodes_minimax.pyindex bb3c9e710..bf560661c 100644--- a/comfy_api_nodes/nodes_minimax.py+++ b/comfy_api_nodes/nodes_minimax.py@@ -1,9 +1,10 @@from inspect import cleandoc-from typing import Union+from typing import Optionalimport loggingimport torch-from comfy.comfy_types.node_typing import IO+from typing_extensions import override+from comfy_api.latest import ComfyExtension, io as comfy_iofrom comfy_api.input_impl.video_types import VideoFromFilefrom comfy_api_nodes.apis import (MinimaxVideoGenerationRequest,@@ -11,7 +12,7 @@ from comfy_api_nodes.apis import (MinimaxFileRetrieveResponse,MinimaxTaskResultResponse,SubjectReferenceItem,- MiniMaxModel+ MiniMaxModel,)from comfy_api_nodes.apis.client import (ApiEndpoint,@@ -31,372 +32,398 @@ from server import PromptServerI2V_AVERAGE_DURATION = 114T2V_AVERAGE_DURATION = 234-class MinimaxTextToVideoNode:++async def _generate_mm_video(+ *,+ auth: dict[str, str],+ node_id: str,+ prompt_text: str,+ seed: int,+ model: str,+ image: Optional[torch.Tensor] = None, # used for ImageToVideo+ subject: Optional[torch.Tensor] = None, # used for SubjectToVideo+ average_duration: Optional[int] = None,+) -> comfy_io.NodeOutput:+ if image is None:+ validate_string(prompt_text, field_name="prompt_text")+ # upload image, if passed in+ image_url = None+ if image is not None:+ image_url = (await upload_images_to_comfyapi(image, max_images=1, auth_kwargs=auth))[0]++ # TODO: figure out how to deal with subject properly, API returns invalid params when using S2V-01 model+ subject_reference = None+ if subject is not None:+ subject_url = (await upload_images_to_comfyapi(subject, max_images=1, auth_kwargs=auth))[0]+ subject_reference = [SubjectReferenceItem(image=subject_url)]+++ video_generate_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path="/proxy/minimax/video_generation",+ method=HttpMethod.POST,+ request_model=MinimaxVideoGenerationRequest,+ response_model=MinimaxVideoGenerationResponse,+ ),+ request=MinimaxVideoGenerationRequest(+ model=MiniMaxModel(model),+ prompt=prompt_text,+ callback_url=None,+ first_frame_image=image_url,+ subject_reference=subject_reference,+ prompt_optimizer=None,+ ),+ auth_kwargs=auth,+ )+ response = await video_generate_operation.execute()++ task_id = response.task_id+ if not task_id:+ raise Exception(f"MiniMax generation failed: {response.base_resp}")++ video_generate_operation = PollingOperation(+ poll_endpoint=ApiEndpoint(+ path="/proxy/minimax/query/video_generation",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=MinimaxTaskResultResponse,+ query_params={"task_id": task_id},+ ),+ completed_statuses=["Success"],+ failed_statuses=["Fail"],+ status_extractor=lambda x: x.status.value,+ estimated_duration=average_duration,+ node_id=node_id,+ auth_kwargs=auth,+ )+ task_result = await video_generate_operation.execute()++ file_id = task_result.file_id+ if file_id is None:+ raise Exception("Request was not successful. Missing file ID.")+ file_retrieve_operation = SynchronousOperation(+ endpoint=ApiEndpoint(+ path="/proxy/minimax/files/retrieve",+ method=HttpMethod.GET,+ request_model=EmptyRequest,+ response_model=MinimaxFileRetrieveResponse,+ query_params={"file_id": int(file_id)},+ ),+ request=EmptyRequest(),+ auth_kwargs=auth,+ )+ file_result = await file_retrieve_operation.execute()++ file_url = file_result.file.download_url+ if file_url is None:+ raise Exception(+ f"No video was found in the response. Full response: {file_result.model_dump()}"+ )+ logging.info("Generated video URL: %s", file_url)+ if node_id:+ if hasattr(file_result.file, "backup_download_url"):+ message = f"Result URL: {file_url}\nBackup URL: {file_result.file.backup_download_url}"+ else:+ message = f"Result URL: {file_url}"+ PromptServer.instance.send_progress_text(message, node_id)++ # Download and return as VideoFromFile+ video_io = await download_url_to_bytesio(file_url)+ if video_io is None:+ error_msg = f"Failed to download video from {file_url}"+ logging.error(error_msg)+ raise Exception(error_msg)+ return comfy_io.NodeOutput(VideoFromFile(video_io))+++class MinimaxTextToVideoNode(comfy_io.ComfyNode):"""Generates videos synchronously based on a prompt, and optional parameters using MiniMax's API."""- AVERAGE_DURATION = T2V_AVERAGE_DURATION-@classmethod- def INPUT_TYPES(s):- return {- "required": {- "prompt_text": (- "STRING",- {- "multiline": True,- "default": "",- "tooltip": "Text prompt to guide the video generation",- },+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="MinimaxTextToVideoNode",+ display_name="MiniMax Text to Video",+ category="api node/video/MiniMax",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.String.Input(+ "prompt_text",+ multiline=True,+ default="",+ tooltip="Text prompt to guide the video generation",),- "model": (- [- "T2V-01",- "T2V-01-Director",- ],- {- "default": "T2V-01",- "tooltip": "Model to use for video generation",- },+ comfy_io.Combo.Input(+ "model",+ options=["T2V-01", "T2V-01-Director"],+ default="T2V-01",+ tooltip="Model to use for video generation",),- },- "optional": {- "seed": (- IO.INT,- {- "default": 0,- "min": 0,- "max": 0xFFFFFFFFFFFFFFFF,- "control_after_generate": True,- "tooltip": "The random seed used for creating the noise.",- },+ comfy_io.Int.Input(+ "seed",+ default=0,+ min=0,+ max=0xFFFFFFFFFFFFFFFF,+ step=1,+ control_after_generate=True,+ tooltip="The random seed used for creating the noise.",+ optional=True,),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }-- RETURN_TYPES = ("VIDEO",)- DESCRIPTION = "Generates videos from prompts using MiniMax's API"- FUNCTION = "generate_video"- CATEGORY = "api node/video/MiniMax"- API_NODE = True-- async def generate_video(- self,- prompt_text,- seed=0,- model="T2V-01",- image: torch.Tensor=None, # used for ImageToVideo- subject: torch.Tensor=None, # used for SubjectToVideo- unique_id: Union[str, None]=None,- **kwargs,- ):- '''- Function used between MiniMax nodes - supports T2V, I2V, and S2V, based on provided arguments.- '''- if image is None:- validate_string(prompt_text, field_name="prompt_text")- # upload image, if passed in- image_url = None- if image is not None:- image_url = (await upload_images_to_comfyapi(image, max_images=1, auth_kwargs=kwargs))[0]-- # TODO: figure out how to deal with subject properly, API returns invalid params when using S2V-01 model- subject_reference = None- if subject is not None:- subject_url = (await upload_images_to_comfyapi(subject, max_images=1, auth_kwargs=kwargs))[0]- subject_reference = [SubjectReferenceItem(image=subject_url)]--- video_generate_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path="/proxy/minimax/video_generation",- method=HttpMethod.POST,- request_model=MinimaxVideoGenerationRequest,- response_model=MinimaxVideoGenerationResponse,- ),- request=MinimaxVideoGenerationRequest(- model=MiniMaxModel(model),- prompt=prompt_text,- callback_url=None,- first_frame_image=image_url,- subject_reference=subject_reference,- prompt_optimizer=None,- ),- auth_kwargs=kwargs,+ ],+ outputs=[comfy_io.Video.Output()],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,)- response = await video_generate_operation.execute()- task_id = response.task_id- if not task_id:- raise Exception(f"MiniMax generation failed: {response.base_resp}")-- video_generate_operation = PollingOperation(- poll_endpoint=ApiEndpoint(- path="/proxy/minimax/query/video_generation",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=MinimaxTaskResultResponse,- query_params={"task_id": task_id},- ),- completed_statuses=["Success"],- failed_statuses=["Fail"],- status_extractor=lambda x: x.status.value,- estimated_duration=self.AVERAGE_DURATION,- node_id=unique_id,- auth_kwargs=kwargs,- )- task_result = await video_generate_operation.execute()-- file_id = task_result.file_id- if file_id is None:- raise Exception("Request was not successful. Missing file ID.")- file_retrieve_operation = SynchronousOperation(- endpoint=ApiEndpoint(- path="/proxy/minimax/files/retrieve",- method=HttpMethod.GET,- request_model=EmptyRequest,- response_model=MinimaxFileRetrieveResponse,- query_params={"file_id": int(file_id)},- ),- request=EmptyRequest(),- auth_kwargs=kwargs,+ @classmethod+ async def execute(+ cls,+ prompt_text: str,+ model: str = "T2V-01",+ seed: int = 0,+ ) -> comfy_io.NodeOutput:+ return await _generate_mm_video(+ auth={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,+ prompt_text=prompt_text,+ seed=seed,+ model=model,+ image=None,+ subject=None,+ average_duration=T2V_AVERAGE_DURATION,)- file_result = await file_retrieve_operation.execute()- file_url = file_result.file.download_url- if file_url is None:- raise Exception(- f"No video was found in the response. Full response: {file_result.model_dump()}"- )- logging.info(f"Generated video URL: {file_url}")- if unique_id:- if hasattr(file_result.file, "backup_download_url"):- message = f"Result URL: {file_url}\nBackup URL: {file_result.file.backup_download_url}"- else:- message = f"Result URL: {file_url}"- PromptServer.instance.send_progress_text(message, unique_id)- video_io = await download_url_to_bytesio(file_url)- if video_io is None:- error_msg = f"Failed to download video from {file_url}"- logging.error(error_msg)- raise Exception(error_msg)- return (VideoFromFile(video_io),)---class MinimaxImageToVideoNode(MinimaxTextToVideoNode):+class MinimaxImageToVideoNode(comfy_io.ComfyNode):"""Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API."""- AVERAGE_DURATION = I2V_AVERAGE_DURATION-@classmethod- def INPUT_TYPES(s):- return {- "required": {- "image": (- IO.IMAGE,- {- "tooltip": "Image to use as first frame of video generation"- },+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="MinimaxImageToVideoNode",+ display_name="MiniMax Image to Video",+ category="api node/video/MiniMax",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input(+ "image",+ tooltip="Image to use as first frame of video generation",),- "prompt_text": (- "STRING",- {- "multiline": True,- "default": "",- "tooltip": "Text prompt to guide the video generation",- },+ comfy_io.String.Input(+ "prompt_text",+ multiline=True,+ default="",+ tooltip="Text prompt to guide the video generation",),- "model": (- [- "I2V-01-Director",- "I2V-01",- "I2V-01-live",- ],- {- "default": "I2V-01",- "tooltip": "Model to use for video generation",- },+ comfy_io.Combo.Input(+ "model",+ options=["I2V-01-Director", "I2V-01", "I2V-01-live"],+ default="I2V-01",+ tooltip="Model to use for video generation",),- },- "optional": {- "seed": (- IO.INT,- {- "default": 0,- "min": 0,- "max": 0xFFFFFFFFFFFFFFFF,- "control_after_generate": True,- "tooltip": "The random seed used for creating the noise.",- },+ comfy_io.Int.Input(+ "seed",+ default=0,+ min=0,+ max=0xFFFFFFFFFFFFFFFF,+ step=1,+ control_after_generate=True,+ tooltip="The random seed used for creating the noise.",+ optional=True,),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }+ ],+ outputs=[comfy_io.Video.Output()],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- RETURN_TYPES = ("VIDEO",)- DESCRIPTION = "Generates videos from an image and prompts using MiniMax's API"- FUNCTION = "generate_video"- CATEGORY = "api node/video/MiniMax"- API_NODE = True+ @classmethod+ async def execute(+ cls,+ image: torch.Tensor,+ prompt_text: str,+ model: str = "I2V-01",+ seed: int = 0,+ ) -> comfy_io.NodeOutput:+ return await _generate_mm_video(+ auth={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,+ prompt_text=prompt_text,+ seed=seed,+ model=model,+ image=image,+ subject=None,+ average_duration=I2V_AVERAGE_DURATION,+ )-class MinimaxSubjectToVideoNode(MinimaxTextToVideoNode):+class MinimaxSubjectToVideoNode(comfy_io.ComfyNode):"""Generates videos synchronously based on an image and prompt, and optional parameters using MiniMax's API."""- AVERAGE_DURATION = T2V_AVERAGE_DURATION-@classmethod- def INPUT_TYPES(s):- return {- "required": {- "subject": (- IO.IMAGE,- {- "tooltip": "Image of subject to reference video generation"- },+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="MinimaxSubjectToVideoNode",+ display_name="MiniMax Subject to Video",+ category="api node/video/MiniMax",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.Image.Input(+ "subject",+ tooltip="Image of subject to reference for video generation",),- "prompt_text": (- "STRING",- {- "multiline": True,- "default": "",- "tooltip": "Text prompt to guide the video generation",- },+ comfy_io.String.Input(+ "prompt_text",+ multiline=True,+ default="",+ tooltip="Text prompt to guide the video generation",),- "model": (- [- "S2V-01",- ],- {- "default": "S2V-01",- "tooltip": "Model to use for video generation",- },+ comfy_io.Combo.Input(+ "model",+ options=["S2V-01"],+ default="S2V-01",+ tooltip="Model to use for video generation",),- },- "optional": {- "seed": (- IO.INT,- {- "default": 0,- "min": 0,- "max": 0xFFFFFFFFFFFFFFFF,- "control_after_generate": True,- "tooltip": "The random seed used for creating the noise.",- },+ comfy_io.Int.Input(+ "seed",+ default=0,+ min=0,+ max=0xFFFFFFFFFFFFFFFF,+ step=1,+ control_after_generate=True,+ tooltip="The random seed used for creating the noise.",+ optional=True,),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }+ ],+ outputs=[comfy_io.Video.Output()],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- RETURN_TYPES = ("VIDEO",)- DESCRIPTION = "Generates videos from an image and prompts using MiniMax's API"- FUNCTION = "generate_video"- CATEGORY = "api node/video/MiniMax"- API_NODE = True+ @classmethod+ async def execute(+ cls,+ subject: torch.Tensor,+ prompt_text: str,+ model: str = "S2V-01",+ seed: int = 0,+ ) -> comfy_io.NodeOutput:+ return await _generate_mm_video(+ auth={+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ },+ node_id=cls.hidden.unique_id,+ prompt_text=prompt_text,+ seed=seed,+ model=model,+ image=None,+ subject=subject,+ average_duration=T2V_AVERAGE_DURATION,+ )-class MinimaxHailuoVideoNode:+class MinimaxHailuoVideoNode(comfy_io.ComfyNode):"""Generates videos from prompt, with optional start frame using the new MiniMax Hailuo-02 model."""@classmethod- def INPUT_TYPES(s):- return {- "required": {- "prompt_text": (- "STRING",- {- "multiline": True,- "default": "",- "tooltip": "Text prompt to guide the video generation.",- },+ def define_schema(cls) -> comfy_io.Schema:+ return comfy_io.Schema(+ node_id="MinimaxHailuoVideoNode",+ display_name="MiniMax Hailuo Video",+ category="api node/video/MiniMax",+ description=cleandoc(cls.__doc__ or ""),+ inputs=[+ comfy_io.String.Input(+ "prompt_text",+ multiline=True,+ default="",+ tooltip="Text prompt to guide the video generation.",),- },- "optional": {- "seed": (- IO.INT,- {- "default": 0,- "min": 0,- "max": 0xFFFFFFFFFFFFFFFF,- "control_after_generate": True,- "tooltip": "The random seed used for creating the noise.",- },+ comfy_io.Int.Input(+ "seed",+ default=0,+ min=0,+ max=0xFFFFFFFFFFFFFFFF,+ step=1,+ control_after_generate=True,+ tooltip="The random seed used for creating the noise.",+ optional=True,),- "first_frame_image": (- IO.IMAGE,- {- "tooltip": "Optional image to use as the first frame to generate a video."- },+ comfy_io.Image.Input(+ "first_frame_image",+ tooltip="Optional image to use as the first frame to generate a video.",+ optional=True,),- "prompt_optimizer": (- IO.BOOLEAN,- {- "tooltip": "Optimize prompt to improve generation quality when needed.",- "default": True,- },+ comfy_io.Boolean.Input(+ "prompt_optimizer",+ default=True,+ tooltip="Optimize prompt to improve generation quality when needed.",+ optional=True,),- "duration": (- IO.COMBO,- {- "tooltip": "The length of the output video in seconds.",- "default": 6,- "options": [6, 10],- },+ comfy_io.Combo.Input(+ "duration",+ options=[6, 10],+ default=6,+ tooltip="The length of the output video in seconds.",+ optional=True,),- "resolution": (- IO.COMBO,- {- "tooltip": "The dimensions of the video display. "- "1080p corresponds to 1920 x 1080 pixels, 768p corresponds to 1366 x 768 pixels.",- "default": "768P",- "options": ["768P", "1080P"],- },+ comfy_io.Combo.Input(+ "resolution",+ options=["768P", "1080P"],+ default="768P",+ tooltip="The dimensions of the video display. 1080p is 1920x1080, 768p is 1366x768.",+ optional=True,),- },- "hidden": {- "auth_token": "AUTH_TOKEN_COMFY_ORG",- "comfy_api_key": "API_KEY_COMFY_ORG",- "unique_id": "UNIQUE_ID",- },- }+ ],+ outputs=[comfy_io.Video.Output()],+ hidden=[+ comfy_io.Hidden.auth_token_comfy_org,+ comfy_io.Hidden.api_key_comfy_org,+ comfy_io.Hidden.unique_id,+ ],+ is_api_node=True,+ )- RETURN_TYPES = ("VIDEO",)- DESCRIPTION = cleandoc(__doc__ or "")- FUNCTION = "generate_video"- CATEGORY = "api node/video/MiniMax"- API_NODE = True-- async def generate_video(- self,- prompt_text,- seed=0,- first_frame_image: torch.Tensor=None, # used for ImageToVideo- prompt_optimizer=True,- duration=6,- resolution="768P",- model="MiniMax-Hailuo-02",- unique_id: Union[str, None]=None,- **kwargs,- ):+ @classmethod+ async def execute(+ cls,+ prompt_text: str,+ seed: int = 0,+ first_frame_image: Optional[torch.Tensor] = None, # used for ImageToVideo+ prompt_optimizer: bool = True,+ duration: int = 6,+ resolution: str = "768P",+ model: str = "MiniMax-Hailuo-02",+ ) -> comfy_io.NodeOutput:+ auth = {+ "auth_token": cls.hidden.auth_token_comfy_org,+ "comfy_api_key": cls.hidden.api_key_comfy_org,+ }if first_frame_image is None:validate_string(prompt_text, field_name="prompt_text")@@ -408,7 +435,7 @@ class MinimaxHailuoVideoNode:# upload image, if passed inimage_url = Noneif first_frame_image is not None:- image_url = (await upload_images_to_comfyapi(first_frame_image, max_images=1, auth_kwargs=kwargs))[0]+ image_url = (await upload_images_to_comfyapi(first_frame_image, max_images=1, auth_kwargs=auth))[0]video_generate_operation = SynchronousOperation(endpoint=ApiEndpoint(@@ -426,7 +453,7 @@ class MinimaxHailuoVideoNode:duration=duration,resolution=resolution,),- auth_kwargs=kwargs,+ auth_kwargs=auth,)response = await video_generate_operation.execute()@@ -447,8 +474,8 @@ class MinimaxHailuoVideoNode:failed_statuses=["Fail"],status_extractor=lambda x: x.status.value,estimated_duration=average_duration,- node_id=unique_id,- auth_kwargs=kwargs,+ node_id=cls.hidden.unique_id,+ auth_kwargs=auth,)task_result = await video_generate_operation.execute()@@ -464,7 +491,7 @@ class MinimaxHailuoVideoNode:query_params={"file_id": int(file_id)},),request=EmptyRequest(),- auth_kwargs=kwargs,+ auth_kwargs=auth,)file_result = await file_retrieve_operation.execute()@@ -474,34 +501,31 @@ class MinimaxHailuoVideoNode:f"No video was found in the response. Full response: {file_result.model_dump()}")logging.info(f"Generated video URL: {file_url}")- if unique_id:+ if cls.hidden.unique_id:if hasattr(file_result.file, "backup_download_url"):message = f"Result URL: {file_url}\nBackup URL: {file_result.file.backup_download_url}"else:message = f"Result URL: {file_url}"- PromptServer.instance.send_progress_text(message, unique_id)+ PromptServer.instance.send_progress_text(message, cls.hidden.unique_id)video_io = await download_url_to_bytesio(file_url)if video_io is None:error_msg = f"Failed to download video from {file_url}"logging.error(error_msg)raise Exception(error_msg)- return (VideoFromFile(video_io),)---# A dictionary that contains all nodes you want to export with their names-# NOTE: names should be globally unique-NODE_CLASS_MAPPINGS = {- "MinimaxTextToVideoNode": MinimaxTextToVideoNode,- "MinimaxImageToVideoNode": MinimaxImageToVideoNode,- # "MinimaxSubjectToVideoNode": MinimaxSubjectToVideoNode,- "MinimaxHailuoVideoNode": MinimaxHailuoVideoNode,-}--# A dictionary that contains the friendly/humanly readable titles for the nodes-NODE_DISPLAY_NAME_MAPPINGS = {- "MinimaxTextToVideoNode": "MiniMax Text to Video",- "MinimaxImageToVideoNode": "MiniMax Image to Video",- "MinimaxSubjectToVideoNode": "MiniMax Subject to Video",- "MinimaxHailuoVideoNode": "MiniMax Hailuo Video",-}+ return comfy_io.NodeOutput(VideoFromFile(video_io))+++class MinimaxExtension(ComfyExtension):+ @override+ async def get_node_list(self) -> list[type[comfy_io.ComfyNode]]:+ return [+ MinimaxTextToVideoNode,+ MinimaxImageToVideoNode,+ # MinimaxSubjectToVideoNode,+ MinimaxHailuoVideoNode,+ ]+++async def comfy_entrypoint() -> MinimaxExtension:+ return MinimaxExtension()