Merge 465d1a95da into 7cf4e78335

Addresses review feedback: the V1 executability check fell back to
constructing the node (class_def()) when the FUNCTION method wasn't found on
the class. That runs __init__ during validation, so a constructor's side
effects or failure could be misreported as invalid_node_definition for an
otherwise valid node.

Inspect only the class. No core/extra node defines its FUNCTION method on the
instance, so this loses no real coverage while removing the side-effect risk.

Replace the instance-fallback test with one asserting a node with a raising
__init__ but a valid class-level method still passes validation (i.e. it is
never instantiated).

.github/workflows/cla.yml

@@ -0,0 +1,91 @@
+name: CLA Assistant
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_target:
+    types: [opened, synchronize, closed]
+
+permissions:
+  actions: write
+  contents: read # 'read' is enough because signatures live in a REMOTE repo
+  pull-requests: write
+  statuses: write
+
+jobs:
+  cla-assistant:
+    runs-on: ubuntu-latest
+    steps:
+      # The CLA action normally requires every commit author in a PR to sign.
+      # We only want the PR author to sign, so we allowlist all other committers
+      # by computing them from the PR's commits and excluding the PR author.
+      - name: Build author-only allowlist
+        id: allowlist
+        if: >
+          github.event_name == 'pull_request_target' ||
+          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
+            github.event.comment.body == 'recheck' ||
+            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
+          ))
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
+          PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
+          BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
+        run: |
+          others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
+            --jq '.[] | (.author.login // empty), (.committer.login // empty)' \
+            | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
+          if [ -n "$others" ]; then
+            echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"
+          else
+            echo "allowlist=${BASE_ALLOWLIST}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: CLA Assistant
+        # Run on PR events, on "recheck" comment, or when someone posts the exact signing phrase.
+        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
+        if: >
+          github.event_name == 'pull_request_target' ||
+          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
+            github.event.comment.body == 'recheck' ||
+            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
+          ))
+        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # PAT required to write to the centralized signatures repo.
+          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+        with:
+          # Where the CLA document lives (shown to contributors)
+          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
+
+          # Centralized signature storage
+          remote-organization-name: comfy-org
+          remote-repository-name: comfy-cla
+          path-to-signatures: signatures/cla.json
+          branch: main
+
+          # Only the PR author must sign: bots plus every non-author committer
+          # are allowlisted via the "Build author-only allowlist" step above.
+          # *[bot] is a catch-all for any GitHub App bot account.
+          allowlist: ${{ steps.allowlist.outputs.allowlist }}
+
+          # Custom PR comment messages
+          custom-notsigned-prcomment: |
+            🎉 Thank you for your contribution, we really appreciate it! 🎉
+
+            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
+
+            - Confirm that you own your contribution.
+            - Keep the right to reuse your own code.
+            - Grant us a copyright license to include and share it within our projects.
+
+            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
+
+            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
+
+          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
+
+          custom-allsigned-prcomment: |
+            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.

CLAUDE.md

@@ -1 +0,0 @@
-AGENTS.md

comfy/sd.py

@@ -468,6 +468,9 @@ class CLIP:
     def decode(self, token_ids, skip_special_tokens=True):
         return self.tokenizer.decode(token_ids, skip_special_tokens=skip_special_tokens)
 
+    def is_dynamic(self):
+        return self.patcher.is_dynamic()
+
 class VAE:
     def __init__(self, sd=None, device=None, config=None, dtype=None, metadata=None):
         if 'decoder.up_blocks.0.resnets.0.norm1.weight' in sd.keys(): #diffusers format
@@ -1251,6 +1254,8 @@ class VAE:
         except:
             return None
 
+    def is_dynamic(self):
+        return self.patcher.is_dynamic()
 
 class StyleModel:
     def __init__(self, model, device="cpu"):

comfy_execution/caching.py

@@ -503,6 +503,21 @@ RAM_CACHE_DEFAULT_RAM_USAGE = 0.05
 
 RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER = 1.3
 
+
+def all_outputs_dynamic(outputs):
+    if outputs is None:
+        return False
+
+    for output in outputs:
+        if isinstance(output, (list, tuple)):
+            if not all_outputs_dynamic(output):
+                return False
+        elif not hasattr(output, "is_dynamic") or not output.is_dynamic():
+            return False
+
+    return True
+
+
 class RAMPressureCache(LRUCache):
 
     def __init__(self, key_class, enable_providers=False):
@@ -533,7 +548,11 @@ class RAMPressureCache(LRUCache):
         for key, cache_entry in self.cache.items():
             if not free_active and self.used_generation[key] == self.generation:
                 continue
-            oom_score =  RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
+
+            if all_outputs_dynamic(cache_entry.outputs) and self.used_generation[key] == self.generation:
+                continue
+
+            oom_score = RAM_CACHE_OLD_WORKFLOW_OOM_MULTIPLIER ** (self.generation - self.used_generation[key])
 
             ram_usage = RAM_CACHE_DEFAULT_RAM_USAGE
             def scan_list_for_ram_usage(outputs):

execution.py

@@ -1113,6 +1113,32 @@ def full_type_name(klass):
         return klass.__qualname__
     return module + '.' + klass.__qualname__
 
+def node_not_executable_reason(class_def, class_type):
+    """Return a human-readable reason the node cannot be executed, or None if it's fine.
+
+    Catches a node whose declared entry point doesn't resolve to a real method
+    (e.g. a V1 ``FUNCTION = "invert"`` where the method is misspelled, or a V3 node
+    missing its ``execute`` override). Running this during validation surfaces the
+    problem before execution starts, instead of after upstream nodes have run.
+
+    Only the class is inspected; the node is never instantiated here, so a node's
+    ``__init__`` side effects cannot run (or fail) during validation.
+    """
+    try:
+        if issubclass(class_def, _ComfyNodeInternal):
+            # V3: validates that execute()/define_schema() overrides exist.
+            class_def.VALIDATE_CLASS()
+            return None
+        # V1: FUNCTION names the method to call; it must exist on the class.
+        function_name = getattr(class_def, "FUNCTION", None)
+        if function_name is None:
+            return f"'{class_type}' does not define FUNCTION"
+        if not callable(getattr(class_def, function_name, None)):
+            return f"'{class_type}' has no method '{function_name}' (declared in FUNCTION)"
+        return None
+    except Exception as ex:
+        return str(ex)
+
 async def validate_prompt(prompt_id, prompt, partial_execution_list: Union[list[str], None]):
     outputs = set()
     for x in prompt:
