vibe-aigc 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

vibe_aigc/__init__.py

@@ -11,9 +11,9 @@ Architecture (Paper Section 5):
 - AssetBank: Character and style consistency management
 """
 
-from .models import Vibe, WorkflowPlan, WorkflowNode, WorkflowNodeType
+from .models import Vibe, WorkflowPlan, WorkflowNode, WorkflowNodeType, GenerationRequest, CharacterProfile
 from .planner import MetaPlanner
-from .llm import LLMClient, LLMConfig
+from .llm import LLMClient, LLMConfig, LLMProvider, list_ollama_models, check_ollama_available
 from .executor import WorkflowExecutor, ExecutionStatus, ExecutionResult
 
 # Paper Section 5.3: Domain-Specific Expert Knowledge Base
@@ -78,8 +78,15 @@ __version__ = "0.2.0"
 __all__ = [
     # Core models
     "Vibe", "WorkflowPlan", "WorkflowNode", "WorkflowNodeType",
+    "GenerationRequest", "CharacterProfile",
+    # System Discovery
+    "SystemDiscovery", "SystemCapabilities", "Capability", "HardwareConstraints",
+    "AvailableNode", "AvailableModel", "discover_system",
+    # General Composer
+    "GeneralComposer", "NodeRequirement", "STANDARD_REQUIREMENTS", "create_composer",
     # MetaPlanner (Section 5.2)
-    "MetaPlanner", "LLMClient", "LLMConfig",
+    "MetaPlanner", "LLMClient", "LLMConfig", "LLMProvider",
+    "list_ollama_models", "check_ollama_available",
     # Executor
     "WorkflowExecutor", "ExecutionStatus", "ExecutionResult",
     # Knowledge Base (Section 5.3)
@@ -97,8 +104,31 @@ __all__ = [
     "DesignerAgent", "ScreenwriterAgent", "ComposerAgent",
     "create_default_agents",
     # Asset Bank
-    "AssetBank", "Character", "StyleGuide", "Artifact", "create_asset_bank"
+    "AssetBank", "Character", "StyleGuide", "Artifact", "create_asset_bank",
+    # Pipeline chaining
+    "Pipeline", "PipelineStep", "PipelineResult", "PipelineStatus",
+    "PipelineBuilder", "StepResult",
+    "create_image_pipeline", "create_video_pipeline"
 ]
+# System Discovery - Constraint-aware system discovery
+from .discovery import (
+    SystemDiscovery,
+    SystemCapabilities,
+    Capability,
+    HardwareConstraints,
+    AvailableNode,
+    AvailableModel,
+    discover_system,
+)
+
+# General Workflow Composer - Builds workflows from discovered nodes
+from .composer_general import (
+    GeneralComposer,
+    NodeRequirement,
+    STANDARD_REQUIREMENTS,
+    create_composer,
+)
+
 # Model Registry - Auto-detect available models
 from .model_registry import ModelRegistry, ModelCapability, ModelFamily, ModelSpec
 
@@ -116,3 +146,15 @@ from .audio import MusicGenBackend, RiffusionBackend, ElevenLabsBackend, MusicGe
 
 # MV Pipeline
 from .mv_pipeline import MVPipeline, Shot, Storyboard, create_mv
+
+# Pipeline chaining for workflow orchestration
+from .pipeline import (
+    Pipeline,
+    PipelineStep,
+    PipelineResult,
+    PipelineStatus,
+    PipelineBuilder,
+    StepResult,
+    create_image_pipeline,
+    create_video_pipeline
+)

vibe_aigc/composer_general.py

@@ -10,9 +10,10 @@ This composer:
 NO HARDCODED NODE TYPES. Everything is discovered.
 """
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 from dataclasses import dataclass, field
 from .discovery import SystemCapabilities, Capability, AvailableNode, AvailableModel
+from .models import GenerationRequest, CharacterProfile
 
 
 @dataclass
@@ -46,6 +47,40 @@ STANDARD_REQUIREMENTS = {
         output_types=["CLIP"],
         preferred_patterns=["cliploader"]
     ),
