fix

* feat: enhance apply_random_seed_to_workflow function to support KSampler node type and handle fixed seed settings

* refactor: add flag to skip randomization in apply_random_seed_to_workflow for KSampler nodes

* tweak

comfy-nodes/external_lora.py

@@ -1,8 +1,4 @@
 import folder_paths
-from PIL import Image, ImageOps
-import numpy as np
-import torch
-import folder_paths
 
 
 class AnyType(str):
@@ -41,6 +37,10 @@ class ComfyUIDeployExternalLora:
                     "STRING",
                     {"multiline": False, "default": ""},
                 ),
+                "bearer_token": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
             },
         }
 
@@ -57,6 +57,7 @@ class ComfyUIDeployExternalLora:
         display_name=None,
         description=None,
         lora_url=None,
+        bearer_token=None,
     ):
         import requests
         import os
@@ -84,9 +85,13 @@ class ComfyUIDeployExternalLora:
                     + " to "
                     + destination_path
                 )
+                headers = {"User-Agent": "Mozilla/5.0"}
+                if bearer_token:
+                    headers["Authorization"] = f"Bearer {bearer_token}"
+                    print("using bearer token")
                 response = requests.get(
                     lora_url,
-                    headers={"User-Agent": "Mozilla/5.0"},
+                    headers=headers,
                     allow_redirects=True,
                 )
                 with open(destination_path, "wb") as out_file:

comfy-nodes/external_seed.py

@@ -0,0 +1,116 @@
+import random
+
+
+class ComfyUIDeployExternalSeed:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "input_id": (
+                    "STRING",
+                    {"multiline": False, "default": "input_seed"},
+                ),
+                "default_value": (
+                    "INT",
+                    {"default": -1},
+                ),
+                "min_value": (
+                    "INT",
+                    {"default": 1, "min": 1, "max": 999999999999999},
+                ),
+                "max_value": (
+                    "INT",
+                    {"default": 4294967295, "min": 1, "max": 999999999999999},
+                ),
+            },
+            "optional": {
+                "display_name": (
+                    "STRING",
+                    {"multiline": False, "default": ""},
+                ),
+                "description": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": 'For default value:\n"-1" (i.e. not in range): Randomize within the min and max value range. \nin range: Fixed, always the same value\n',
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("seed",)
+    FUNCTION = "run"
+    CATEGORY = "🔗ComfyDeploy"
+
+    # Limits
+    _MAX_LIMIT = 999_999_999_999_999  # 15 digits
+
+    # Store cached seed when fixed flag is enabled
+    _cached_seed = None
+
+    @classmethod
+    def IS_CHANGED(
+        cls,
+        input_id,
+        min_value,
+        max_value,
+        default_value=None,
+        **kwargs,
+    ):
+        """Inform ComfyUI whether the node output should be considered changed.
+
+        If default_value is within range (Fixed mode), we return the inputs tuple
+        so the cached result is reused until the user changes something.
+        For Randomize mode, we force re-execution each queue.
+        """
+        # Clamp values to allowed range for check
+        min_value = max(1, min_value)
+        max_value = min(cls._MAX_LIMIT, max_value)
+
+        # Fixed mode when default_value is within range
+        if (
+            default_value is not None
+            and default_value >= min_value
+            and default_value <= max_value
+        ):
+            return (input_id, default_value)
+
+        # For Randomize (default_value is -1 or out of range) we force re-execution
+        import random as _rnd
+
+        return _rnd.random()
+
+    def run(
+        self,
+        input_id,
+        min_value: int,
+        max_value: int,
+        display_name=None,
+        description=None,
+        default_value: int = -1,
+    ):
+        # Clamp values to allowed range
+        min_value = max(1, min_value)
+        max_value = min(self._MAX_LIMIT, max_value)
+
+        # Ensure limits are in correct order after clamping
+        if min_value > max_value:
+            min_value, max_value = max_value, min_value
+
+        # Fixed mode: default_value is within range
+        if default_value >= min_value and default_value <= max_value:
+            seed = int(default_value)
+            self._cached_seed = seed
+            return [seed]
+
+        # Randomize mode: default_value is -1 or out of range
+        seed = random.randint(min_value, max_value)
+        self._cached_seed = seed
+        return [seed]
+
+
+NODE_CLASS_MAPPINGS = {"ComfyUIDeployExternalSeed": ComfyUIDeployExternalSeed}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "ComfyUIDeployExternalSeed": "External Seed (ComfyUI Deploy)"
+}

custom_routes.py

@@ -158,6 +158,8 @@ from logging import basicConfig, getLogger
 # Check for an environment variable to enable/disable Logfire
 use_logfire = os.environ.get("USE_LOGFIRE", "false").lower() == "true"
 
+API_KEY_COMFY_ORG = os.environ.get("API_KEY_COMFY_ORG", None)
+
 if use_logfire:
     try:
         import logfire
@@ -283,6 +285,9 @@ def post_prompt(json_data):
         if "extra_data" in json_data:
             extra_data = json_data["extra_data"]
 
