feat: Add Bytedance provider settings support

- Added provider settings and reference images support to image inference
- Created Runware Bytedance Provider Settings node with cameraFixed and maxSequentialImages
- Updated image inference to handle provider settings and reference images
- Added debug logging for request/response tracking
- Increased timeout from 90 to 180 seconds
- Fixed parameter handling for conditional inclusion

__init__.py

@@ -31,8 +31,9 @@ from .modules.frameImages import RunwareFrameImages
 from .modules.providerSettings import RunwareProviderSettings
 from .modules.pixverseProviderSettings import RunwarePixverseProviderSettings
 from .modules.openaiProviderSettings import RunwareOpenAIProviderSettings
+from .modules.bytedanceImageProviderSettings import RunwareBytedanceProviderSettings
 
-RUNWARE_COMFYUI_VERSION = "1.4.0 Beta"
+RUNWARE_COMFYUI_VERSION = "1.3.0 Beta"
 
 RESET_COLOR = "\033[0m"
 BLUE_COLOR = "\033[94m"
@@ -76,6 +77,7 @@ NODE_CLASS_MAPPINGS = {
     "Runware Provider Settings": RunwareProviderSettings,
     "Runware Pixverse Provider Settings": RunwarePixverseProviderSettings,
     "Runware OpenAI Provider Settings": RunwareOpenAIProviderSettings,
+    "Runware Bytedance Provider Settings": RunwareBytedanceProviderSettings,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {

modules/bytedanceImageProviderSettings.py

@@ -0,0 +1,65 @@
+"""
+Runware Bytedance Image Provider Settings Node
+Provides Bytedance-specific settings for image generation
+"""
+
+import torch
+from typing import Optional, Dict, Any
+
+class RunwareBytedanceProviderSettings:
+    """Runware Bytedance Image Provider Settings Node"""
+    
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {},
+            "optional": {
+                "cameraFixed": ("BOOLEAN", {
+                    "tooltip": "Enable to fix camera position during video generation",
+                    "default": False,
+                }),
+                "maxSequentialImages": ("INT", {
+                    "tooltip": "Maximum number of sequential images to generate (1-15)",
+                    "default": 1,
+                    "min": 1,
+                    "max": 15,
+                }),
+            }
+        }
+    
+    RETURN_TYPES = ("RUNWAREPROVIDERSETTINGS",)
+    RETURN_NAMES = ("providerSettings",)
+    FUNCTION = "create_provider_settings"
+    CATEGORY = "Runware/Provider Settings"
+    
+    def create_provider_settings(self, **kwargs) -> tuple[Dict[str, Any]]:
+        """Create Bytedance provider settings"""
+        
+        # Get parameters
+        cameraFixed = kwargs.get("cameraFixed", False)
+        maxSequentialImages = kwargs.get("maxSequentialImages", 1)
+        
+        # Build settings dictionary
+        settings = {}
+        
+        # Add cameraFixed only if it's true
+        if cameraFixed is True:
+            settings["cameraFixed"] = cameraFixed
+        
+        # Add maxSequentialImages if provided and valid
+        if maxSequentialImages is not None and 1 <= maxSequentialImages <= 15:
+            settings["maxSequentialImages"] = maxSequentialImages
+        
+        # Clean up None values
+        settings = {k: v for k, v in settings.items() if v is not None}
+        
+        return (settings,)
+
+# Node class mappings
+NODE_CLASS_MAPPINGS = {
+    "RunwareBytedanceProviderSettings": RunwareBytedanceProviderSettings,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "RunwareBytedanceProviderSettings": "Runware Bytedance Provider Settings",
+}

modules/imageInference.py

@@ -1,4 +1,5 @@
 from .utils import runwareUtils as rwUtils
+import json
 
 
 class txt2img:
@@ -153,6 +154,12 @@ class txt2img:
                 "VAE": ("RUNWAREVAE", {
                     "tooltip": "Connect a Runware VAE Node to help the model generate images that align with the desired structure.",
                 }),
+                "referenceImages": ("RUNWAREREFERENCEIMAGES", {
+                    "tooltip": "Connect a Runware Reference Images Node to provide visual guidance for image generation.",
+                }),
+                "providerSettings": ("RUNWAREPROVIDERSETTINGS", {
+                    "tooltip": "Connect a Runware Provider Settings Node to configure provider-specific parameters.",
+                }),
             }
         }
 
@@ -186,6 +193,8 @@ class txt2img:
         runwareRefiner = kwargs.get("Refiner", None)
         runwareEmbedding = kwargs.get("Embeddings", None)
         runwareVAE = kwargs.get("VAE", None)
+        referenceImages = kwargs.get("referenceImages", None)
+        providerSettings = kwargs.get("providerSettings", None)
         seedImage = kwargs.get("seedImage", None)
         seedImageStrength = kwargs.get("strength", 0.8)
         maskImage = kwargs.get("maskImage", None)
@@ -278,9 +287,38 @@ class txt2img:
                 if (enableMaskMargin):
                     genConfig[0]["maskMargin"] = maskImageMargin
 
+        # Handle referenceImages
+        if referenceImages is not None:
+            genConfig[0]["referenceImages"] = referenceImages
+
+        # Handle providerSettings - extract provider name from model and merge with custom settings
+        if providerSettings is not None:
+            # Extract provider name from model (e.g., "bytedance:1@1" -> "bytedance")
+            provider_name = runwareModel.split(":")[0] if ":" in runwareModel else runwareModel
+            
+            # If providerSettings is a dictionary, create the correct API format
+            if isinstance(providerSettings, dict):
+                # Create the providerSettings object with provider name as key
+                final_provider_settings = {
+                    provider_name: providerSettings
+                }
+                genConfig[0]["providerSettings"] = final_provider_settings
+            else:
+                # If it's already in the correct format, use it directly
+                genConfig[0]["providerSettings"] = providerSettings
+
         if (multiInferenceMode):
             return (None, genConfig)
         else:
+            # Debug: Print the request being sent
+            print(f"[DEBUG] Sending Image Inference Request:")
+            print(f"[DEBUG] Request Payload: {json.dumps(genConfig, indent=2)}")
+            
             genResult = rwUtils.inferenecRequest(genConfig)
+            
+            # Debug: Print the response received
+            print(f"[DEBUG] Received Image Inference Response:")
+            print(f"[DEBUG] Response: {json.dumps(genResult, indent=2)}")
+            
             images = rwUtils.convertImageB64List(genResult)
             return (images, None)

modules/utils/runwareUtils.py

@@ -69,7 +69,7 @@ def getTimeout():
     if timeout and timeout.isdigit():
         return int(timeout)
     else:
-        timeout = 90
+        timeout = 180
         os.environ["RUNWARE_TIMEOUT"] = str(timeout)
         return timeout
 

modules/videoInference.py

@@ -1,5 +1,6 @@
 from .utils import runwareUtils as rwUtils
 from .videoModelSearch import videoModelSearch
+import json
 
 
 class RunwareFrameImages:
@@ -282,7 +283,16 @@ class txt2vid:
             return (None, genConfig)
         else:
             try:
+                # Debug: Print the request being sent
+                print(f"[DEBUG] Sending Video Inference Request:")
+                print(f"[DEBUG] Request Payload: {json.dumps(genConfig, indent=2)}")
+                
                 genResult = rwUtils.inferenecRequest(genConfig)
+                
+                # Debug: Print the response received
+                print(f"[DEBUG] Received Video Inference Response:")
+                print(f"[DEBUG] Response: {json.dumps(genResult, indent=2)}")
+                
                 print(f"[Debugging] Generation config: {genConfig}")
             except Exception as e:
                 # Check if it's a dimension error and provide helpful information