@@ -1148,6 +1174,35 @@ async def validate_prompt(prompt_id, prompt, partial_execution_list: Union[list[
             }
             return (False, error, [], {})
 
+        # Make sure the node is actually executable (its FUNCTION/execute entry
+        # point resolves to a real method) before we touch any schema-derived
+        # attributes below or start execution. Catches code typos up front and
+        # attributes the error to the offending node.
+        not_executable = node_not_executable_reason(class_, class_type)
+        if not_executable is not None:
+            node_title = prompt[x].get('_meta', {}).get('title', class_type)
+            error = {
+                "type": "invalid_node_definition",
+                "message": "Node is not executable",
+                "details": f"{not_executable} (Node ID '#{x}')",
+                "extra_info": {
+                    "node_id": x,
+                    "class_type": class_type,
+                    "node_title": node_title,
+                }
+            }
+            node_errors = {x: {
+                "errors": [{
+                    "type": "invalid_node_definition",
+                    "message": "Node is not executable",
+                    "details": not_executable,
+                    "extra_info": {},
+                }],
+                "dependent_outputs": [],
+                "class_type": class_type,
+            }}
+            return (False, error, [], node_errors)
+
         if hasattr(class_, 'OUTPUT_NODE') and class_.OUTPUT_NODE is True:
             if partial_execution_list is None or x in partial_execution_list:
                 outputs.add(x)

tests-unit/execution_test/validate_node_executable_test.py

@@ -0,0 +1,137 @@
+"""Tests for pre-execution validation that a node is actually executable.
+
+validate_prompt rejects a node whose declared entry point does not resolve to a
+real method (a V1 FUNCTION typo, or a V3 node missing its execute override) before
+any node runs, attributing the error to the offending node.
+"""
+import asyncio
+
+import nodes
+from comfy_api.latest import io
+from execution import node_not_executable_reason, validate_prompt
+
+
+class _GoodV1Node:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "run"
+    OUTPUT_NODE = True
+    CATEGORY = "Test"
+
+    def run(self):
+        return (None,)
+
+
+class _TypoV1Node:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "invert"  # method below is misspelled
+    OUTPUT_NODE = True
+    CATEGORY = "Test"
+
+    def invvert(self):
+        return (None,)
+
+
+class _SideEffectInitV1Node:
+    """Valid class-level method, but a constructor that must never run in validation."""
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "run"
+    OUTPUT_NODE = True
+    CATEGORY = "Test"
+
+    def __init__(self):
+        raise RuntimeError("__init__ must not run during validation")
+
+    def run(self):
+        return (None,)
+
+
+def _v3_schema(node_id):
+    return io.Schema(
+        node_id=node_id,
+        display_name=node_id,
+        category="Test",
+        inputs=[],
+        outputs=[io.Image.Output()],
+        is_output_node=True,
+    )
+
+
+class _GoodV3Node(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return _v3_schema("GoodV3Node")
+
+    @classmethod
+    def execute(cls):
+        return io.NodeOutput(None)
+
+
+class _TypoV3Node(io.ComfyNode):
+    @classmethod
+    def define_schema(cls):
+        return _v3_schema("TypoV3Node")
+
+    @classmethod
+    def exicute(cls):  # typo: should be "execute"
+        return io.NodeOutput(None)
+
+
+def _register(class_type, class_def):
+    nodes.NODE_CLASS_MAPPINGS[class_type] = class_def
+
+
+def _validate(class_type):
+    prompt = {"1": {"class_type": class_type, "inputs": {}}}
+    return asyncio.run(validate_prompt("pid", prompt, None))
+
+
+def test_good_node_passes():
+    _register("GoodV1Node", _GoodV1Node)
+    assert node_not_executable_reason(_GoodV1Node, "GoodV1Node") is None
+    valid, _, _, _ = _validate("GoodV1Node")
+    assert valid is True
+
+
+def test_typo_node_rejected_with_node_error():
+    _register("TypoV1Node", _TypoV1Node)
+    valid, error, _, node_errors = _validate("TypoV1Node")
+    assert valid is False
+    assert error["type"] == "invalid_node_definition"
+    assert node_errors["1"]["class_type"] == "TypoV1Node"
+    assert node_errors["1"]["errors"][0]["type"] == "invalid_node_definition"
+    assert "invert" in node_errors["1"]["errors"][0]["details"]
+
+
+def test_validation_does_not_instantiate_node():
+    """A valid node is not constructed during validation, so __init__ never runs."""
+    _register("SideEffectInitV1Node", _SideEffectInitV1Node)
+    assert node_not_executable_reason(_SideEffectInitV1Node, "SideEffectInitV1Node") is None
+    valid, _, _, _ = _validate("SideEffectInitV1Node")
+    assert valid is True
+
+
+def test_good_v3_node_passes():
+    _register("GoodV3Node", _GoodV3Node)
+    assert node_not_executable_reason(_GoodV3Node, "GoodV3Node") is None
+    valid, _, _, _ = _validate("GoodV3Node")
+    assert valid is True
+
+
+def test_typo_v3_node_rejected_with_node_error():
+    _register("TypoV3Node", _TypoV3Node)
+    valid, error, _, node_errors = _validate("TypoV3Node")
+    assert valid is False
+    assert error["type"] == "invalid_node_definition"
+    assert node_errors["1"]["errors"][0]["type"] == "invalid_node_definition"