From 6dc63a1bc2b456d9b88a8f9d840c7e2baf04a68d Mon Sep 17 00:00:00 2001
From: silveroxides <ishimarukaito@gmail.com>
Date: Sun, 8 Feb 2026 05:22:00 +0100
Subject: [PATCH] restore debug nodes

---
 __init__.py    |  25 +++++++-
 nodes_debug.py | 152 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 176 insertions(+), 1 deletion(-)
 create mode 100644 nodes_debug.py

diff --git a/__init__.py b/__init__.py
index 17ed4a4..b5f32bc 100644
--- a/__init__.py
+++ b/__init__.py
@@ -5,6 +5,7 @@ import comfy.utils
 import logging
 import re
 from comfy.sd1_clip import token_weights, escape_important, unescape_important
+from .nodes_debug import PromptEmbeddingFixer, InspectEmbeddingForClip
 
 def tokenize_preserving_weights(clip, text):
     """
@@ -33,6 +34,17 @@ def tokenize_preserving_weights(clip, text):
     
     found_any = False
     
+    # Try standard tokenization first to get a baseline for all parts
+    # This ensures we don't lose parts that we can't manually tokenize
+    try:
+        # Some tokenizers might not support llama_template, so we try with and without
+        try:
+            out = clip.tokenize(text, llama_template="{}")
+        except TypeError:
+            out = clip.tokenize(text)
+    except Exception:
+        out = {}
+    
     for attr in potential_parts:
         if hasattr(tokenizer, attr):
             sub_tok = getattr(tokenizer, attr)
@@ -187,7 +199,14 @@ def tokenize_preserving_weights(clip, text):
                     import traceback
                     traceback.print_exc()
 
-    if not found_any:
+    # If manual tokenization was attempted and succeeded for at least one part,
+    # 'out' now contains a mix of standard tokenization (for skipped parts)
+    # and manual tokenization (for parts that needed weight preservation).
+    # If no manual tokenization happened, we rely entirely on the initial clip.tokenize result.
+    
+    if not found_any and not out:
+        # If both failed (e.g. clip.tokenize failed earlier and no manual parts found)
+        # Try one last time or return empty
         return clip.tokenize(text, llama_template="{}")
         
     return out
@@ -875,6 +894,8 @@ NODE_CLASS_MAPPINGS = {
     "SaveWeightedEmbeddings": SaveWeightedEmbeddings,
     "SaveA1111WeightedEmbeddings": SaveA1111WeightedEmbeddings,
     "SliceExistingEmbedding": SliceExistingEmbedding,
+    "PromptEmbeddingFixer": PromptEmbeddingFixer,
+    "InspectEmbeddingForClip": InspectEmbeddingForClip,
 }
 
 NODE_DISPLAY_NAME_MAPPINGS = {
@@ -882,6 +903,8 @@ NODE_DISPLAY_NAME_MAPPINGS = {
     "SaveWeightedEmbeddings": "Save Weighted Embeddings",
     "SaveA1111WeightedEmbeddings": "Save A1111-style Weighted Embeddings",
     "SliceExistingEmbedding": "Slice Existing Embedding File",
+    "PromptEmbeddingFixer": "Prompt Embedding Fixer",
+    "InspectEmbeddingForClip": "Inspect Embedding For Clip",
 }
 
 __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']
\ No newline at end of file
diff --git a/nodes_debug.py b/nodes_debug.py
new file mode 100644
index 0000000..1a97741
--- /dev/null
+++ b/nodes_debug.py
@@ -0,0 +1,152 @@
+import torch
+import os
+import folder_paths
+import comfy.utils
+import re
+
+class PromptEmbeddingFixer:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "text": ("STRING", {"multiline": True, "dynamicPrompts": True}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "fix_prompt"
+    CATEGORY = "EmbeddingToolkit/Utils"
+
+    def fix_prompt(self, text):
+        # Add space before embedding if missing
+        text = re.sub(r'(?<!\s)(embedding:[^\s]+)', r' \1', text)
+        # Add space after embedding if missing
+        text = re.sub(r'(embedding:[^\s]+)(?!\s)', r'\1 ', text)
+        return (text,)
+
+class InspectEmbeddingForClip:
+    @classmethod
+    def INPUT_TYPES(cls):
+        try:
+            embedding_files = [f for f in folder_paths.get_filename_list("embeddings") if f.lower().endswith((".safetensors", ".pt"))]
+        except:
+            embedding_files = ["None"]
+
+        return {
+            "required": {
+                "clip": ("CLIP",),
+                "embedding_file": (embedding_files,),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "inspect_embedding"
+    CATEGORY = "EmbeddingToolkit/Debug"
+    OUTPUT_NODE = True
+
+    def inspect_embedding(self, clip, embedding_file):
+        output_text = []
+        output_text.append(f"Inspecting File: {embedding_file}")
+
+        # Load embedding
+        full_path = folder_paths.get_full_path("embeddings", embedding_file)
+        if not full_path:
+             output_text.append("Error: Embedding file not found.")
+             return {"ui": {"text": ["\n".join(output_text)]}}
+
+        try:
+            embed_data = comfy.utils.load_torch_file(full_path)
+            output_text.append(f"Keys found in file: {list(embed_data.keys())}")
+        except Exception as e:
+            output_text.append(f"Error loading file: {e}")
+            return {"ui": {"text": ["\n".join(output_text)]}}
+
+        # Inspect CLIP Wrapper
+        cond_model = clip.cond_stage_model
+        output_text.append(f"\nCLIP Model Wrapper: {type(cond_model).__name__}")
+
+        # Inspect Tokenizer Wrapper
+        tokenizer = clip.tokenizer
+        output_text.append(f"Tokenizer Wrapper: {type(tokenizer).__name__}")
+        if hasattr(tokenizer, "llama_template"):
+             output_text.append(f"  Template: {repr(tokenizer.llama_template)}")
+
+        # Check sub-models and sub-tokenizers
+        potential_parts = [
+            'clip_l', 'clip_g', 'clip_h',
+            't5xxl', 't5xl', 't5base',
+            'qwen25_7b', 'qwen25_3b', 'qwen3_4b', 'qwen3_8b', 'qwen3_2b', 'qwen3_06b',
+            'mistral3_24b', 'gemma2_2b', 'gemma3_4b', 'gemma3_12b',
+            'jina_clip_2', 'gemma', 'jina', 'byt5_small', 'llama'
+        ]
+
+        # Add dynamic parts from tokenizer
+        if hasattr(tokenizer, "clip") and isinstance(tokenizer.clip, str):
+            if tokenizer.clip not in potential_parts:
+                potential_parts.append(tokenizer.clip)
+
+        for part in potential_parts:
+            # Check Model
+            if hasattr(cond_model, part):
+                sub_model = getattr(cond_model, part)
+                output_text.append(f"\n--- Component: {part} ---")
+
+                # Check Tokenizer for this component
+                if hasattr(tokenizer, part):
+                    sub_tok = getattr(tokenizer, part)
+                    output_text.append(f"  Tokenizer: Found")
+                    output_text.append(f"    Embedding Dir: {getattr(sub_tok, 'embedding_directory', 'N/A')}")
+                    output_text.append(f"    Embedding ID: {repr(getattr(sub_tok, 'embedding_identifier', 'N/A'))}")
+                else:
+                    output_text.append(f"  Tokenizer: NOT FOUND on wrapper")
+
+                # Check Model Embedding Size
+                if hasattr(sub_model, "transformer") and sub_model.transformer is not None:
+                    try:
+                        weight = sub_model.transformer.get_input_embeddings().weight
+                        expected_size = weight.shape[-1]
+                        output_text.append(f"  Model Embedding Size: {expected_size}")
+                        
+                        # Check compatibility with file
+                        match_found = False
+
+                        # 1. Check exact key match
+                        if part in embed_data:
+                            emb = embed_data[part]
+                            output_text.append(f"  [MATCH] Key '{part}' found in file.")
+                            output_text.append(f"    File Shape: {emb.shape}")
+                            if emb.shape[-1] != expected_size:
+                                output_text.append(f"    [FAIL] Dimension mismatch! {emb.shape[-1]} vs {expected_size}")
+                            else:
+                                output_text.append(f"    [OK] Dimensions match.")
+                                match_found = True
+
+                        # 2. Check for single tensor fallback
+                        if not match_found and len(embed_data) == 1:
+                             val = list(embed_data.values())[0]
+                             if hasattr(val, "shape") and val.ndim >= 2:
+                                 output_text.append(f"  [CHECK] Checking single tensor fallback...")
+                                 if val.shape[-1] == expected_size:
+                                     output_text.append(f"    [OK] Fallback match! Shape: {val.shape}")
+                                     match_found = True
+                                 else:
+                                     output_text.append(f"    [FAIL] Fallback mismatch. {val.shape[-1]} vs {expected_size}")
+                        
+                        if not match_found:
+                             output_text.append(f"  [INFO] No compatible embedding found for this component.")
+                    
+                    except Exception as e:
+                        output_text.append(f"  Error inspecting model component: {e}")
+                else:
+                    output_text.append("  (No transformer found)")
+
+        return {"ui": {"text": ["\n".join(output_text)]}}
+
+NODE_CLASS_MAPPINGS = {
+    "PromptEmbeddingFixer": PromptEmbeddingFixer,
+    "InspectEmbeddingForClip": InspectEmbeddingForClip,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "PromptEmbeddingFixer": "Prompt Embedding Fixer",
+    "InspectEmbeddingForClip": "Inspect Embedding For Clip",
+}