+        if API_KEY_COMFY_ORG is not None:
+            extra_data["api_key_comfy_org"] = API_KEY_COMFY_ORG
+
         if "client_id" in json_data:
             extra_data["client_id"] = json_data["client_id"]
         if valid[0]:
@@ -316,7 +321,7 @@ def randomSeed(num_digits=15):
     return random.randint(range_start, range_end)
 
 
-def apply_random_seed_to_workflow(workflow_api):
+def apply_random_seed_to_workflow(workflow_api, workflow):
     """
     Applies a random seed to each element in the workflow_api that has a 'seed' input.
 
@@ -329,6 +334,41 @@ def apply_random_seed_to_workflow(workflow_api):
                 # If seed is a list, it's an input from another node (generally `external number int`)
                 if isinstance(workflow_api[key]["inputs"]["seed"], list):
                     continue
+
+                # Check node type in workflow to determine if we should randomize
+                node_id = key
+                should_skip = (
+                    False  # Add a flag to track if we should skip randomization
+                )
+
+                for node in workflow["nodes"]:
+                    if str(node["id"]) == node_id and node["type"] == "KSampler":
+                        # Check if this node has widgets_values and if seed setting is not "fixed"
+                        if "widgets_values" in node and len(node["widgets_values"]) > 1:
+                            seed_mode = node["widgets_values"][1]
+                            if seed_mode == "fixed":
+                                # Skip randomization for fixed seeds
+                                logger.info(
+                                    f"Skipping random seed for KSampler (node {node_id}) as it's set to fixed"
+                                )
+                                should_skip = True  # Set the flag to skip randomization
+                                break  # Exit the inner loop
+
+                            # Apply random seed for non-fixed seeds (randomize, iter, etc.)
+                            workflow_api[key]["inputs"]["seed"] = randomSeed()
+                            logger.info(
+                                f"Applied random seed {workflow_api[key]['inputs']['seed']} to KSampler (node {node_id})"
+                            )
+                            should_skip = (
+                                True  # Set the flag to skip default randomization
+                            )
+                            break  # Exit the inner loop
+                        break  # This break will skip checking other nodes if widgets_values doesn't exist
+
+                # Skip the rest of the code for this key if we already handled it
+                if should_skip:
+                    continue
+
                 # Special case for SONICSampler
                 if workflow_api[key]["class_type"] == "SONICSampler":
                     workflow_api[key]["inputs"]["seed"] = randomSeed("sonic")
@@ -436,6 +476,12 @@ def apply_inputs_to_workflow(workflow_api: Any, inputs: Any, sid: str = None):
                 if value["class_type"] == "ComfyUIDeployExternalEXR":
                     value["inputs"]["exr_file"] = new_value
 
+                if value["class_type"] == "ComfyUIDeployExternalSeed":
+                    logger.info(
+                        f"Applied random seed {new_value} to {value['class_type']}"
+                    )
+                    value["inputs"]["default_value"] = new_value
+
 
 def send_prompt(sid: str, inputs: StreamingPrompt):
     # workflow_api = inputs.workflow_api
@@ -443,7 +489,7 @@ def send_prompt(sid: str, inputs: StreamingPrompt):
     workflow = copy.deepcopy(inputs.workflow)
 
     # Random seed
-    apply_random_seed_to_workflow(workflow_api)
+    apply_random_seed_to_workflow(workflow_api, workflow)
 
     logger.info("getting inputs", inputs.inputs)
 
@@ -529,7 +575,7 @@ async def comfy_deploy_run(request):
     workflow = data.get("workflow")
 
     # Now it handles directly in here
-    apply_random_seed_to_workflow(workflow_api)
+    apply_random_seed_to_workflow(workflow_api, workflow)
     apply_inputs_to_workflow(workflow_api, inputs)
 
     prompt = {
@@ -596,7 +642,7 @@ async def stream_prompt(data, token):
     gpu_event_id = data.get("gpu_event_id", None)
 
     # Now it handles directly in here
-    apply_random_seed_to_workflow(workflow_api)
+    apply_random_seed_to_workflow(workflow_api, workflow)
     apply_inputs_to_workflow(workflow_api, inputs)
 
     prompt = {
@@ -2010,13 +2056,14 @@ async def upload_in_background(
                 ("files", "content_type", "image/png"),
                 ("gifs", "format", "image/gif"),
                 ("model_file", "format", "application/octet-stream"),
+                ("result", "format", "application/octet-stream"),
                 ("text_file", "format", "text/plain"),
             ]:
                 items = data.get(file_type, [])
 
                 for item in items:
                     # if is model_file, just add it to the data
-                    if file_type == "model_file":
+                    if file_type == "model_file" or file_type == "result":
                         if isinstance(item, str):
                             filename = os.path.basename(item)
                             # Extract folder name from the path
@@ -2096,6 +2143,7 @@ async def update_run_with_output(
             or "files" in data
             or "gifs" in data
             or "model_file" in data
+            or "result" in data
             or "text_file" in data
         )
     if bypass_upload and have_upload_media: