feat: exclude coder LLMs from model list via user-configurable patterns

Add excluded_model_patterns config option that filters models at
fetch time (startup and refresh). Users can add patterns to
lms_config/user_config.json which is .gitignored so it survives updates.
Defaults to filtering embedding models only.

Author: EnragedAntelope

LMStudio.py

@@ -40,7 +40,8 @@
 # Attempt to fetch models at startup
 _startup_server_url = _config_manager.get_server_url()
 _startup_timeout = _config_manager.get_timeout()
-initialize_model_cache(_startup_server_url, _startup_timeout)
+_startup_excluded_patterns = _config_manager.get_excluded_patterns()
+initialize_model_cache(_startup_server_url, _startup_timeout, excluded_patterns=_startup_excluded_patterns)
 
 # Image resize options
 IMAGE_RESIZE_OPTIONS = [
@@ -460,13 +461,14 @@ def generate(
         config = _config_manager.get_config()
         server_url = _config_manager.get_server_url()
         timeout = _config_manager.get_timeout()
+        excluded_patterns = config.get("excluded_model_patterns", [])
 
         troubleshooting_lines.append(f"[INFO] Server: {server_url}")
         troubleshooting_lines.append(f"[INFO] Cached models: {get_cached_model_count()}")
 
         # Handle model refresh request
         if refresh_models:
-            success, message = refresh_model_cache(server_url, timeout)
+            success, message = refresh_model_cache(server_url, timeout, excluded_patterns=excluded_patterns)
             if success:
                 troubleshooting_lines.append(f"[INFO] Model refresh: {message}")
             else:

README.md

@@ -53,6 +53,22 @@ Edit `lms_config/user_config.json`:
 }
 ```
 
+## Model Exclusion Patterns
+
+Exclude models from the dropdown by adding patterns to `lms_config/user_config.json`:
+```json
+{
+    "excluded_model_patterns": ["embedding", "Qwen3-Coder", "codellama"]
+}
+```
+
+- The default excludes all models containing **"embedding"**.
+- Patterns are matched as case-insensitive substrings against the full model identifier.
+- Use specific enough patterns to avoid accidentally excluding desired models (e.g., use `Qwen3-Coder` instead of just `coder`).
+- To find exact model names, check LM Studio's API: `http://127.0.0.1:1234/v1/models` (look at the `id` field).
+- The `user_config.json` file is gitignored so your settings survive updates.
+- Restart ComfyUI or toggle the **refresh_models** checkbox after changing patterns.
+
 ## Outputs
 
 | Output | Description |

__init__.py

@@ -21,8 +21,9 @@ async def _refresh_models_route(request):
     config_manager = ConfigManager()
     server_url = config_manager.get_server_url()
     timeout = config_manager.get_timeout()
+    excluded_patterns = config_manager.get_excluded_patterns()
 
-    success, message = refresh_model_cache(server_url, timeout)
+    success, message = refresh_model_cache(server_url, timeout, excluded_patterns=excluded_patterns)
     choices = get_model_choices()
     models = [m for m in choices if m != CUSTOM_MODEL_OPTION]
 

lms_config/config_manager.py

@@ -5,14 +5,16 @@
 import json
 import logging
 from pathlib import Path
-from typing import Dict, Any
+from typing import Dict, Any, List
+
 
 logger = logging.getLogger("EA_LMStudio")
 
 DEFAULT_CONFIG: Dict[str, Any] = {
     "server_host": "127.0.0.1",
     "server_port": 1234,
-    "timeout_seconds": 5
+    "timeout_seconds": 5,
+    "excluded_model_patterns": ["embedding"],
 }
 
 
@@ -67,6 +69,31 @@ def get_timeout(self) -> float:
         config = self.get_config()
         return float(config.get("timeout_seconds", 5))
 
+    def get_excluded_patterns(self) -> List[str]:
+        """Get model exclusion patterns from config.
+
+        Returns a merged list: default patterns + user-specified additions.
+        The "embedding" pattern is always included and cannot be removed.
+        """
+        config = self.get_config()
+        val = config.get("excluded_model_patterns")
+
+        # Start with defaults
+        result: List[str] = list(DEFAULT_CONFIG["excluded_model_patterns"])
+
+        # Merge user patterns (type guard + dedup)
+        if isinstance(val, list):
+            for p in val:
+                if isinstance(p, str) and p not in result:
+                    result.append(p)
+        elif val is not None:
+            logger.warning(
+                "excluded_model_patterns in user_config.json is not a list. "
+                "Using defaults + any valid entries."
+            )
+
+        return result
+
     def create_user_config_template(self) -> None:
         """
         Create user config template file if it doesn't exist.
@@ -78,7 +105,8 @@ def create_user_config_template(self) -> None:
                 "_instructions": "Modify values below to override defaults. Delete this file to reset.",
                 "server_host": "127.0.0.1",
                 "server_port": 1234,
-                "timeout_seconds": 5
+                "timeout_seconds": 5,
+                "excluded_model_patterns": ["embedding"],
             }
             try:
                 with open(self.user_config_path, 'w', encoding='utf-8') as f:

lms_config/default_config.json

@@ -2,5 +2,8 @@
     "_comment": "Default configuration reference. Do not edit. Create user_config.json to override.",
     "server_host": "127.0.0.1",
     "server_port": 1234,
-    "timeout_seconds": 5
+    "timeout_seconds": 5,
+    "excluded_model_patterns": [
+        "embedding"
+    ]
 }

model_fetcher.py

@@ -5,7 +5,8 @@
 import re
 import requests
 import logging
-from typing import List, Tuple, Optional
+from typing import List, Optional
+
 
 logger = logging.getLogger("EA_LMStudio")
 
@@ -17,58 +18,73 @@
 # Constants
 CUSTOM_MODEL_OPTION = "-- Custom (enter below) --"
 
-# Patterns to exclude from model list (embedding models, etc.)
-EXCLUDED_MODEL_PATTERNS = ("embedding",)
-
 
-def validate_model_identifier(model_id: str) -> Tuple[bool, str]:
+def validate_model_identifier(model_id: str) -> bool:
     """
     Validate model identifier for safety.
 
     Args:
         model_id: The model identifier string to validate.
 
     Returns:
-        Tuple of (is_valid, error_message). error_message is empty if valid.
+        True if valid, False otherwise.
     """
     if not model_id or not model_id.strip():
-        return False, "Model identifier cannot be empty"
+        return False
 
     model_id = model_id.strip()
 
     # Check for path traversal attempts
     if ".." in model_id:
-        return False, "Model identifier contains invalid path sequence"
+        return False
 
     # Check reasonable length
     if len(model_id) > 256:
-        return False, "Model identifier exceeds maximum length (256 characters)"
+        return False
 
     # Allow alphanumeric, hyphens, underscores, dots, colons, at signs, forward slashes
     # These are common in model names like "lmstudio-community/Meta-Llama-3.1-8B-Instruct-GGUF"
     # or "qwen2.5-7b@q4_k_m"
     if not re.match(r'^[\w\-.:@/]+$', model_id):
-        return False, "Model identifier contains disallowed characters"
+        return False
+
+    return True
 
-    return True, ""
 
+def _is_excluded(model_id: str, excluded_patterns: List[str]) -> bool:
+    """Check if a model should be excluded based on configured patterns."""
+    if not excluded_patterns or not model_id:
+        return False
+    model_id_lower = model_id.lower()
+    return any(pattern in model_id_lower for pattern in excluded_patterns)
 
-def fetch_models_from_server(server_url: str, timeout: float = 5.0) -> Tuple[List[str], Optional[str]]:
+
+def fetch_models_from_server(
+    server_url: str,
+    timeout: float = 5.0,
+    excluded_patterns: Optional[List[str]] = None,
+) -> tuple[List[str], Optional[str]]:
     """
     Fetch available models from LM Studio server.
 
     Args:
         server_url: Base URL of LM Studio server (e.g., http://127.0.0.1:1234)
         timeout: Request timeout in seconds
+        excluded_patterns: List of substrings to exclude from model list.
+            If None, uses default ["embedding"]. Pass an empty list to include all models.
 
     Returns:
         Tuple of (model_list, error_message)
-        - model_list: List of model IDs (excludes embedding models), empty list on failure
+        - model_list: Filtered list of model IDs, empty on failure
         - error_message: None on success, descriptive error on failure
     """
     models: List[str] = []
     error: Optional[str] = None
 
+    # Default to ["embedding"] if no patterns specified
+    if excluded_patterns is None:
+        excluded_patterns = ["embedding"]
+
     endpoint = f"{server_url.rstrip('/')}/v1/models"
 
     try:
@@ -88,15 +104,14 @@ def fetch_models_from_server(server_url: str, timeout: float = 5.0) -> Tuple[Lis
             if not model_id:
                 continue
 
-            # Exclude embedding models by checking id pattern
-            model_id_lower = model_id.lower()
-            is_excluded = any(pattern in model_id_lower for pattern in EXCLUDED_MODEL_PATTERNS)
+            # Exclude models matching configured patterns
+            if _is_excluded(model_id, excluded_patterns):
+                logger.debug(f"EA_LMStudio: Excluding model '{model_id}'")
+                continue
 
-            if not is_excluded:
-                # Validate the model ID before adding
-                is_valid, _ = validate_model_identifier(model_id)
-                if is_valid:
-                    models.append(model_id)
+            # Validate the model ID before adding
+            if validate_model_identifier(model_id):
+                models.append(model_id)
 
         # Sort alphabetically for easier navigation
         models.sort(key=str.lower)
@@ -139,20 +154,26 @@ def get_model_choices() -> List[str]:
     return choices
 
 
-def refresh_model_cache(server_url: str, timeout: float = 5.0) -> Tuple[bool, str]:
+def refresh_model_cache(
+    server_url: str,
+    timeout: float = 5.0,
+    excluded_patterns: Optional[List[str]] = None,
+) -> tuple[bool, str]:
     """
     Refresh the cached model list from server.
 
     Args:
         server_url: Base URL of LM Studio server
         timeout: Request timeout in seconds
+        excluded_patterns: List of substrings to exclude from model list.
+            If None, uses default ["embedding"]. Pass an empty list to include all models.
 
     Returns:
         Tuple of (success, message)
     """
     global _cached_models, _last_fetch_error, _last_fetch_success
 
-    models, error = fetch_models_from_server(server_url, timeout)
+    models, error = fetch_models_from_server(server_url, timeout, excluded_patterns)
 
     if error:
         _last_fetch_error = error
@@ -169,15 +190,15 @@ def refresh_model_cache(server_url: str, timeout: float = 5.0) -> Tuple[bool, st
         return True, "Connected to LM Studio but no models found (embedding models are excluded)"
 
 
-def initialize_model_cache(server_url: str, timeout: float = 5.0) -> None:
+def initialize_model_cache(server_url: str, timeout: float = 5.0, excluded_patterns=None) -> None:
     """
     Initialize model cache at startup. Silent failure - just logs warning.
 
     Args:
         server_url: Base URL of LM Studio server
         timeout: Request timeout in seconds
     """
-    success, message = refresh_model_cache(server_url, timeout)
+    success, message = refresh_model_cache(server_url, timeout, excluded_patterns=excluded_patterns)
     if not success:
         logger.warning(f"EA_LMStudio startup: {message}")
         logger.warning("EA_LMStudio: Models will need to be entered manually or refreshed later")

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "EA_LMStudio"
 description = "A custom node for LM Studio integration into ComfyUI."
-version = "1.2.3"
+version = "1.3.1"
 license = {file = "LICENSE"}
 
 [project.urls]