+    # IP-Adapter / Character consistency
+    "load_ipadapter": NodeRequirement(
+        purpose="load_ipadapter",
+        output_types=["IPADAPTER"],
+        preferred_patterns=["ipadaptermodelloader", "ipadapterloader", "ipadapter"]
+    ),
+    "load_clip_vision": NodeRequirement(
+        purpose="load_clip_vision",
+        output_types=["CLIP_VISION"],
+        preferred_patterns=["clipvisionloader", "clip_vision"]
+    ),
+    "encode_clip_vision": NodeRequirement(
+        purpose="encode_clip_vision",
+        input_types=["CLIP_VISION", "IMAGE"],
+        output_types=["CLIP_VISION_OUTPUT"],
+        preferred_patterns=["clipvisionencode"]
+    ),
+    "apply_ipadapter": NodeRequirement(
+        purpose="apply_ipadapter",
+        input_types=["MODEL", "IPADAPTER", "IMAGE"],
+        output_types=["MODEL"],
+        preferred_patterns=["ipadapterapply", "ipadapter"]
+    ),
+    "load_image": NodeRequirement(
+        purpose="load_image",
+        output_types=["IMAGE"],
+        preferred_patterns=["loadimage", "load_image"]
+    ),
+    "load_lora": NodeRequirement(
+        purpose="load_lora",
+        input_types=["MODEL", "CLIP"],
+        output_types=["MODEL", "CLIP"],
+        preferred_patterns=["loraloader", "lora"]
+    ),
     "encode_text": NodeRequirement(
         purpose="encode_text",
         input_types=["CLIP"],
@@ -425,6 +460,264 @@ class GeneralComposer:
             base["4"]["inputs"]["batch_size"] = frames
         return base
     
+    # =========================================================================
+    # CHARACTER CONSISTENCY / IP-ADAPTER SUPPORT
+    # =========================================================================
+    
+    def inject_ipadapter(
+        self,
+        workflow: Dict[str, Any],
+        reference_image: str,
+        strength: float = 0.8,
+        model_node_id: str = "1",
+        start_node_id: int = 100
+    ) -> Tuple[Dict[str, Any], str]:
+        """Inject IP-Adapter nodes into an existing workflow.
+        
+        Returns updated workflow and the new model node ID to use downstream.
+        """
+        node_id = start_node_id
+        
+        # Find IP-Adapter loader
+        ipadapter_loader = self.find_node_for(STANDARD_REQUIREMENTS["load_ipadapter"])
+        clip_vision_loader = self.find_node_for(STANDARD_REQUIREMENTS["load_clip_vision"])
+        ipadapter_apply = self.find_node_for(STANDARD_REQUIREMENTS["apply_ipadapter"])
+        load_image = self.find_node_for(STANDARD_REQUIREMENTS["load_image"])
+        
+        if not ipadapter_apply:
+            print("No IP-Adapter apply node found - skipping character reference")
+            return workflow, model_node_id
+        
+        if not load_image:
+            print("No image loader found - skipping character reference")
+            return workflow, model_node_id
+        
+        # Load reference image
+        workflow[str(node_id)] = {
+            "class_type": load_image,
+            "inputs": {"image": reference_image}
+        }
+        ref_image_node = str(node_id)
+        node_id += 1
+        
+        # Load CLIP Vision (if available and needed)
+        clip_vision_node = None
+        if clip_vision_loader:
+            clip_vision_models = self.caps.get_clip_vision_models()
+            if clip_vision_models:
+                workflow[str(node_id)] = {
+                    "class_type": clip_vision_loader,
+                    "inputs": {"clip_name": clip_vision_models[0].filename}
+                }
+                clip_vision_node = str(node_id)
+                node_id += 1
+        
+        # Load IP-Adapter model (if loader exists)
+        ipadapter_model_node = None
+        if ipadapter_loader:
+            ipadapter_models = self.caps.get_ipadapter_models()
+            if ipadapter_models:
+                workflow[str(node_id)] = {
+                    "class_type": ipadapter_loader,
+                    "inputs": {"ipadapter_file": ipadapter_models[0].filename}
+                }
+                ipadapter_model_node = str(node_id)
+                node_id += 1
+        
+        # Apply IP-Adapter
+        apply_inputs = {
+            "model": [model_node_id, 0],
+            "image": [ref_image_node, 0],
+            "weight": strength,
+        }
+        
+        # Add optional inputs if available
+        if ipadapter_model_node:
+            apply_inputs["ipadapter"] = [ipadapter_model_node, 0]
+        if clip_vision_node:
+            apply_inputs["clip_vision"] = [clip_vision_node, 0]
+        
+        workflow[str(node_id)] = {
+            "class_type": ipadapter_apply,
+            "inputs": apply_inputs
+        }
+        new_model_node = str(node_id)
+        node_id += 1
+        
+        return workflow, new_model_node
+    
+    def inject_lora(
+        self,
+        workflow: Dict[str, Any],
+        lora_path: str,
+        strength: float = 0.8,
+        model_node_id: str = "1",
+        clip_node_id: Optional[str] = None,
+        start_node_id: int = 100
+    ) -> Tuple[Dict[str, Any], str, Optional[str]]:
+        """Inject LoRA into an existing workflow.
+        
+        Returns updated workflow, new model node ID, and new clip node ID.
+        """
+        lora_loader = self.find_node_for(STANDARD_REQUIREMENTS["load_lora"])
+        if not lora_loader:
+            print("No LoRA loader found - skipping LoRA injection")
+            return workflow, model_node_id, clip_node_id
+        
+        node_id = start_node_id
+        
+        lora_inputs = {
+            "lora_name": lora_path,
+            "strength_model": strength,
+            "strength_clip": strength,
+            "model": [model_node_id, 0],
+        }
+        
+        if clip_node_id:
+            lora_inputs["clip"] = [clip_node_id, 0]
+        
+        workflow[str(node_id)] = {
+            "class_type": lora_loader,
+            "inputs": lora_inputs
+        }
+        new_model_node = str(node_id)
+        new_clip_node = str(node_id) if clip_node_id else None
+        
+        return workflow, new_model_node, new_clip_node
+    
+    def inject_clip_vision_reference(
+        self,
+        workflow: Dict[str, Any],
+        reference_image: str,
+        start_node_id: int = 100
+    ) -> Tuple[Dict[str, Any], Optional[str]]:
+        """Inject CLIP Vision encoding for reference image (lighter alternative to IP-Adapter).
+        
+        This works even without full IP-Adapter by encoding the reference image
+        via CLIP Vision, which can be used for style guidance.
+        
+        Returns updated workflow and the clip vision output node ID.
+        """
+        clip_vision_loader = self.find_node_for(STANDARD_REQUIREMENTS["load_clip_vision"])
+        clip_vision_encode = self.find_node_for(STANDARD_REQUIREMENTS["encode_clip_vision"])
+        load_image = self.find_node_for(STANDARD_REQUIREMENTS["load_image"])
+        
+        if not (clip_vision_encode and load_image):
+            print("CLIP Vision encode or image loader not available")
+            return workflow, None
+        
+        node_id = start_node_id
+        
+        # Load reference image
+        workflow[str(node_id)] = {
+            "class_type": load_image,
+            "inputs": {"image": reference_image}
+        }
+        ref_image_node = str(node_id)
+        node_id += 1
+        
+        # Load CLIP Vision model (if needed)
+        clip_vision_node = None
+        if clip_vision_loader:
+            clip_vision_models = self.caps.get_clip_vision_models()
+            if clip_vision_models:
+                workflow[str(node_id)] = {
+                    "class_type": clip_vision_loader,
+                    "inputs": {"clip_name": clip_vision_models[0].filename}
+                }
+                clip_vision_node = str(node_id)
+                node_id += 1
+        
+        # Encode with CLIP Vision
+        encode_inputs = {"image": [ref_image_node, 0]}
+        if clip_vision_node:
+            encode_inputs["clip_vision"] = [clip_vision_node, 0]
+        
+        workflow[str(node_id)] = {
+            "class_type": clip_vision_encode,
+            "inputs": encode_inputs
+        }
+        clip_vision_output = str(node_id)
+        
+        return workflow, clip_vision_output
+    
+    def compose_with_character_reference(
+        self,
+        model: AvailableModel,
+        prompt: str,
+        reference_image: str,
+        character_strength: float = 0.8,
+        negative_prompt: str = "",
+        width: int = 512,
+        height: int = 512,
+        steps: int = 20,
+        cfg: float = 7.0,
+        seed: int = 0,
+        character_lora: Optional[str] = None,
+        character_lora_strength: float = 0.8
+    ) -> Optional[Dict[str, Any]]:
+        """Compose a text-to-image workflow with character reference.
+        
+        Uses IP-Adapter if available, falls back to CLIP Vision encoding.
+        """
+        # Start with base text-to-image workflow
+        workflow = self.compose_text_to_image(
+            model, prompt, negative_prompt, width, height, steps, cfg, seed
+        )
+        
+        if not workflow:
+            return None
+        
+        # Find the model node (typically node 1 from checkpoint loader)
+        model_node_id = "1"
+        clip_node_id = "1"  # CLIP is output 1 from checkpoint loader
+        
+        current_start_id = 100
+        
+        # Inject character LoRA if provided
+        if character_lora:
+            workflow, model_node_id, clip_node_id = self.inject_lora(
+                workflow,
+                character_lora,
+                character_lora_strength,
+                model_node_id,
+                clip_node_id,
+                current_start_id
+            )
+            current_start_id += 10
+        
+        # Try IP-Adapter first
+        if self.caps.has_ipadapter_support():
+            workflow, new_model_node = self.inject_ipadapter(
+                workflow,
+                reference_image,
+                character_strength,
+                model_node_id,
+                current_start_id
+            )
+            
+            # Update sampler to use new model node
+            for node_id, node in workflow.items():
+                if node.get("class_type", "").lower() in ["ksampler", "sampler"]:
+                    if "model" in node.get("inputs", {}):
+                        node["inputs"]["model"] = [new_model_node, 0]
+        
+        elif self.caps.has_reference_image_support():
+            # Fall back to CLIP Vision encoding
+            workflow, clip_vision_output = self.inject_clip_vision_reference(
+                workflow,
+                reference_image,
+                current_start_id
+            )
+            # Note: CLIP Vision output would need to be wired to compatible nodes
+            # This is a placeholder for systems without full IP-Adapter
+            print("Using CLIP Vision encoding (limited character consistency)")
+        
+        else:
+            print("No character reference support available on this system")
+        
+        return workflow
+    
     def compose_for_capability(
         self,
         capability: Capability,
@@ -448,6 +741,120 @@ class GeneralComposer:
             return None
 
 
+    def compose_from_request(
+        self,
+        request: GenerationRequest,
+        capability: Capability = Capability.TEXT_TO_IMAGE
+    ) -> Optional[Dict[str, Any]]:
+        """Compose a workflow from a GenerationRequest.
+        
+        Automatically handles character consistency if reference_image is provided.
+        """
+        # Find appropriate model
+        model = None
+        if request.model:
+            # Use specified model
+            for category_models in self.caps.models.values():
+                for m in category_models:
+                    if m.filename == request.model:
+                        model = m
+                        break
+                if model:
+                    break
+        
+        if not model:
+            model = self.find_model_for(capability)
+        
+        if not model:
+            print(f"No model found for {capability.value}")
+            return None
+        
+        # Compose based on whether we have character reference
+        if request.reference_image:
+            workflow = self.compose_with_character_reference(
+                model=model,
+                prompt=request.prompt,
+                reference_image=request.reference_image,
+                character_strength=request.character_strength,
+                negative_prompt=request.negative_prompt,
+                width=request.width,
+                height=request.height,
+                steps=request.steps,
+                cfg=request.cfg,
+                seed=request.seed,
+                character_lora=request.character_lora,
+                character_lora_strength=request.character_lora_strength
+            )
+        else:
+            # Standard composition
+            if capability == Capability.TEXT_TO_IMAGE:
+                workflow = self.compose_text_to_image(
+                    model, request.prompt, request.negative_prompt,
+                    request.width, request.height, request.steps,
+                    request.cfg, request.seed
+                )
+            elif capability in [Capability.TEXT_TO_VIDEO, Capability.IMAGE_TO_VIDEO]:
+                workflow = self.compose_text_to_video(
+                    model, request.prompt, request.negative_prompt,
+                    request.width, request.height, request.frames,
+                    request.steps, request.cfg, request.seed
+                )
+            else:
+                workflow = self.compose_for_capability(capability, request.prompt)
+        
+        # Inject additional LoRAs if specified
+        if workflow and request.loras:
+            model_node = "1"
+            clip_node = "1"
+            start_id = 200
+            
+            for lora_config in request.loras:
+                lora_path = lora_config.get("path", lora_config.get("name", ""))
+                lora_strength = lora_config.get("strength", 0.8)
+                
+                if lora_path:
+                    workflow, model_node, clip_node = self.inject_lora(
+                        workflow, lora_path, lora_strength,
+                        model_node, clip_node, start_id
+                    )
+                    start_id += 10
+        
+        return workflow
+    
+    def compose_for_character(
+        self,
+        profile: CharacterProfile,
+        prompt: str,
+        capability: Capability = Capability.TEXT_TO_IMAGE,
+        **kwargs
+    ) -> Optional[Dict[str, Any]]:
+        """Compose a workflow using a CharacterProfile for consistency.
+        
+        Convenience method that extracts reference settings from profile.
+        """
+        # Merge profile settings with any overrides
+        gen_params = profile.to_generation_params()
+        gen_params.update(kwargs)
+        
+        # Inject trigger words into prompt if available
+        full_prompt = prompt
+        if profile.trigger_words:
+            trigger_str = " ".join(profile.trigger_words)
+            full_prompt = f"{trigger_str}, {prompt}"
+        
+        # Add character description to prompt
+        if profile.description:
+            full_prompt = f"{profile.description}, {full_prompt}"
+        
+        # Create request
+        request = GenerationRequest(
+            prompt=full_prompt,
+            **gen_params
+        )
+        
+        return self.compose_from_request(request, capability)
+
+
 def create_composer(capabilities: SystemCapabilities) -> GeneralComposer:
     """Create a general composer from system capabilities."""
     return GeneralComposer(capabilities)

vibe_aigc/discovery.py

@@ -27,6 +27,8 @@ class Capability(Enum):
     UPSCALE = "upscale"
     INPAINT = "inpaint"
     AUDIO = "audio"
+    CHARACTER_CONSISTENCY = "character_consistency"  # IP-Adapter, LoRA character refs
+    STYLE_TRANSFER = "style_transfer"  # Style reference from images
     UNKNOWN = "unknown"
 
 
@@ -81,6 +83,14 @@ class AvailableModel:
         """Infer capability from filename patterns."""
         name = self.filename.lower()
         
+        # IP-Adapter / Character consistency models
+        if any(x in name for x in ['ipadapter', 'ip_adapter', 'ip-adapter', 'instantid', 'faceid', 'pulid']):
+            return Capability.CHARACTER_CONSISTENCY
+        
+        # Style transfer / reference models
+        if any(x in name for x in ['style', 'reference', 'clipvision']):
+            return Capability.STYLE_TRANSFER
+        
         # Video models
         if any(x in name for x in ['video', 'animate', 'motion', 'wan', 'ltx', 'svd', 'i2v', 't2v']):
             if 'i2v' in name or 'img2vid' in name:
@@ -104,6 +114,27 @@ class AvailableModel:
             return Capability.TEXT_TO_IMAGE
         
         return Capability.UNKNOWN
+    
+    @property
+    def is_ipadapter(self) -> bool:
+        """Check if this is an IP-Adapter model."""
+        name = self.filename.lower()
+        return any(x in name for x in ['ipadapter', 'ip_adapter', 'ip-adapter'])
+    
+    @property
+    def is_character_lora(self) -> bool:
+        """Check if this is a character/person LoRA."""
+        name = self.filename.lower()
+        # Character LoRAs often have these patterns
+        return self.category == 'loras' and any(x in name for x in [
+            'character', 'person', 'face', 'portrait', 'style', 'celeb'
+        ])
+    
+    @property
+    def is_clip_vision(self) -> bool:
+        """Check if this is a CLIP Vision model."""
+        name = self.filename.lower()
+        return self.category == 'clip_vision' or 'clipvision' in name or 'clip_vision' in name
 
 
 @dataclass
@@ -126,6 +157,55 @@ class SystemCapabilities:
                     result.append(model)
         return result
     
+    def get_ipadapter_models(self) -> List[AvailableModel]:
+        """Get all IP-Adapter models."""
+        result = []
+        for category in ['ipadapter', 'instantid', 'pulid', 'faceid']:
+            result.extend(self.models.get(category, []))
+        # Also check other categories for IP-Adapter files
+        for category_models in self.models.values():
+            for model in category_models:
+                if model.is_ipadapter and model not in result:
+                    result.append(model)
+        return result
+    
+    def get_clip_vision_models(self) -> List[AvailableModel]:
+        """Get all CLIP Vision models."""
+        result = list(self.models.get('clip_vision', []))
+        for category_models in self.models.values():
+            for model in category_models:
+                if model.is_clip_vision and model not in result:
+                    result.append(model)
+        return result
+    
+    def get_character_loras(self) -> List[AvailableModel]:
+        """Get all character/person LoRAs."""
+        result = []
+        for model in self.models.get('loras', []):
+            if model.is_character_lora:
+                result.append(model)
+        return result
+    
+    def has_ipadapter_support(self) -> bool:
+        """Check if full IP-Adapter workflow is possible."""
+        # Need IP-Adapter node + IP-Adapter model + CLIP Vision
+        node_names = set(n.lower() for n in self.nodes.keys())
+        has_ipadapter_node = any('ipadapter' in n for n in node_names)
+        has_ipadapter_model = bool(self.get_ipadapter_models())
+        has_clip_vision = bool(self.get_clip_vision_models()) or 'CLIPVisionLoader' in self.nodes
+        return has_ipadapter_node and (has_ipadapter_model or has_clip_vision)
+    
+    def has_reference_image_support(self) -> bool:
+        """Check if any reference image workflow is possible (IP-Adapter, ByteDance, etc.)."""
+        node_names = set(n.lower() for n in self.nodes.keys())
+        # Check for various reference image approaches
+        return (
+            any('ipadapter' in n for n in node_names) or
+            any('reference' in n and 'image' in n for n in node_names) or
+            any('bytedance' in n.lower() for n in node_names) or
+            'CLIPVisionEncode' in self.nodes  # Can encode reference images
+        )
+    
     def summary(self) -> str:
         """Human-readable summary."""
         lines = [
@@ -149,6 +229,15 @@ class SystemCapabilities:
             elif cap != Capability.UNKNOWN:
                 lines.append(f"  [NO]  {cap.value}")
         
+        # Character consistency details
+        lines.append("")
+        lines.append("Character Consistency:")
+        lines.append(f"  IP-Adapter support: {'YES' if self.has_ipadapter_support() else 'NO'}")
+        lines.append(f"  Reference image support: {'YES' if self.has_reference_image_support() else 'NO'}")
+        lines.append(f"  IP-Adapter models: {len(self.get_ipadapter_models())}")
+        lines.append(f"  CLIP Vision models: {len(self.get_clip_vision_models())}")
+        lines.append(f"  Character LoRAs: {len(self.get_character_loras())}")
+        
         return "\n".join(lines)
 
 
@@ -231,10 +320,12 @@ class SystemDiscovery:
         """Discover available models via /models/* endpoints."""
         models = {}
         
-        # Standard ComfyUI model categories
+        # Standard ComfyUI model categories + IP-Adapter related
         categories = [
             "checkpoints", "unet", "diffusion_models", "vae", 
-            "clip", "loras", "upscale_models", "embeddings"
+            "clip", "loras", "upscale_models", "embeddings",
+            # IP-Adapter / Character consistency related
+            "ipadapter", "clip_vision", "insightface", "instantid", "pulid", "faceid"
         ]
         
         for category in categories:
@@ -275,6 +366,20 @@ class SystemDiscovery:
         # Also check node availability for capabilities
         node_names = set(n.lower() for n in nodes.keys())
         
+        # IP-Adapter / Character consistency nodes
+        ip_adapter_patterns = ['ipadapter', 'ip_adapter', 'ip-adapter', 'instantid', 'faceid', 'pulid']
+        if any(any(p in n for p in ip_adapter_patterns) for n in node_names):
+            capabilities.add(Capability.CHARACTER_CONSISTENCY)
+        
+        # CLIP Vision (needed for IP-Adapter) - partial support for character refs
+        if any('clipvision' in n or 'clip_vision' in n for n in node_names):
+            # CLIP Vision enables style/image reference even without full IP-Adapter
+            capabilities.add(Capability.STYLE_TRANSFER)
+        
+        # ByteDance reference nodes (alternative to IP-Adapter)
+        if any('reference' in n and ('image' in n or 'bytedance' in n) for n in node_names):
+            capabilities.add(Capability.CHARACTER_CONSISTENCY)
+        
         # Video nodes
         if any('video' in n or 'animate' in n for n in node_names):
             capabilities.add(Capability.TEXT_TO_VIDEO)